[ConstraintSystem] Start using implicit conversion to/from CGFloat

Add logic to `matchTypes` to insert an implicit conversion to/from
CGFloat type when two nominal types are matched and one of them is
of `CGFloat` type.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -5089,6 +5089,41 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
         }
       }
 
+      if (kind >= ConstraintKind::Subtype &&
+          nominal1->getDecl() != nominal2->getDecl() &&
+          (desugar1->isCGFloatType() || desugar2->isCGFloatType())) {
+        SmallVector<LocatorPathElt, 4> path;
+        auto anchor = locator.getLocatorParts(path);
+
+        // Try implicit CGFloat conversion only if:
+        // - This is not an explicit call to a CGFloat initializer;
+        // - This is a first type such conversion is attempted for
+        //   for a given path (AST element).
+
+        bool isCGFloatInit = false;
+        if (auto *call = getAsExpr<CallExpr>(anchor)) {
+          if (auto *typeExpr = dyn_cast<TypeExpr>(call->getFn())) {
+            isCGFloatInit = getInstanceType(typeExpr)->isCGFloatType();
+          }
+        }
+
+        if (!isCGFloatInit &&
+            llvm::none_of(path, [&](const LocatorPathElt &rawElt) {
+              if (auto elt =
+                      rawElt.getAs<LocatorPathElt::ImplicitConversion>()) {
+                auto convKind = elt->getConversionKind();
+                return convKind == ConversionRestrictionKind::TypeToCGFloat ||
+                       convKind == ConversionRestrictionKind::CGFloatToType;
+              }
+              return false;
+            })) {
+          conversionsOrFixes.push_back(
+              desugar1->isCGFloatType()
+                  ? ConversionRestrictionKind::CGFloatToType
+                  : ConversionRestrictionKind::TypeToCGFloat);
+        }
+      }
+
       break;
     }
 

lib/Sema/ConstraintSystem.cpp

@@ -4477,6 +4477,29 @@ ConstraintSystem::getArgumentInfo(ConstraintLocator *locator) {
   if (!locator)
     return None;
 
+  // Implicit conversions to/from CGFloat type are modeled without
+  // any changes to the AST, so we have to accomodate for that here
+  // by faking presence of appopriate AST location.
+  if (locator->isLastElement<LocatorPathElt::ApplyArgument>() ||
+      locator->isLastElement<LocatorPathElt::ApplyFunction>()) {
+    auto path = locator->getPath().drop_back();
+    if (!path.empty() && path.back().is<LocatorPathElt::ImplicitConversion>()) {
+      auto conversion = path.back()
+                            .castTo<LocatorPathElt::ImplicitConversion>()
+                            .getConversionKind();
+
+      if (conversion == ConversionRestrictionKind::TypeToCGFloat ||
+          conversion == ConversionRestrictionKind::CGFloatToType) {
+        // 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.
+        ArrayRef<Identifier> labels{Identifier()};
+        return ArgumentInfo{.Labels = allocateCopy(labels),
+                            .UnlabeledTrailingClosureIndex = None};
+      }
+    }
+  }
+
   if (auto *infoLocator = getArgumentInfoLocator(locator)) {
     auto known = ArgumentInfos.find(infoLocator);
     if (known != ArgumentInfos.end())