[CSBindings] Cache already computed type variable bindings

To avoid re-computing same bindings over and over again,
let's try to keep a cache of active bindings and invalidate
them as needed.

Invalidate bindings conservatively when new constraints are
introduced (even if such constraints are not going to result
in new type bindings), and when type variables are assigned
fixed types or merged together.

Invalidation also makes sure to erase bindings of all adjacent
type variables related to equivalence class of the variables
in question.

This significantly speeds up use-cases that have a lot of type
variables such as collection literals with arbitrary nesting.

Author: xedin

lib/Sema/CSBindings.cpp

@@ -25,22 +25,26 @@ Optional<ConstraintSystem::PotentialBindings>
 ConstraintSystem::determineBestBindings() {
   // Look for potential type variable bindings.
   Optional<PotentialBindings> bestBindings;
-  llvm::SmallDenseMap<TypeVariableType *, PotentialBindings> cache;
-
   // First, let's collect all of the possible bindings.
   for (auto *typeVar : getTypeVariables()) {
     if (typeVar->getImpl().hasRepresentativeOrFixed())
       continue;
 
+    if (Bindings.count(typeVar) > 0)
+      continue;
+
     if (auto bindings = getPotentialBindings(typeVar))
-      cache.insert({typeVar, std::move(bindings)});
+      Bindings.insert({typeVar, std::move(bindings)});
   }
 
   // Now let's see if we could infer something for related type
   // variables based on other bindings.
   for (auto *typeVar : getTypeVariables()) {
-    auto cachedBindings = cache.find(typeVar);
-    if (cachedBindings == cache.end())
+    if (typeVar->getImpl().hasRepresentativeOrFixed())
+      continue;
+
+    auto cachedBindings = Bindings.find(typeVar);
+    if (cachedBindings == Bindings.end())
       continue;
 
     auto &bindings = cachedBindings->getSecond();
@@ -62,8 +66,8 @@ ConstraintSystem::determineBestBindings() {
       if (!tv)
         continue;
 
-      auto relatedBindings = cache.find(tv);
-      if (relatedBindings == cache.end())
+      auto relatedBindings = Bindings.find(tv);
+      if (relatedBindings == Bindings.end())
         continue;
 
       for (auto &binding : relatedBindings->getSecond().Bindings) {

lib/Sema/CSSimplify.cpp

@@ -1561,7 +1561,6 @@ ConstraintSystem::matchTypesBindTypeVar(
   }
 
   assignFixedType(typeVar, type);
-
   return getTypeMatchSuccess();
 }
 

lib/Sema/ConstraintSystem.cpp

@@ -232,6 +232,10 @@ void ConstraintSystem::addTypeVariableConstraintsToWorkList(
                              constraint);
     constraint->setActive(true);
   }
+
+  // Invalidate pre-computed bindings associated
+  // with this type variable (if any).
+  invalidateBindings(typeVar);
 }
 
 /// Retrieve a dynamic result signature for the given declaration.

lib/Sema/ConstraintSystem.h

@@ -1213,6 +1213,7 @@ class ConstraintSystem {
     /// \param constraint The newly generated constraint.
     void addGeneratedConstraint(Constraint *constraint) {
       generatedConstraints.push_back(constraint);
+      CS.invalidateBindings(constraint->getTypeVariables());
     }
 
     /// \brief Erase given constraint from the list of generated constraints
@@ -2940,6 +2941,12 @@ class ConstraintSystem {
     }
   };
 
+  /// Maps type variables to their bindings. Bindings are invalidated
+  /// and have to be re-computed if new constraints are introduced or
+  /// in relation to a particular set of type variables or type variables
+  /// are assigned fixed types or merged together.
+  llvm::DenseMap<TypeVariableType *, PotentialBindings> Bindings;
+
   Optional<Type> checkTypeOfBinding(TypeVariableType *typeVar, Type type,
                                     bool *isNilLiteral = nullptr);
   Optional<PotentialBindings> determineBestBindings();
@@ -3228,6 +3235,28 @@ class ConstraintSystem {
                             SmallVectorImpl<unsigned> &Ordering,
                             SmallVectorImpl<unsigned> &PartitionBeginning);
 
+  void invalidateBindings(ArrayRef<TypeVariableType *> typeVars) {
+    llvm::SmallPtrSet<TypeVariableType *, 8> visitedVars;
+    for (auto *typeVar : typeVars) {
+      if (typeVar != typeVar->getImpl().getRepresentative(nullptr) ||
+          visitedVars.count(typeVar) > 0)
+        continue;
+
+      // If there was no binding, there is no need to disturb
+      // other type variables.
+      Bindings.erase(typeVar);
+      visitedVars.insert(typeVar);
+
+      for (auto *eqClassVar : CG[typeVar].getEquivalenceClass()) {
+        for (auto *adjacentVar : CG[eqClassVar].getAdjacencies()) {
+          auto *var = getRepresentative(adjacentVar);
+          if (visitedVars.insert(var).second)
+            Bindings.erase(var);
+        }
+      }
+    }
+  }
+
   LLVM_ATTRIBUTE_DEPRECATED(
       void dump() LLVM_ATTRIBUTE_USED,
       "only for use within the debugger");

validation-test/Sema/type_checker_perf/fast/rdar30596744_3.swift.gyb

@@ -0,0 +1,15 @@
+// RUN: %scale-test --begin 1 --end 20 --step 1 --select NumLeafScopes %s
+// REQUIRES: OS=macosx
+// REQUIRES: asserts
+
+% array_elements = 20
+
+let _ = [
+%for i in range(0, N):
+  ${i} : [
+    %for j in range(array_elements):
+      "e${j}",
+    %end
+  ],
+%end
+]

validation-test/Sema/type_checker_perf/slow/rdar30596744_2.swift.gyb

@@ -1,4 +1,4 @@
-// RUN: %scale-test --invert-result --begin 1 --end 5 --step 1 --select NumLeafScopes %s --expected-exit-code 1
+// RUN: %scale-test --invert-result --begin 1 --end 4 --step 1 --select NumLeafScopes %s --expected-exit-code 1
 // REQUIRES: OS=macosx
 // REQUIRES: asserts