[ConstraintSolver] When ranking bindings prefer type vars with literal bindings

lib/Sema/CSBindings.cpp

@@ -20,11 +20,10 @@
 using namespace swift;
 using namespace constraints;
 
-std::pair<ConstraintSystem::PotentialBindings, TypeVariableType *>
+Optional<ConstraintSystem::PotentialBindings>
 ConstraintSystem::determineBestBindings() {
   // Look for potential type variable bindings.
-  TypeVariableType *bestTypeVar = nullptr;
-  PotentialBindings bestBindings;
+  Optional<PotentialBindings> bestBindings;
   for (auto typeVar : getTypeVariables()) {
     // Skip any type variables that are bound.
     if (typeVar->getImpl().hasRepresentativeOrFixed())
@@ -42,13 +41,11 @@ ConstraintSystem::determineBestBindings() {
 
     // If these are the first bindings, or they are better than what
     // we saw before, use them instead.
-    if (!bestTypeVar || bindings < bestBindings) {
+    if (!bestBindings || bindings < *bestBindings)
       bestBindings = std::move(bindings);
-      bestTypeVar = typeVar;
-    }
   }
 
-  return std::make_pair(bestBindings, bestTypeVar);
+  return bestBindings;
 }
 
 /// Find the set of type variables that are inferable from the given type.
@@ -141,7 +138,7 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) {
   getConstraintGraph().gatherConstraints(
       typeVar, constraints, ConstraintGraph::GatheringKind::EquivalenceClass);
 
-  PotentialBindings result;
+  PotentialBindings result(typeVar);
 
   // Consider each of the constraints related to this type variable.
   llvm::SmallPtrSet<CanType, 4> exactTypes;
@@ -196,7 +193,7 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) {
       auto dynamicType = constraint->getFirstType();
       if (auto *tv = dynamicType->getAs<TypeVariableType>()) {
         if (tv->getImpl().getRepresentative(nullptr) == typeVar)
-          return {};
+          return {typeVar};
       }
 
       // This is right-hand side, let's continue.

lib/Sema/CSSolver.cpp

@@ -1783,21 +1783,15 @@ bool ConstraintSystem::solveSimplified(
     Constraint *disjunction, SmallVectorImpl<Solution> &solutions,
     FreeTypeVariableBinding allowFreeTypeVariables) {
 
-  TypeVariableType *bestTypeVar = nullptr;
-  PotentialBindings bestBindings;
-  std::tie(bestBindings, bestTypeVar) = determineBestBindings();
+  auto bestBindings = determineBestBindings();
 
   // If we have a binding that does not involve type variables, and is
-  // not fully bound, and is either not a literal or is a collection
-  // literal, or we have no disjunction to attempt instead, go ahead
-  // and try the bindings for this type variable.
-  if (bestBindings &&
-      (!disjunction ||
-       (!bestBindings.InvolvesTypeVariables && !bestBindings.FullyBound &&
-        (bestBindings.LiteralBinding == LiteralBindingKind::None ||
-         bestBindings.LiteralBinding == LiteralBindingKind::Collection)))) {
-    return tryTypeVariableBindings(solverState->depth, bestTypeVar,
-                                   bestBindings.Bindings, solutions,
+  // not fully bound, or we have no disjunction to attempt instead,
+  // go ahead and try the bindings for this type variable.
+  if (bestBindings && (!disjunction || (!bestBindings->InvolvesTypeVariables &&
+                                        !bestBindings->FullyBound))) {
+    return tryTypeVariableBindings(solverState->depth, bestBindings->TypeVar,
+                                   bestBindings->Bindings, solutions,
                                    allowFreeTypeVariables);
   }
 

lib/Sema/ConstraintSystem.h

@@ -2551,8 +2551,10 @@ class ConstraintSystem {
   };
 
   struct PotentialBindings {
-    typedef std::tuple<bool, bool, bool, bool, unsigned char,
-                       bool, unsigned int> BindingScore;
+    typedef std::tuple<bool, bool, bool, bool, bool,
+                       unsigned char, unsigned int> BindingScore;
+
+    TypeVariableType *TypeVar;
 
     /// The set of potential bindings.
     SmallVector<PotentialBinding, 4> Bindings;
@@ -2578,6 +2580,8 @@ class ConstraintSystem {
     /// Tracks the position of the last known supertype in the group.
     Optional<unsigned> lastSupertypeIndex;
 
+    PotentialBindings(TypeVariableType *typeVar) : TypeVar(typeVar) {}
+
     /// Determine whether the set of bindings is non-empty.
     explicit operator bool() const { return !Bindings.empty(); }
 
@@ -2591,8 +2595,8 @@ class ConstraintSystem {
                              b.FullyBound,
                              b.IsRHSOfBindParam,
                              b.SubtypeOfExistentialType,
-                             static_cast<unsigned char>(b.LiteralBinding),
                              b.InvolvesTypeVariables,
+                             static_cast<unsigned char>(b.LiteralBinding),
                              -(b.Bindings.size() - b.NumDefaultableBindings));
     }
 
@@ -2717,7 +2721,7 @@ class ConstraintSystem {
 
   Optional<Type> checkTypeOfBinding(TypeVariableType *typeVar, Type type,
                                     bool *isNilLiteral = nullptr);
-  std::pair<PotentialBindings, TypeVariableType *> determineBestBindings();
+  Optional<PotentialBindings> determineBestBindings();
   PotentialBindings getPotentialBindings(TypeVariableType *typeVar);
 
   bool

validation-test/Sema/type_checker_perf/slow/rdar21720888.swift.gyb → validation-test/Sema/type_checker_perf/fast/rdar21720888.swift.gyb

@@ -1,4 +1,4 @@
-// RUN: %scale-test --invert-result --begin 2 --end 7 --step 1 --select incrementScopeCounter %s
+// RUN: %scale-test --begin 1 --end 10 --step 1 --select incrementScopeCounter %s
 // REQUIRES: OS=macosx
 // REQUIRES: asserts