[CSApply] A couple of locator adjustments to support updated Double<->CGFloat conversion

lib/Sema/CSApply.cpp

@@ -3481,9 +3481,11 @@ namespace {
 
       auto elementType = expr->getElementType();
 
-      for (auto &element : expr->getElements()) {
-        element = coerceToType(element, elementType,
-                               cs.getConstraintLocator(element));
+      for (unsigned i = 0, n = expr->getNumElements(); i != n; ++i) {
+        expr->setElement(
+            i, coerceToType(expr->getElement(i), elementType,
+                            cs.getConstraintLocator(
+                                expr, {LocatorPathElt::TupleElement(i)})));
       }
 
       return expr;
@@ -3526,9 +3528,12 @@ namespace {
       expr->setInitializer(witness);
 
       auto elementType = expr->getElementType();
-      for (auto &element : expr->getElements()) {
-        element = coerceToType(element, elementType,
-                               cs.getConstraintLocator(element));
+
+      for (unsigned i = 0, n = expr->getNumElements(); i != n; ++i) {
+        expr->setElement(
+            i, coerceToType(expr->getElement(i), elementType,
+                            cs.getConstraintLocator(
+                                expr, {LocatorPathElt::TupleElement(i)})));
       }
 
       return expr;
@@ -3730,10 +3735,12 @@ namespace {
       expr->setCondExpr(cond);
 
       // Coerce the then/else branches to the common type.
-      expr->setThenExpr(coerceToType(expr->getThenExpr(), resultTy,
-                               cs.getConstraintLocator(expr->getThenExpr())));
-      expr->setElseExpr(coerceToType(expr->getElseExpr(), resultTy,
-                                 cs.getConstraintLocator(expr->getElseExpr())));
+      expr->setThenExpr(coerceToType(
+          expr->getThenExpr(), resultTy,
+          cs.getConstraintLocator(expr, LocatorPathElt::TernaryBranch(true))));
+      expr->setElseExpr(coerceToType(
+          expr->getElseExpr(), resultTy,
+          cs.getConstraintLocator(expr, LocatorPathElt::TernaryBranch(false))));
 
       return expr;
     }
@@ -4305,9 +4312,12 @@ namespace {
     Expr *visitAssignExpr(AssignExpr *expr) {
       // Convert the source to the simplified destination type.
       auto destTy = simplifyType(cs.getType(expr->getDest()));
-      auto locator =
-        ConstraintLocatorBuilder(cs.getConstraintLocator(expr->getSrc()));
-      Expr *src = coerceToType(expr->getSrc(), destTy->getRValueType(), locator);
+      // Conversion is recorded as anchored on an assignment itself by
+      // constraint generator and that has to be preserved here in case
+      // anything depends on the locator (i.e. Double<->CGFloat implicit
+      // conversion).
+      Expr *src = coerceToType(expr->getSrc(), destTy->getRValueType(),
+                               cs.getConstraintLocator(expr));
       if (!src)
         return nullptr;
 
@@ -6752,6 +6762,11 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       auto *argExpr = locator.trySimplifyToExpr();
       assert(argExpr);
 
+      // Source requires implicit conversion to match destination
+      // type but the conversion itself is recorded on assignment.
+      if (auto *assignment = dyn_cast<AssignExpr>(argExpr))
+        argExpr = assignment->getSrc();
+
       // Load the value for conversion.
       argExpr = cs.coerceToRValue(argExpr);
 

lib/Sema/ConstraintSystem.cpp

@@ -429,6 +429,11 @@ ConstraintLocator *ConstraintSystem::getImplicitValueConversionLocator(
   SmallVector<LocatorPathElt, 4> path;
   auto anchor = root.getLocatorParts(path);
   {
+    if (isExpr<DictionaryExpr>(anchor) && path.size() > 1) {
+      // Drop everything except for first `tuple element #`.
+      path.pop_back_n(path.size() - 1);
+    }
+
     // Drop any value-to-optional conversions that were applied along the
     // way to reach this one.
     while (!path.empty()) {

test/Constraints/implicit_double_cgfloat_conversion.swift

@@ -216,3 +216,49 @@ func test_multi_argument_conversion_with_optional(d: Double, cgf: CGFloat) {
 
   test(cgf, d) // Ok (CGFloat -> Double and Double? -> CGFloat?)
 }
+
+extension CGFloat: Hashable {
+  public func hash(into hasher: inout Hasher) { fatalError() }
+}
+
+func test_collection_literals_as_call_arguments() {
+  enum E {
+    case test_arr([CGFloat])
+    case test_dict_key([CGFloat: String])
+    case test_dict_value([String: CGFloat])
+    case test_arr_nested([String: [[CGFloat]: String]])
+    case test_dict_nested([String: [String: CGFloat]])
+  }
+
+  struct Container {
+    var prop: E
+  }
+
+  struct Point {
+    var x: Double
+    var y: Double
+  }
+
+  func test(cont: inout Container, point: Point) {
+    cont.prop = .test_arr([point.x]) // Ok
+    cont.prop = .test_dict_key([point.y: ""]) // Ok
+    cont.prop = .test_dict_value(["": point.y]) // Ok
+    cont.prop = .test_arr_nested(["": [[point.x]: ""]]) // Ok
+    cont.prop = .test_dict_nested(["": ["": point.x]]) // Ok
+  }
+}
+
+func assignments_with_and_without_optionals() {
+  class C {
+    var prop: CGFloat = 0
+  }
+
+  func test(c: C?, v: Double, cgf: CGFloat) {
+    c?.prop = v / 2.0 // Ok
+    c?.prop = (false ? cgf : v)
+
+    let copy = c!
+    copy.prop = Optional(v) ?? 0 // Ok
+    copy.prop = (true ? cgf : (false ? v : cgf))
+  }
+}