Revert "Sema: Allow optional-to-optional CGFloat <-> Double conversion"

include/swift/AST/DiagnosticsSema.def

@@ -7563,6 +7563,13 @@ ERROR(result_builder_buildpartialblock_accumulated_not_accessible,none,
         "expression shuffles the elements of this tuple; "
         "this behavior is deprecated", ())
 
+//------------------------------------------------------------------------------
+// MARK: Implicit conversion diagnostics
+//------------------------------------------------------------------------------
+ERROR(cannot_implicitly_convert_in_optional_context,none,
+      "cannot implicitly convert value of type %0 to expected type %1",
+      (Type, Type))
+
 //------------------------------------------------------------------------------
 // MARK: marker protocol diagnostics
 //------------------------------------------------------------------------------

lib/Sema/CSDiagnostics.cpp

@@ -2852,6 +2852,22 @@ bool ContextualFailure::diagnoseAsError() {
     break;
   }
 
+  case ConstraintLocator::OptionalInjection: {
+    // If this is an attempt at a Double <-> CGFloat conversion
+    // through optional chaining, let's produce a tailored diagnostic.
+    if (isExpr<OptionalEvaluationExpr>(getAnchor())) {
+      if ((fromType->isDouble() || fromType->isCGFloat()) &&
+          (toType->isDouble() || toType->isCGFloat())) {
+        fromType = OptionalType::get(fromType);
+        toType = OptionalType::get(toType);
+        diagnostic = diag::cannot_implicitly_convert_in_optional_context;
+        break;
+      }
+    }
+
+    return false;
+  }
+
   case ConstraintLocator::EnumPatternImplicitCastMatch: {
     // In this case, the types are reversed, as we are checking whether we
     // can convert the pattern type to the context type.

lib/Sema/CSSimplify.cpp

@@ -7489,18 +7489,28 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
         // Look through all value-to-optional promotions to allow
         // conversions like Double -> CGFloat?? and vice versa.
         // T -> Optional<T>
-        if (location.endsWith<LocatorPathElt::OptionalInjection>() ||
-            location.endsWith<LocatorPathElt::GenericArgument>()) {
+        if (location.endsWith<LocatorPathElt::OptionalInjection>()) {
           SmallVector<LocatorPathElt, 4> path;
           auto anchor = location.getLocatorParts(path);
 
-          // Drop all of the applied `value-to-optional` and
-          // `optional-to-optional` conversions.
+          // An attempt at Double/CGFloat conversion through
+          // optional chaining. This is not supported at the
+          // moment because solution application doesn't know
+          // how to map Double to/from CGFloat through optionals.
+          if (isExpr<OptionalEvaluationExpr>(anchor)) {
+            if (!shouldAttemptFixes())
+              return getTypeMatchFailure(locator);
+
+            conversionsOrFixes.push_back(ContextualMismatch::create(
+                *this, nominal1, nominal2, getConstraintLocator(locator)));
+            break;
+          }
+
+          // Drop all of the applied `value-to-optional` promotions.
           path.erase(llvm::remove_if(
                          path,
                          [](const LocatorPathElt &elt) {
-                           return elt.is<LocatorPathElt::OptionalInjection>() ||
-                                  elt.is<LocatorPathElt::GenericArgument>();
+                           return elt.is<LocatorPathElt::OptionalInjection>();
                          }),
                      path.end());
 

test/Constraints/implicit_double_cgfloat_conversion.swift

@@ -350,7 +350,14 @@ func test_init_validation() {
   }
 }
 
-// Optional-to-optional conversion
-func optional_to_optional(x: CGFloat?) -> Double? {
-  return x
+func test_ternary_and_nil_coalescing() {
+  func test(_: Double?) {}
+
+  func ternary(v: CGFloat) {
+    test(true ? v : nil) // Ok
+  }
+
+  func test_nil_coalescing(v: CGFloat?) {
+    test(v ?? 0.0) // Ok
+  }
 }

validation-test/Sema/type_checker_crashers_fixed/rdar83666783.swift

@@ -12,5 +12,5 @@ func compute(_: Double?) -> Double? {
 }
 
 func test(s: S?) {
-  _ = compute(s?.test)
+  _ = compute(s?.test) // expected-error {{cannot implicitly convert value of type 'CGFloat?' to expected type 'Double?'}}
 }