[TypeChecker] Allow Double<->CGFloat conversion with optional promotions

There are APIs that expect a `Double?` or `CGFloat?` argument
and it should be possible to pass `CGFloat` and `Double` respectively.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -5131,14 +5131,36 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
           nominal1->getDecl() != nominal2->getDecl() &&
           ((nominal1->isCGFloatType() || nominal2->isCGFloatType()) &&
            (nominal1->isDoubleType() || nominal2->isDoubleType()))) {
+        ConstraintLocatorBuilder location{locator};
+        // Look through all value-to-optional promotions to allow
+        // conversions like Double -> CGFloat?? and vice versa.
+        if (auto last = location.last()) {
+          // T -> Optional<T>
+          if (last->is<LocatorPathElt::OptionalPayload>()) {
+            SmallVector<LocatorPathElt, 4> path;
+            auto anchor = location.getLocatorParts(path);
+
+            // Drop all of the applied `value-to-optional` promotions.
+            path.erase(llvm::remove_if(
+                           path,
+                           [](const LocatorPathElt &elt) {
+                             return elt.is<LocatorPathElt::OptionalPayload>();
+                           }),
+                       path.end());
+
+            location = getConstraintLocator(anchor, path);
+          }
+        }
+
         // Support implicit Double<->CGFloat conversions only for
         // something which could be directly represented in the AST
         // e.g. argument-to-parameter, contextual conversions etc.
-        if (!locator.trySimplifyToExpr())
+        if (!location.trySimplifyToExpr()) {
           return getTypeMatchFailure(locator);
+        }
 
         SmallVector<LocatorPathElt, 4> path;
-        auto anchor = locator.getLocatorParts(path);
+        auto anchor = location.getLocatorParts(path);
 
         // Try implicit CGFloat conversion only if:
         // - This is not:

test/Constraints/implicit_double_cgfloat_conversion.swift

@@ -192,3 +192,20 @@ func test_no_ambiguity_with_unary_operators(width: CGFloat, height: CGFloat) {
   // CHECK: function_ref @$s34implicit_double_cgfloat_conversion38test_no_ambiguity_with_unary_operators5width6heighty12CoreGraphics7CGFloatV_AGtF1RL_V1x1yAcdiG_A3GtcfC
   _ = R(x: width / 4, y: -height / 2, width: width, height: height)
 }
+
+func test_conversions_with_optional_promotion(d: Double, cgf: CGFloat) {
+  func test_double(_: Double??) {}
+  func test_cgfloat(_: CGFloat??) {}
+
+  // CHECK: function_ref @$sSd12CoreGraphicsEySdAA7CGFloatVcfC
+  // CHECK-NEXT: apply
+  // CHECK-NEXT: enum $Optional<Double>, #Optional.some!enumelt
+  // CHECK-NEXT: enum $Optional<Optional<Double>>, #Optional.some!enumelt
+  test_double(cgf)
+
+  // CHECK: function_ref @$s12CoreGraphics7CGFloatVyACSdcfC
+  // CHECK-NEXT: apply
+  // CHECK-NEXT: enum $Optional<CGFloat>, #Optional.some!enumelt
+  // CHECK-NEXT: enum $Optional<Optional<CGFloat>>, #Optional.some!enumelt
+  test_cgfloat(d)
+}

test/Misc/misc_diagnostics.swift

@@ -228,4 +228,10 @@ func test_implicit_cgfloat_conversion() {
     }
     _ = S(x: 0.0, y: values.0) // Ok
   }
+
+  func allow_optional_promotion_double(_: Double??) {}
+  func allow_optional_promotion_cgfloat(_: CGFloat??) {}
+
+  allow_optional_promotion_double(cgf) // Ok -> CGFloat -> Double -> Double??
+  allow_optional_promotion_cgfloat(d) // Ok -> Double -> CGFloat -> CFloat??
 }