[TypeChecker] Add a flag to disable Double<->CGFloat implicit conversion

Author: xedin

include/swift/Basic/LangOptions.h

@@ -579,6 +579,9 @@ namespace swift {
 
     /// See \ref FrontendOptions.PrintFullConvention
     bool PrintFullConvention = false;
+
+    /// Disallow Double and CGFloat types to be used interchangeably.
+    bool DisableImplicitDoubleCGFloatConversion = false;
   };
 
   /// Options for controlling the behavior of the Clang importer.

include/swift/Option/FrontendOptions.td

@@ -244,6 +244,9 @@ def enable_resilience : Flag<["-"], "enable-resilience">,
 // HIDDEN FLAGS
 let Flags = [FrontendOption, NoDriverOption, HelpHidden] in {
 
+def disable_implicit_double_cgfloat_conversion : Flag<["-"], "disable-implicit-double-cgfloat-conversion">,
+  HelpText<"Disable implicit conversion between Double and CGFloat types">;
+
 def debug_constraints : Flag<["-"], "debug-constraints">,
   HelpText<"Debug the constraint-based type checker">;
 

include/swift/Sema/ConstraintSystem.h

@@ -1405,6 +1405,10 @@ enum class ConstraintSystemFlags {
   /// calling conventions, say due to Clang attributes such as
   /// `__attribute__((ns_consumed))`.
   UseClangFunctionTypes = 0x80,
+
+  /// Disallow to use Double and CGFloat interchangeably through means of
+  /// an implicit value conversion.
+  DisableImplicitDoubleCGFloatConversion = 0x100,
 };
 
 /// Options that affect the constraint system as a whole.

lib/Frontend/CompilerInvocation.cpp

@@ -809,6 +809,9 @@ static bool ParseTypeCheckerArgs(TypeCheckerOptions &Opts, ArgList &Args,
   Opts.DebugConstraintSolver |= Args.hasArg(OPT_debug_constraints);
   Opts.DebugGenericSignatures |= Args.hasArg(OPT_debug_generic_signatures);
 
+  Opts.DisableImplicitDoubleCGFloatConversion |=
+      Args.hasArg(OPT_disable_implicit_double_cgfloat_conversion);
+
   for (const Arg *A : Args.filtered(OPT_debug_constraints_on_line)) {
     unsigned line;
     if (StringRef(A->getValue()).getAsInteger(/*radix*/ 10, line)) {

lib/Sema/CSSimplify.cpp

@@ -5087,6 +5087,10 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
           nominal1->getDecl() != nominal2->getDecl() &&
           ((nominal1->isCGFloatType() || nominal2->isCGFloatType()) &&
            (nominal1->isDoubleType() || nominal2->isDoubleType()))) {
+        if (Options.contains(
+                ConstraintSystemFlags::DisableImplicitDoubleCGFloatConversion))
+          return getTypeMatchFailure(locator);
+
         // Support implicit Double<->CGFloat conversions only for
         // something which could be directly represented in the AST
         // e.g. argument-to-parameter, contextual conversions etc.

lib/Sema/ConstraintSystem.cpp

@@ -88,6 +88,9 @@ ConstraintSystem::ConstraintSystem(DeclContext *dc,
   }
   if (Context.LangOpts.UseClangFunctionTypes)
     Options |= ConstraintSystemFlags::UseClangFunctionTypes;
+
+  if (Context.TypeCheckerOpts.DisableImplicitDoubleCGFloatConversion)
+    Options |= ConstraintSystemFlags::DisableImplicitDoubleCGFloatConversion;
 }
 
 ConstraintSystem::~ConstraintSystem() {