Implemeting fixit and custom failure diagnostics

Author: LucianoPAlmeida

Diff for: lib/Sema/CSDiagnostics.cpp

@@ -4334,3 +4334,12 @@ bool ThrowingFunctionConversionFailure::diagnoseAsError() {
                  getFromType(), getToType());
   return true;
 }
+
+bool UnecessaryCoecionFailure::diagnoseAsError() {
+  auto expr = dyn_cast<CoerceExpr>(getAnchor());
+  
+  emitDiagnostic(expr->getLoc(), diag::unecessary_same_type_coercion, getToType())
+      .fixItRemove(SourceRange(expr->getLoc(),
+                               expr->getCastTypeLoc().getSourceRange().End));
+  return true;
+}

Diff for: lib/Sema/CSDiagnostics.h

@@ -1316,11 +1316,11 @@ class MutatingMemberRefOnImmutableBase final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
-// Diagnose an attempt to use AnyObject as the root type of a KeyPath
-//
-// ```swift
-// let keyPath = \AnyObject.bar
-// ```
+/// Diagnose an attempt to use AnyObject as the root type of a KeyPath
+///
+/// ```swift
+/// let keyPath = \AnyObject.bar
+/// ```
 class AnyObjectKeyPathRootFailure final : public FailureDiagnostic {
 
 public:
@@ -1595,6 +1595,20 @@ class InvalidTupleSplatWithSingleParameterFailure final
   bool diagnoseAsError() override;
 };
 
+class UnecessaryCoecionFailure final : public FailureDiagnostic {
+  Type toType;
+
+public:
+  UnecessaryCoecionFailure(ConstraintSystem &cs,
+                           Type toType,
+                           ConstraintLocator *locator)
+  : FailureDiagnostic(locator->getAnchor(), cs, locator), toType(toType) {}
+  
+  Type getToType() { return toType; }
+  
+  bool diagnoseAsError() override;
+};
+
 /// Provides information about the application of a function argument to a
 /// parameter.
 class FunctionArgApplyInfo {

Diff for: lib/Sema/CSFix.cpp

@@ -775,15 +775,16 @@ IgnoreContextualType *IgnoreContextualType::create(ConstraintSystem &cs,
 }
 
 bool RemoveUnecessaryCoercion::diagnose(Expr *root, bool asNote) const {
-  // TODO: Create custom diag for that?
-  return false;
+  auto &cs = getConstraintSystem();
+
+  UnecessaryCoecionFailure failure(cs, getToType(), getLocator());
+  return failure.diagnoseAsError();
 }
 
 RemoveUnecessaryCoercion
 *RemoveUnecessaryCoercion::create(ConstraintSystem &cs,
-                                  Type fromType,
                                   Type toType,
                                   ConstraintLocator *locator) {
   return new (cs.getAllocator())
-      RemoveUnecessaryCoercion(cs, fromType, toType, locator);
+      RemoveUnecessaryCoercion(cs, toType, locator);
 }

Diff for: lib/Sema/CSFix.h

@@ -1316,24 +1316,22 @@ class IgnoreContextualType : public ContextualMismatch {
 };
 
 class RemoveUnecessaryCoercion : public ConstraintFix {
-  Type LHS, RHS;
+  Type toType;
 
 protected:
-  RemoveUnecessaryCoercion(ConstraintSystem &cs, Type lhs, Type rhs,
-                     ConstraintLocator *locator)
-  : ConstraintFix(cs, FixKind::RemoveUnecessaryCoercion, locator), LHS(lhs),
-  RHS(rhs) {}
+  RemoveUnecessaryCoercion(ConstraintSystem &cs, Type toType,
+                           ConstraintLocator *locator)
+  : ConstraintFix(cs, FixKind::RemoveUnecessaryCoercion, locator, /*isWarning*/ true), toType(toType) {}
 
 
 public:
   std::string getName() const override { return "remove unecessary explicit type coercion"; }
 
-  Type getFromType() const { return LHS; }
-  Type getToType() const { return RHS; }
+  Type getToType() const { return toType; }
 
   bool diagnose(Expr *root, bool asNote = false) const override;
 
-  static RemoveUnecessaryCoercion *create(ConstraintSystem &cs, Type lhs, Type rhs,
+  static RemoveUnecessaryCoercion *create(ConstraintSystem &cs, Type toType,
                                           ConstraintLocator *locator);
 };
 

Diff for: lib/Sema/CSSimplify.cpp

@@ -2748,8 +2748,10 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
 
   // If the types are obviously equivalent, we're done.
   if (desugar1->isEqual(desugar2)) {
-    if (kind == ConstraintKind::Conversion) {
-      // TODO: Create fix it or emit diagnostic?
+    if (locator.getBaseLocator()->isLastElement(ConstraintLocator::PathElementKind::TypeCoercion)) {
+      auto *fix = RemoveUnecessaryCoercion::create(*this, type2,
+                                                   locator.getBaseLocator());
+      recordFix(fix);
     }
     if (!isa<InOutType>(desugar2))
       return getTypeMatchSuccess();

Diff for: lib/Sema/ConstraintLocator.h

@@ -471,7 +471,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
   bool isFunctionConversion() const {
     return (getSummaryFlags() & IsFunctionConversion);
   }
-  
+
   /// Determine whether given locator points to the subscript reference
   /// e.g. `foo[0]` or `\Foo.[0]`
   bool isSubscriptMemberRef() const;