[Constraint system] Switch TypeVariables to a SetVector.

There were a few places where we wanted fast testing to see whether a
particular type variable is currently of interest. Instead of building
local hash tables in those places, keep type variables in a SetVector
for efficient testing.

Author: DougGregor

lib/Sema/CSSolver.cpp

@@ -77,7 +77,7 @@ Solution ConstraintSystem::finalize() {
     }
   }
 
-  for (auto tv : TypeVariables) {
+  for (auto tv : getTypeVariables()) {
     if (getFixedType(tv))
       continue;
 
@@ -95,7 +95,7 @@ Solution ConstraintSystem::finalize() {
   }
 
   // For each of the type variables, get its fixed type.
-  for (auto tv : TypeVariables) {
+  for (auto tv : getTypeVariables()) {
     solution.typeBindings[tv] = simplifyType(tv)->reconstituteSugar(false);
   }
 
@@ -198,12 +198,9 @@ void ConstraintSystem::applySolution(const Solution &solution) {
   CurrentScore += solution.getFixedScore();
 
   // Assign fixed types to the type variables solved by this solution.
-  llvm::SmallPtrSet<TypeVariableType *, 4> 
-    knownTypeVariables(TypeVariables.begin(), TypeVariables.end());
   for (auto binding : solution.typeBindings) {
     // If we haven't seen this type variable before, record it now.
-    if (knownTypeVariables.insert(binding.first).second)
-      TypeVariables.push_back(binding.first);
+    addTypeVariable(binding.first);
 
     // If we don't already have a fixed type for this type variable,
     // assign the fixed type from the solution.
@@ -475,7 +472,8 @@ ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
 ConstraintSystem::SolverScope::~SolverScope() {
   // Erase the end of various lists.
   cs.resolvedOverloadSets = resolvedOverloadSets;
-  truncate(cs.TypeVariables, numTypeVariables);
+  while (cs.TypeVariables.size() > numTypeVariables)
+    cs.TypeVariables.pop_back();
 
   // Restore bindings.
   cs.restoreTypeVariableBindings(cs.solverState->savedBindings.size() -

lib/Sema/CSStep.cpp

@@ -32,7 +32,7 @@ ComponentStep::Scope::Scope(ComponentStep &component)
   TypeVars = std::move(CS.TypeVariables);
 
   for (auto *typeVar : component.TypeVars)
-    CS.TypeVariables.push_back(typeVar);
+    CS.addTypeVariable(typeVar);
 
   auto &workList = CS.InactiveConstraints;
   workList.splice(workList.end(), *component.Constraints);
@@ -92,7 +92,7 @@ void SplitterStep::computeFollowupSteps(
   CG.optimize();
 
   // Compute the connected components of the constraint graph.
-  auto components = CG.computeConnectedComponents(CS.TypeVariables);
+  auto components = CG.computeConnectedComponents(CS.getTypeVariables());
   unsigned numComponents = components.size();
   if (numComponents < 2) {
     steps.push_back(llvm::make_unique<ComponentStep>(
@@ -106,10 +106,10 @@ void SplitterStep::computeFollowupSteps(
     CG.verify();
 
     log << "---Constraint graph---\n";
-    CG.print(CS.TypeVariables, log);
+    CG.print(CS.getTypeVariables(), log);
 
     log << "---Connected components---\n";
-    CG.printConnectedComponents(CS.TypeVariables, log);
+    CG.printConnectedComponents(CS.getTypeVariables(), log);
   }
 
   // Take the orphaned constraints, because they'll go into a component now.

lib/Sema/CSStep.h

@@ -342,7 +342,7 @@ class ComponentStep final : public SolverStep {
     ConstraintSystem &CS;
     ConstraintSystem::SolverScope *SolverScope;
 
-    std::vector<TypeVariableType *> TypeVars;
+    SetVector<TypeVariableType *> TypeVars;
     ConstraintSystem::SolverScope *PrevPartialScope = nullptr;
 
     // The component this scope is associated with.

lib/Sema/ConstraintGraph.cpp

@@ -378,18 +378,6 @@ llvm::TinyPtrVector<Constraint *> ConstraintGraph::gatherConstraints(
     llvm::function_ref<bool(Constraint *)> acceptConstraintFn) {
   llvm::TinyPtrVector<Constraint *> constraints;
 
-  // Local function to test whether the given type variable is in the current
-  // interest set for the solver.
-  SmallPtrSet<TypeVariableType *, 4> interestingTypeVars;
-  auto isInterestingTypeVar = [&](TypeVariableType *typeVar) {
-    if (interestingTypeVars.empty()) {
-      interestingTypeVars.insert(CS.TypeVariables.begin(),
-                                 CS.TypeVariables.end());
-    }
-
-    return interestingTypeVars.count(typeVar) > 0;
-  };
-
   // Whether we should consider this constraint at all.
   auto rep = CS.getRepresentative(typeVar);
   auto shouldConsiderConstraint = [&](Constraint *constraint) {
@@ -399,7 +387,7 @@ llvm::TinyPtrVector<Constraint *> ConstraintGraph::gatherConstraints(
     if (constraint->getKind() == ConstraintKind::OneWayBind) {
       auto lhsTypeVar =
           constraint->getFirstType()->castTo<TypeVariableType>();
-      if (!isInterestingTypeVar(lhsTypeVar))
+      if (!CS.isActiveTypeVariable(lhsTypeVar))
         return false;
 
       SmallVector<TypeVariableType *, 2> rhsTypeVars;
@@ -1295,7 +1283,7 @@ void ConstraintGraph::dump() {
 void ConstraintGraph::dump(llvm::raw_ostream &out) {
   llvm::SaveAndRestore<bool>
     debug(CS.getASTContext().LangOpts.DebugConstraintSolver, true);
-  print(CS.TypeVariables, out);
+  print(CS.getTypeVariables(), out);
 }
 
 void ConstraintGraph::printConnectedComponents(
@@ -1334,7 +1322,7 @@ void ConstraintGraph::printConnectedComponents(
 void ConstraintGraph::dumpConnectedComponents() {
   llvm::SaveAndRestore<bool>
     debug(CS.getASTContext().LangOpts.DebugConstraintSolver, true);
-  printConnectedComponents(CS.TypeVariables, llvm::dbgs());
+  printConnectedComponents(CS.getTypeVariables(), llvm::dbgs());
 }
 
 #pragma mark Verification of graph invariants

lib/Sema/ConstraintGraph.h

@@ -337,7 +337,7 @@ class ConstraintGraph {
   ConstraintSystem &CS;
 
   /// The type variables in this graph, in stable order.
-  SmallVector<TypeVariableType *, 4> TypeVariables;
+  std::vector<TypeVariableType *> TypeVariables;
 
   /// Constraints that are "orphaned" because they contain no type variables.
   SmallVector<Constraint *, 4> OrphanedConstraints;

lib/Sema/ConstraintSystem.cpp

@@ -107,7 +107,7 @@ bool ConstraintSystem::hasFreeTypeVariables() {
 }
 
 void ConstraintSystem::addTypeVariable(TypeVariableType *typeVar) {
-  TypeVariables.push_back(typeVar);
+  TypeVariables.insert(typeVar);
 
   // Notify the constraint graph.
   (void)CG[typeVar];

lib/Sema/ConstraintSystem.h

@@ -1055,7 +1055,7 @@ class ConstraintSystem {
   /// solution it represents.
   Score CurrentScore;
 
-  std::vector<TypeVariableType *> TypeVariables;
+  llvm::SetVector<TypeVariableType *> TypeVariables;
 
   /// Maps expressions to types for choosing a favored overload
   /// type in a disjunction constraint.
@@ -1766,9 +1766,15 @@ class ConstraintSystem {
 
   /// Retrieve the set of active type variables.
   ArrayRef<TypeVariableType *> getTypeVariables() const {
-    return TypeVariables;
+    return TypeVariables.getArrayRef();
   }
-  
+
+  /// Whether the given type variable is active in the constraint system at
+  /// the moment.
+  bool isActiveTypeVariable(TypeVariableType *typeVar) const {
+    return TypeVariables.count(typeVar) > 0;
+  }
+
   TypeBase* getFavoredType(Expr *E) {
     assert(E != nullptr);
     return this->FavoredTypes[E];

lib/Sema/TypeCheckConstraints.cpp

@@ -3664,7 +3664,7 @@ void ConstraintSystem::print(raw_ostream &out) {
   }
 
   out << "Type Variables:\n";
-  for (auto tv : TypeVariables) {
+  for (auto tv : getTypeVariables()) {
     out.indent(2);
     tv->getImpl().print(out);
     if (tv->getImpl().canBindToLValue())