Making sure to add explicit coercion path only for coercion constraint on disjunction.

Author: LucianoPAlmeida

lib/Sema/CSApply.cpp

@@ -3526,15 +3526,7 @@ namespace {
       auto rvalueSub = cs.coerceToRValue(expr->getSubExpr());
       expr->setSubExpr(rvalueSub);
 
-      auto *locator = [&]() {
-        // Only adding this path for explicty coercions e.g _ = a as Int
-        // and for non literal/array-literal subExpr.
-        if (!expr->isImplicit()
-            && !isa<LiteralExpr>(expr->getSubExpr())
-            && !isa<CollectionExpr>(expr->getSubExpr()))
-          return cs.getConstraintLocator(expr, LocatorPathElt::ExplicitTypeCoercion());
-        return cs.getConstraintLocator(expr);
-      }();
+      auto *locator = cs.getConstraintLocator(expr);
 
       // If we weren't explicitly told by the caller which disjunction choice,
       // get it from the solution to determine whether we've picked a coercion

lib/Sema/CSGen.cpp

@@ -2661,15 +2661,7 @@ namespace {
       CS.setType(expr->getCastTypeLoc(), toType);
 
       auto fromType = CS.getType(expr->getSubExpr());
-      auto locator = [&]() {
-        // Only adding this path for explicty coercions e.g _ = a as Int
-        // and for non literal/array-literal subExpr.
-        if (!expr->isImplicit()
-            && !isa<LiteralExpr>(expr->getSubExpr())
-            && !isa<CollectionExpr>(expr->getSubExpr()))
-          return CS.getConstraintLocator(expr, LocatorPathElt::ExplicitTypeCoercion());
-        return CS.getConstraintLocator(expr);
-      }();
+      auto locator = CS.getConstraintLocator(expr);
 
       // Add a conversion constraint for the direct conversion between
       // types.

lib/Sema/CSSimplify.cpp

@@ -7753,20 +7753,28 @@ void ConstraintSystem::addExplicitConversionConstraint(
   SmallVector<Constraint *, 3> constraints;
 
   auto locatorPtr = getConstraintLocator(locator);
-
+  auto coerceLocator = [&]() {
+    if (auto expr = dyn_cast_or_null<CoerceExpr>(locatorPtr->getAnchor())) {
+      // Only adding this path for explicty coercions e.g _ = a as Int
+      // and for non literal/array-literal subExpr.
+      if (!expr->isImplicit()
+          && !isa<LiteralExpr>(expr->getSubExpr())
+          && !isa<CollectionExpr>(expr->getSubExpr()))
+        return getConstraintLocator(expr, LocatorPathElt::ExplicitTypeCoercion());
+    }
+    return locatorPtr;
+  }();
   // Coercion (the common case).
   Constraint *coerceConstraint =
     Constraint::create(*this, ConstraintKind::Conversion,
-                       fromType, toType, locatorPtr);
+                       fromType, toType, coerceLocator);
   coerceConstraint->setFavored();
   constraints.push_back(coerceConstraint);
 
-  auto bridgingPtr = getConstraintLocator(
-                       locator.withPathElement(LocatorPathElt::BridgingTypeCoercion()));
   // The source type can be explicitly converted to the destination type.
   Constraint *bridgingConstraint =
   Constraint::create(*this, ConstraintKind::BridgingConversion,
-                     fromType, toType, bridgingPtr);
+                     fromType, toType, locatorPtr);
   constraints.push_back(bridgingConstraint);
 
   if (allowFixes && shouldAttemptFixes()) {

lib/Sema/ConstraintLocator.cpp

@@ -85,7 +85,6 @@ void ConstraintLocator::Profile(llvm::FoldingSetNodeID &id, Expr *anchor,
     case KeyPathValue:
     case KeyPathComponentResult:
     case ExplicityTypeCoercion:
-    case BridgingTypeCoercion:
       auto numValues = numNumericValuesInPathElement(elt.getKind());
       for (unsigned i = 0; i < numValues; ++i)
         id.AddInteger(elt.getValue(i));
@@ -418,10 +417,6 @@ void ConstraintLocator::dump(SourceManager *sm, raw_ostream &out) {
     case ExplicityTypeCoercion:
       out << "type coercion";
       break;
-      
-    case BridgingTypeCoercion:
-      out << "bridging type coercion";
-      break;
     }
   }
   out << ']';

lib/Sema/ConstraintLocator.h

@@ -139,8 +139,6 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     KeyPathComponentResult,
     /// A explicity type coercion
     ExplicityTypeCoercion,
-    /// A bridging type coercion
-    BridgingTypeCoercion
   };
 
   /// Determine the number of numeric values used for the given path
@@ -175,7 +173,6 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     case KeyPathValue:
     case KeyPathComponentResult:
     case ExplicityTypeCoercion:
-    case BridgingTypeCoercion:
       return 0;
 
     case ContextualType:
@@ -248,7 +245,6 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     case KeyPathValue:
     case KeyPathComponentResult:
     case ExplicityTypeCoercion:
-    case BridgingTypeCoercion:
       return 0;
 
     case FunctionArgument:
@@ -368,7 +364,6 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     class OpenedGeneric;
     class KeyPathDynamicMember;
     class ExplicitTypeCoercion;
-    class BridgingTypeCoercion;
 
     PathElement(PathElementKind kind)
       : storage(encodeStorage(kind, 0)), storedKind(StoredKindAndValue)
@@ -909,17 +904,6 @@ class LocatorPathElt::ExplicitTypeCoercion final : public LocatorPathElt {
   }
 };
 
-
-class LocatorPathElt::BridgingTypeCoercion final : public LocatorPathElt {
-public:
-  BridgingTypeCoercion()
-  : LocatorPathElt(ConstraintLocator::BridgingTypeCoercion) {}
-
-  static bool classof(const LocatorPathElt *elt) {
-    return elt->getKind() == ConstraintLocator::BridgingTypeCoercion;
-  }
-};
-
 /// A simple stack-only builder object that constructs a
 /// constraint locator without allocating memory.
 ///