[ConstraintSystem] Limit new implicit conversion to only Double <-> CGFloat

Author: xedin

include/swift/Sema/Constraint.h

@@ -258,12 +258,12 @@ enum class ConversionRestrictionKind {
   /// Implicit conversion from an Objective-C class type to its
   /// toll-free-bridged CF type.
   ObjCTollFreeBridgeToCF,
-  /// Implicit conversion from a CGFloat to another compatible type via
+  /// Implicit conversion from a value of Double to a value of CGFloat type via
   /// an implicit CGFloat initializer call.
-  TypeToCGFloat,
-  /// Implicit conversion from a compatible value to a CGFloat via
-  /// an implicit call to an initializer passing CGFloat value.
-  CGFloatToType,
+  DoubleToCGFloat,
+  /// Implicit conversion from a value of CGFloat type to a value of Double type
+  /// via an implicit call to an initializer passing CGFloat value.
+  CGFloatToDouble,
 };
 
 /// Specifies whether a given conversion requires the creation of a temporary

lib/Sema/CSApply.cpp

@@ -6690,8 +6690,8 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
                               ForeignObjectConversionExpr(result, toType));
     }
 
-    case ConversionRestrictionKind::CGFloatToType:
-    case ConversionRestrictionKind::TypeToCGFloat: {
+    case ConversionRestrictionKind::CGFloatToDouble:
+    case ConversionRestrictionKind::DoubleToCGFloat: {
       auto *fnExpr = TypeExpr::createImplicit(toType, ctx);
       cs.cacheExprTypes(fnExpr);
 

lib/Sema/CSDiagnostics.cpp

@@ -6406,8 +6406,8 @@ void NonEphemeralConversionFailure::emitSuggestionNotes() const {
   case ConversionRestrictionKind::HashableToAnyHashable:
   case ConversionRestrictionKind::CFTollFreeBridgeToObjC:
   case ConversionRestrictionKind::ObjCTollFreeBridgeToCF:
-  case ConversionRestrictionKind::CGFloatToType:
-  case ConversionRestrictionKind::TypeToCGFloat:
+  case ConversionRestrictionKind::CGFloatToDouble:
+  case ConversionRestrictionKind::DoubleToCGFloat:
     llvm_unreachable("Expected an ephemeral conversion!");
   }
 }

lib/Sema/CSSimplify.cpp

@@ -5089,9 +5089,14 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
         }
       }
 
+      auto isDoubleType = [&](NominalType *NTD) {
+        return NTD->getDecl() == getASTContext().getDoubleDecl();
+      };
+
       if (kind >= ConstraintKind::Subtype &&
           nominal1->getDecl() != nominal2->getDecl() &&
-          (desugar1->isCGFloatType() || desugar2->isCGFloatType())) {
+          ((nominal1->isCGFloatType() || nominal2->isCGFloatType()) &&
+           (isDoubleType(nominal1) || isDoubleType(nominal2)))) {
         SmallVector<LocatorPathElt, 4> path;
         auto anchor = locator.getLocatorParts(path);
 
@@ -5112,15 +5117,15 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
               if (auto elt =
                       rawElt.getAs<LocatorPathElt::ImplicitConversion>()) {
                 auto convKind = elt->getConversionKind();
-                return convKind == ConversionRestrictionKind::TypeToCGFloat ||
-                       convKind == ConversionRestrictionKind::CGFloatToType;
+                return convKind == ConversionRestrictionKind::DoubleToCGFloat ||
+                       convKind == ConversionRestrictionKind::CGFloatToDouble;
               }
               return false;
             })) {
           conversionsOrFixes.push_back(
               desugar1->isCGFloatType()
-                  ? ConversionRestrictionKind::CGFloatToType
-                  : ConversionRestrictionKind::TypeToCGFloat);
+                  ? ConversionRestrictionKind::CGFloatToDouble
+                  : ConversionRestrictionKind::DoubleToCGFloat);
         }
       }
 
@@ -10523,8 +10528,8 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
                       ConstraintKind::Subtype, subflags, locator);
   }
 
-  case ConversionRestrictionKind::TypeToCGFloat:
-  case ConversionRestrictionKind::CGFloatToType: {
+  case ConversionRestrictionKind::DoubleToCGFloat:
+  case ConversionRestrictionKind::CGFloatToDouble: {
     increaseScore(SK_ImplicitValueConversion);
     if (worseThanBestSolution())
       return SolutionKind::Error;

lib/Sema/Constraint.cpp

@@ -548,10 +548,10 @@ StringRef swift::constraints::getName(ConversionRestrictionKind kind) {
     return "[cf-toll-free-bridge-to-objc]";
   case ConversionRestrictionKind::ObjCTollFreeBridgeToCF:
     return "[objc-toll-free-bridge-to-cf]";
-  case ConversionRestrictionKind::CGFloatToType:
-    return "[CGFloat-to-type]";
-  case ConversionRestrictionKind::TypeToCGFloat:
-    return "[type-to-CGFloat]";
+  case ConversionRestrictionKind::CGFloatToDouble:
+    return "[CGFloat-to-Double]";
+  case ConversionRestrictionKind::DoubleToCGFloat:
+    return "[Double-to-CGFloat]";
   }
   llvm_unreachable("bad conversion restriction kind");
 }

lib/Sema/ConstraintSystem.cpp

@@ -4488,8 +4488,8 @@ ConstraintSystem::getArgumentInfo(ConstraintLocator *locator) {
                             .castTo<LocatorPathElt::ImplicitConversion>()
                             .getConversionKind();
 
-      if (conversion == ConversionRestrictionKind::TypeToCGFloat ||
-          conversion == ConversionRestrictionKind::CGFloatToType) {
+      if (conversion == ConversionRestrictionKind::DoubleToCGFloat ||
+          conversion == ConversionRestrictionKind::CGFloatToDouble) {
         // TODO: This is not very efficient, long term we should just
         //       save a single `ArgumentInfo` and use it for all of
         //       the locations where conversion is needed.
@@ -4902,8 +4902,8 @@ ConstraintSystem::isConversionEphemeral(ConversionRestrictionKind conversion,
   case ConversionRestrictionKind::HashableToAnyHashable:
   case ConversionRestrictionKind::CFTollFreeBridgeToObjC:
   case ConversionRestrictionKind::ObjCTollFreeBridgeToCF:
-  case ConversionRestrictionKind::CGFloatToType:
-  case ConversionRestrictionKind::TypeToCGFloat:
+  case ConversionRestrictionKind::CGFloatToDouble:
+  case ConversionRestrictionKind::DoubleToCGFloat:
     // @_nonEphemeral has no effect on these conversions, so treat them as all
     // being non-ephemeral in order to allow their passing to an @_nonEphemeral
     // parameter.

test/Constraints/bridging.swift

@@ -208,7 +208,7 @@ let d2: Double = 3.14159
 inferDouble2 = d2
 
 // rdar://problem/18269449
-var i1: Int = 1.5 * 3.5 // Ok (Double -> CGFloat for each argument, CGFloat -> Int for the result)
+var i1: Int = 1.5 * 3.5 // expected-error {{cannot convert value of type 'Double' to specified type 'Int'}}
 
 // rdar://problem/18330319
 func rdar18330319(_ s: String, d: [String : AnyObject]) {

test/Misc/misc_diagnostics.swift

@@ -19,7 +19,8 @@ var pi = 3.14159265358979
 var d: CGFloat = 2.0
 var dpi:CGFloat = d*pi // Ok (implicit conversion Float -> CGFloat)
 
-let ff: CGFloat = floorf(20.0) // Ok (implicit conversion Float -> CGFloat)
+let ff: CGFloat = floorf(20.0) // expected-error{{cannot convert value of type 'Float' to specified type 'CGFloat'}}
+let _: CGFloat = floor(20.0) // Ok (Double -> CGFloat) conversion
 
 let total = 15.0
 let count = 7
@@ -34,7 +35,7 @@ var b: Int = [1, 2, 3] // expected-error{{cannot convert value of type '[Int]' t
 var f1: Float = 2.0
 var f2: Float = 3.0
 
-var dd: Double = f1 - f2 // Ok (implicit conversion Float -> CGFloat for each argument and CGFloat -> Double for the result)
+var dd: Double = f1 - f2 // expected-error{{cannot convert value of type 'Float' to specified type 'Double'}}
 
 func f() -> Bool {
   return 1 + 1 // expected-error{{type 'Int' cannot be used as a boolean; test for '!= 0' instead}}
@@ -172,3 +173,23 @@ func tuple_splat2(_ q : (a : Int, b : Int)) {
 func is_foreign(a: AnyObject) -> Bool {
   return a is CGColor // expected-warning {{'is' test is always true because 'CGColor' is a Core Foundation type}}
 }
+
+func test_implicit_cgfloat_conversion() {
+  func test_to(_: CGFloat) {}
+  func test_from(_: Double) {}
+
+  let d: Double    = 0.0
+  let f: Float     = 0.0
+  let cgf: CGFloat = 0.0
+
+  test_to(d) // Ok (Double -> CGFloat
+  test_to(f) // error
+
+  test_from(cgf) // Ok (CGFloat -> Double)
+  test_from(f) // error
+
+  let _: CGFloat = d // Ok
+  let _: CGFloat = f // error
+  let _: Double  = cgf // Ok
+  let _: Float   = cgf // error
+}