Updating implementation

Author: LucianoPAlmeida

lib/Sema/CSFix.cpp

@@ -773,3 +773,17 @@ IgnoreContextualType *IgnoreContextualType::create(ConstraintSystem &cs,
   return new (cs.getAllocator())
       IgnoreContextualType(cs, resultTy, specifiedTy, locator);
 }
+
+bool RemoveUnecessaryCoercion::diagnose(Expr *root, bool asNote) const {
+  // TODO: Create custom diag for that?
+  return false;
+}
+
+RemoveUnecessaryCoercion
+*RemoveUnecessaryCoercion::create(ConstraintSystem &cs,
+                                  Type fromType,
+                                  Type toType,
+                                  ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      RemoveUnecessaryCoercion(cs, fromType, toType, locator);
+}

lib/Sema/CSFix.h

@@ -195,6 +195,9 @@ enum class FixKind : uint8_t {
   /// Allow a single tuple parameter to be matched with N arguments
   /// by forming all of the given arguments into a single tuple.
   AllowTupleSplatForSingleParameter,
+  
+  /// Remove a unecessary coercion ('as') if the types are already equal. e.g. "Hello" as String
+  RemoveUnecessaryCoercion,
 };
 
 class ConstraintFix {
@@ -1312,6 +1315,28 @@ class IgnoreContextualType : public ContextualMismatch {
                                       ConstraintLocator *locator);
 };
 
+class RemoveUnecessaryCoercion : public ConstraintFix {
+  Type LHS, RHS;
+  
+protected:
+  RemoveUnecessaryCoercion(ConstraintSystem &cs, Type lhs, Type rhs,
+                     ConstraintLocator *locator)
+  : ConstraintFix(cs, FixKind::RemoveUnecessaryCoercion, locator), LHS(lhs),
+  RHS(rhs) {}
+
+  
+public:
+  std::string getName() const override { return "remove unecessary explicit type coercion"; }
+  
+  Type getFromType() const { return LHS; }
+  Type getToType() const { return RHS; }
+  
+  bool diagnose(Expr *root, bool asNote = false) const override;
+  
+  static RemoveUnecessaryCoercion *create(ConstraintSystem &cs, Type lhs, Type rhs,
+                                          ConstraintLocator *locator);
+};
+
 } // end namespace constraints
 } // end namespace swift
 

lib/Sema/CSSimplify.cpp

@@ -2747,9 +2747,13 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
   auto desugar2 = type2->getDesugaredType();
 
   // If the types are obviously equivalent, we're done.
-  if (desugar1->isEqual(desugar2) &&
-      !isa<InOutType>(desugar2))
-    return getTypeMatchSuccess();
+  if (desugar1->isEqual(desugar2)) {
+    if (kind == ConstraintKind::Conversion) {
+      // TODO: Create fix it or emit diagnostic?
+    }
+    if (!isa<InOutType>(desugar2))
+      return getTypeMatchSuccess();
+  }
 
   // Local function that should be used to produce the return value whenever
   // this function was unable to resolve the constraint. It should be used
@@ -2890,20 +2894,7 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
                                          formUnsolvedResult);
         }
       }
-      
-      // If we are trying to perform coercion to the same type emit a warning.
-      if (locator.getBaseLocator()->isTypeCoercion()) {
-        if (auto expr = dyn_cast<CoerceExpr>(locator.getBaseLocator()->getAnchor())) {
-          if (!shouldSuppressDiagnostics()) {
-            if (type1->getCanonicalType()->isEqual(type2->getCanonicalType())) {
-              TC.diagnose(expr->getLoc(), diag::unecessary_same_type_coercion, type2)
-                .fixItRemove(SourceRange(expr->getLoc(),
-                                         expr->getCastTypeLoc().getSourceRange().End));
-            }
-          }
-        }
-      }
-      
+
       return formUnsolvedResult();
     }
 
@@ -7363,6 +7354,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::GenericArgumentsMismatch:
   case FixKind::AllowMutatingMemberOnRValueBase:
   case FixKind::AllowTupleSplatForSingleParameter:
+  case FixKind::RemoveUnecessaryCoercion:
     llvm_unreachable("handled elsewhere");
   }
 
@@ -7616,9 +7608,7 @@ void ConstraintSystem::addExplicitConversionConstraint(
   auto locatorPtr = getConstraintLocator(locator);
 
   // Coercion (the common case).
-  auto coercionPath = LocatorPathElt(ConstraintLocator::TypeCoercion);
-  auto coerceLocator = getConstraintLocator(locator.getBaseLocator(),
-                                            coercionPath);
+  auto coerceLocator = getConstraintLocator(locator.getBaseLocator(), LocatorPathElt::TypeCoercion());
   Constraint *coerceConstraint =
     Constraint::create(*this, ConstraintKind::Conversion,
                        fromType, toType, coerceLocator);

lib/Sema/ConstraintLocator.h

@@ -34,6 +34,7 @@ namespace swift {
 
 class Expr;
 class SourceManager;
+class CoerceExpr;
 
 namespace constraints {
   class ConstraintSystem;
@@ -367,6 +368,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     class GenericParameter;
     class OpenedGeneric;
     class KeyPathDynamicMember;
+    class TypeCoercion;
 
     PathElement(PathElementKind kind)
       : storage(encodeStorage(kind, 0)), storedKind(StoredKindAndValue)
@@ -897,6 +899,16 @@ class LocatorPathElt::KeyPathDynamicMember final : public LocatorPathElt {
   }
 };
 
+class LocatorPathElt::TypeCoercion final : public LocatorPathElt {
+public:
+  TypeCoercion()
+  : LocatorPathElt(ConstraintLocator::TypeCoercion) {}
+  
+  static bool classof(const LocatorPathElt *elt) {
+    return elt->getKind() == ConstraintLocator::TypeCoercion;
+  }
+};
+
 /// A simple stack-only builder object that constructs a
 /// constraint locator without allocating memory.
 ///