[CSApply] Adjust locator while coercion source of assignment to destination type

Constraint generator records conversion between source and destination
types as anchored on an assignment, which means that coercion has to do
the same in case restrictions (like Double<->CGFloat conversion) depend
on locators to retrieve information for the solution.

Author: xedin

lib/Sema/CSApply.cpp

@@ -4310,9 +4310,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;
 
@@ -6757,6 +6760,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);
 

test/Constraints/implicit_double_cgfloat_conversion.swift

@@ -247,3 +247,16 @@ func test_collection_literals_as_call_arguments() {
     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) {
+    c?.prop = v / 2.0 // Ok
+
+    let copy = c!
+    copy.prop = Optional(v) ?? 0 // Ok
+  }
+}