[ConstraintSystem] Attempt Double <-> CGFloat implicit conversion only once and re-use results

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -553,8 +553,12 @@ template <typename T = Expr> T *castToExpr(ASTNode node) {
 }
 
 template <typename T = Expr> T *getAsExpr(ASTNode node) {
+  if (node.isNull())
+    return nullptr;
+
   if (auto *E = node.dyn_cast<Expr *>())
     return dyn_cast_or_null<T>(E);
+
   return nullptr;
 }
 

lib/Sema/CSApply.cpp

@@ -6692,21 +6692,23 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
 
     case ConversionRestrictionKind::CGFloatToDouble:
     case ConversionRestrictionKind::DoubleToCGFloat: {
-      auto *fnExpr = TypeExpr::createImplicit(toType, ctx);
-      cs.cacheExprTypes(fnExpr);
+      auto conversionKind = knownRestriction->second;
 
       auto *argExpr = locator.trySimplifyToExpr();
       assert(argExpr);
 
-      auto *callLocator = cs.getConstraintLocator(
-          locator,
-          LocatorPathElt::ImplicitConversion(knownRestriction->second));
-
       auto *implicitInit =
-          CallExpr::createImplicit(ctx, fnExpr,
+          CallExpr::createImplicit(ctx, TypeExpr::createImplicit(toType, ctx),
                                    /*args=*/{argExpr},
                                    /*argLabels=*/{Identifier()});
-      cs.cacheExprTypes(implicitInit);
+
+      cs.cacheExprTypes(implicitInit->getFn());
+      cs.setType(argExpr, fromType);
+      cs.setType(implicitInit->getArg(),
+                 ParenType::get(cs.getASTContext(), fromType));
+
+      auto *callLocator = cs.getConstraintLocator(
+          implicitInit, LocatorPathElt::ImplicitConversion(conversionKind));
 
       // HACK: Temporarily push the call expr onto the expr stack to make sure
       // we don't try to prematurely close an existential when applying the
@@ -6715,6 +6717,25 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       ExprStack.push_back(implicitInit);
       SWIFT_DEFER { ExprStack.pop_back(); };
 
+      // We need to take information recorded for all conversions of this
+      // kind and move it to a specific location where restriction is applied.
+      {
+        auto *memberLoc = solution.getConstraintLocator(
+            callLocator, {ConstraintLocator::ApplyFunction,
+                          ConstraintLocator::ConstructorMember});
+
+        auto overload = solution.getOverloadChoice(cs.getConstraintLocator(
+            ASTNode(), {LocatorPathElt::ImplicitConversion(conversionKind),
+                        ConstraintLocator::ApplyFunction,
+                        ConstraintLocator::ConstructorMember}));
+
+        solution.overloadChoices.insert({memberLoc, overload});
+        solution.trailingClosureMatchingChoices.insert(
+            {cs.getConstraintLocator(callLocator,
+                                     ConstraintLocator::ApplyArgument),
+             TrailingClosureMatching::Forward});
+      }
+
       finishApply(implicitInit, toType, callLocator, callLocator);
       return implicitInit;
     }

lib/Sema/CSSimplify.cpp

@@ -1345,12 +1345,6 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
     }
   }
 
-  // If this application is part of an operator, then we allow an implicit
-  // lvalue to be compatible with inout arguments.  This is used by
-  // assignment operators.
-  auto anchor = locator.getAnchor();
-  assert(bool(anchor) && "locator without anchor?");
-
   auto isSynthesizedArgument = [](const AnyFunctionType::Param &arg) -> bool {
     if (auto *typeVar = arg.getPlainType()->getAs<TypeVariableType>()) {
       auto *locator = typeVar->getImpl().getLocator();
@@ -10534,13 +10528,30 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
     if (worseThanBestSolution())
       return SolutionKind::Error;
 
-    auto *applicationLoc = getConstraintLocator(
-        locator, {LocatorPathElt::ImplicitConversion(restriction),
-                  ConstraintLocator::ApplyFunction});
+    auto *conversionLoc = getConstraintLocator(
+        /*anchor=*/ASTNode(), LocatorPathElt::ImplicitConversion(restriction));
+
+    auto *applicationLoc =
+        getConstraintLocator(conversionLoc, ConstraintLocator::ApplyFunction);
 
     auto *memberLoc = getConstraintLocator(
         applicationLoc, ConstraintLocator::ConstructorMember);
 
+    // This conversion has been already attempted for and constructor
+    // choice has been recorded.
+    if (findSelectedOverloadFor(memberLoc))
+      return SolutionKind::Solved;
+
+    // Allocate a single argument info to conver all possible
+    // Double <-> CGFloat conversion locations.
+    if (!ArgumentInfos.count(memberLoc)) {
+      auto &ctx = getASTContext();
+      ArgumentInfo callInfo{.Labels = ctx.Allocate<Identifier>(
+                                1, AllocationArena::ConstraintSolver),
+                            .UnlabeledTrailingClosureIndex = None};
+      ArgumentInfos.insert({memberLoc, std::move(callInfo)});
+    }
+
     auto *memberTy = createTypeVariable(memberLoc, TVO_CanBindToNoEscape);
 
     addValueMemberConstraint(MetatypeType::get(type2, getASTContext()),