Changing implementation to the PR suggestion

Author: LucianoPAlmeida

lib/Sema/CSApply.cpp

@@ -3533,15 +3533,6 @@ namespace {
         Expr *sub = expr->getSubExpr();
 
         cs.setExprTypes(sub);
-        
-        if (!SuppressDiagnostics) {
-          // If we are trying to perform coercion to the same type emit a warning.
-          if (cs.getType(sub)->isEqual(toType)) {
-            tc.diagnose(expr->getLoc(), diag::unecessary_same_type_coercion, toType)
-              .fixItRemove(SourceRange(expr->getLoc(),
-                                       expr->getCastTypeLoc().getSourceRange().End));
-          }
-        }
 
         if (tc.convertToType(sub, toType, cs.DC))
           return nullptr;

lib/Sema/CSGen.cpp

@@ -2659,7 +2659,9 @@ namespace {
       CS.setType(expr->getCastTypeLoc(), toType);
 
       auto fromType = CS.getType(expr->getSubExpr());
-      auto locator = CS.getConstraintLocator(expr);
+      
+      auto pathElt = LocatorPathElt(ConstraintLocator::TypeCoercion);
+      auto locator = CS.getConstraintLocator(expr, pathElt);
 
       // Add a conversion constraint for the direct conversion between
       // types.

lib/Sema/CSSimplify.cpp

@@ -2811,6 +2811,19 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
                                          formUnsolvedResult);
         }
       }
+      
+      if (locator.getBaseLocator()->isTypeCoercion()) {
+        auto expr = dyn_cast<CoerceExpr>(locator.getBaseLocator()->getAnchor());
+        if (!shouldSuppressDiagnostics()) {
+          // If we are trying to perform coercion to the same type emit a warning.
+          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();
     }
 

lib/Sema/ConstraintLocator.cpp

@@ -84,6 +84,7 @@ void ConstraintLocator::Profile(llvm::FoldingSetNodeID &id, Expr *anchor,
     case KeyPathRoot:
     case KeyPathValue:
     case KeyPathComponentResult:
+    case TypeCoercion:
       if (unsigned numValues = numNumericValuesInPathElement(elt.getKind())) {
         id.AddInteger(elt.getValue());
         if (numValues > 1)
@@ -94,6 +95,18 @@ void ConstraintLocator::Profile(llvm::FoldingSetNodeID &id, Expr *anchor,
   }
 }
 
+/// Determine whether given locator points to the type coercion
+/// e.g. "Hello" as String
+bool ConstraintLocator::isTypeCoercion() const {
+  auto *anchor = getAnchor();
+  auto path = getPath();
+  
+  if (!anchor || path.empty())
+    return false;
+  
+  return path.back().getKind() == ConstraintLocator::TypeCoercion;
+}
+
 /// Determine whether given locator points to the subscript reference
 /// e.g. `foo[0]` or `\Foo.[0]`
 bool ConstraintLocator::isSubscriptMemberRef() const {
@@ -402,6 +415,10 @@ void ConstraintLocator::dump(SourceManager *sm, raw_ostream &out) {
     case KeyPathComponentResult:
       out << "key path component result";
       break;
+        
+    case TypeCoercion:
+      out << "type coercion";
+      break;
     }
   }
   out << ']';

lib/Sema/ConstraintLocator.h

@@ -139,6 +139,8 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     KeyPathValue,
     /// The result type of a key path component. Not used for subscripts.
     KeyPathComponentResult,
+    /// A type coercion
+    TypeCoercion,
   };
 
   /// Determine the number of numeric values used for the given path
@@ -173,6 +175,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     case KeyPathRoot:
     case KeyPathValue:
     case KeyPathComponentResult:
+    case TypeCoercion:
       return 0;
 
     case ContextualType:
@@ -244,6 +247,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     case KeyPathRoot:
     case KeyPathValue:
     case KeyPathComponentResult:
+    case TypeCoercion:
       return 0;
 
     case FunctionArgument:
@@ -553,6 +557,10 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     return (getSummaryFlags() & IsFunctionConversion);
   }
 
+  /// Determine whether given locator points to the type coercion
+  /// e.g. "Hello" as String
+  bool isTypeCoercion() const;
+  
   /// Determine whether given locator points to the subscript reference
   /// e.g. `foo[0]` or `\Foo.[0]`
   bool isSubscriptMemberRef() const;