[ConstraintSystem] Record all Double <-> CGFloat conversions performed along a current solver path

This information makes it easier to compute a score for the next
implicit value conversion solver would have to perform.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -1177,6 +1177,10 @@ class Solution {
   /// The locators of \c Defaultable constraints whose defaults were used.
   llvm::SmallPtrSet<ConstraintLocator *, 2> DefaultedConstraints;
 
+  /// Implicit value conversions applied for a given locator.
+  SmallVector<std::pair<ConstraintLocator *, ConversionRestrictionKind>, 2>
+      ImplicitValueConversions;
+
   /// The node -> type mappings introduced by this solution.
   llvm::DenseMap<ASTNode, Type> nodeTypes;
 
@@ -2210,6 +2214,11 @@ class ConstraintSystem {
   std::vector<std::pair<ConstraintLocator*, TrailingClosureMatching>>
       trailingClosureMatchingChoices;
 
+  /// The set of implicit value conversions performed by the solver on
+  /// a current path to reach a solution.
+  SmallVector<std::pair<ConstraintLocator *, ConversionRestrictionKind>, 2>
+      ImplicitValueConversions;
+
   /// The worklist of "active" constraints that should be revisited
   /// due to a change.
   ConstraintList ActiveConstraints;
@@ -2738,6 +2747,9 @@ class ConstraintSystem {
     /// The length of \c caseLabelItems.
     unsigned numCaseLabelItems;
 
+    /// The length of \c ImplicitValueConversions.
+    unsigned numImplicitValueConversions;
+
     /// The previous score.
     Score PreviousScore;
 

lib/Sema/CSSimplify.cpp

@@ -5083,14 +5083,10 @@ 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() &&
           ((nominal1->isCGFloatType() || nominal2->isCGFloatType()) &&
-           (isDoubleType(nominal1) || isDoubleType(nominal2)))) {
+           (nominal1->isDoubleType() || nominal2->isDoubleType()))) {
         SmallVector<LocatorPathElt, 4> path;
         auto anchor = locator.getLocatorParts(path);
 
@@ -10531,7 +10527,7 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
     auto defaultImpact =
         restriction == ConversionRestrictionKind::CGFloatToDouble ? 1 : 2;
 
-    auto numConversions = CurrentScore.Data[SK_ImplicitValueConversion];
+    auto numConversions = ImplicitValueConversions.size();
     increaseScore(SK_ImplicitValueConversion,
                   defaultImpact * (numConversions + 1));
 
@@ -10572,6 +10568,9 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
     addConstraint(ConstraintKind::ApplicableFunction,
                   FunctionType::get({FunctionType::Param(type1)}, type2),
                   memberTy, applicationLoc);
+
+    ImplicitValueConversions.push_back(
+        {getConstraintLocator(locator), restriction});
     return SolutionKind::Solved;
   }
   }

lib/Sema/CSSolver.cpp

@@ -193,6 +193,11 @@ Solution ConstraintSystem::finalize() {
     solution.appliedPropertyWrappers.insert(appliedWrapper);
   }
 
+  // Remember implicit value conversions.
+  for (const auto &valueConversion : ImplicitValueConversions) {
+    solution.ImplicitValueConversions.push_back(valueConversion);
+  }
+
   return solution;
 }
 
@@ -282,6 +287,10 @@ void ConstraintSystem::applySolution(const Solution &solution) {
     appliedPropertyWrappers.insert(appliedWrapper);
   }
 
+  for (auto &valueConversion : solution.ImplicitValueConversions) {
+    ImplicitValueConversions.push_back(valueConversion);
+  }
+
   // Register any fixes produced along this path.
   Fixes.append(solution.Fixes.begin(), solution.Fixes.end());
 }
@@ -488,6 +497,7 @@ ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
   numContextualTypes = cs.contextualTypes.size();
   numSolutionApplicationTargets = cs.solutionApplicationTargets.size();
   numCaseLabelItems = cs.caseLabelItems.size();
+  numImplicitValueConversions = cs.ImplicitValueConversions.size();
 
   PreviousScore = cs.CurrentScore;
 
@@ -578,6 +588,9 @@ ConstraintSystem::SolverScope::~SolverScope() {
   // Remove any case label item infos.
   truncate(cs.caseLabelItems, numCaseLabelItems);
 
+  // Remove any implicit value conversions.
+  truncate(cs.ImplicitValueConversions, numImplicitValueConversions);
+
   // Reset the previous score.
   cs.CurrentScore = PreviousScore;