Merge pull request #24659 from gmittert/StackConstraints

Reduce the Stack Size of ConstraintSystem

Author: gmittert

lib/Sema/CSSolver.cpp

@@ -229,7 +229,8 @@ void ConstraintSystem::applySolution(const Solution &solution) {
   }
 
   // Register the defaulted type variables.
-  DefaultedConstraints.append(solution.DefaultedConstraints.begin(),
+  DefaultedConstraints.insert(DefaultedConstraints.end(),
+                              solution.DefaultedConstraints.begin(),
                               solution.DefaultedConstraints.end());
 
   // Register the conformances checked along the way to arrive to solution.
@@ -310,6 +311,12 @@ bool ConstraintSystem::simplify(bool ContinueAfterFailures) {
 
 namespace {
 
+template<typename T>
+void truncate(std::vector<T> &vec, unsigned newSize) {
+  assert(newSize <= vec.size() && "Not a truncation!");
+  vec.erase(vec.begin() + newSize, vec.end());
+}
+
 /// Truncate the given small vector to the given new size.
 template<typename T>
 void truncate(SmallVectorImpl<T> &vec, unsigned newSize) {

lib/Sema/CSStep.cpp

@@ -99,8 +99,8 @@ void SplitterStep::computeFollowupSteps(
   // FIXME: We're seeding typeVars with TypeVariables so that the
   // connected-components algorithm only considers those type variables within
   // our component. There are clearly better ways to do this.
-  SmallVector<TypeVariableType *, 16> typeVars(CS.TypeVariables);
-  SmallVector<unsigned, 16> components;
+  std::vector<TypeVariableType *> typeVars(CS.TypeVariables);
+  std::vector<unsigned> components;
   unsigned numComponents = CG.computeConnectedComponents(typeVars, components);
   if (numComponents < 2) {
     componentSteps.push_back(llvm::make_unique<ComponentStep>(

lib/Sema/CSStep.h

@@ -291,7 +291,7 @@ class ComponentStep final : public SolverStep {
     ConstraintSystem &CS;
     ConstraintSystem::SolverScope *SolverScope;
 
-    SmallVector<TypeVariableType *, 16> TypeVars;
+    std::vector<TypeVariableType *> TypeVars;
     ConstraintSystem::SolverScope *PrevPartialScope = nullptr;
 
     // The component this scope is associated with.
@@ -336,7 +336,7 @@ class ComponentStep final : public SolverStep {
   std::unique_ptr<Scope> ComponentScope = nullptr;
 
   /// Type variables and constraints "in scope" of this step.
-  SmallVector<TypeVariableType *, 16> TypeVars;
+  std::vector<TypeVariableType *> TypeVars;
   /// Constraints "in scope" of this step.
   ConstraintList *Constraints;
 

lib/Sema/ConstraintGraph.cpp

@@ -528,7 +528,7 @@ void ConstraintGraph::gatherConstraints(
 static void connectedComponentsDFS(ConstraintGraph &cg,
                                    ConstraintGraphNode &node,
                                    unsigned component,
-                                   SmallVectorImpl<unsigned> &components) {
+                                   std::vector<unsigned> &components) {
   // Local function that recurses on the given set of type variables.
   auto visitAdjacencies = [&](ArrayRef<TypeVariableType *> typeVars) {
     for (auto adj : typeVars) {
@@ -562,8 +562,8 @@ static void connectedComponentsDFS(ConstraintGraph &cg,
 }
 
 unsigned ConstraintGraph::computeConnectedComponents(
-           SmallVectorImpl<TypeVariableType *> &typeVars,
-           SmallVectorImpl<unsigned> &components) {
+           std::vector<TypeVariableType *> &typeVars,
+           std::vector<unsigned> &components) {
   // Track those type variables that the caller cares about.
   llvm::SmallPtrSet<TypeVariableType *, 4> typeVarSubset(typeVars.begin(),
                                                          typeVars.end());
@@ -871,9 +871,9 @@ void ConstraintGraph::dump() {
 }
 
 void ConstraintGraph::printConnectedComponents(llvm::raw_ostream &out) {
-  SmallVector<TypeVariableType *, 16> typeVars;
-  typeVars.append(TypeVariables.begin(), TypeVariables.end());
-  SmallVector<unsigned, 16> components;
+  std::vector<TypeVariableType *> typeVars;
+  typeVars.insert(typeVars.end(), TypeVariables.begin(), TypeVariables.end());
+  std::vector<unsigned> components;
   unsigned numComponents = computeConnectedComponents(typeVars, components);
   for (unsigned component = 0; component != numComponents; ++component) {
     out.indent(2);

lib/Sema/ConstraintGraph.h

@@ -249,8 +249,8 @@ class ConstraintGraph {
   /// one component for each of the constraints produced by
   /// \c getOrphanedConstraints().
   unsigned computeConnectedComponents(
-             SmallVectorImpl<TypeVariableType *> &typeVars,
-             SmallVectorImpl<unsigned> &components);
+             std::vector<TypeVariableType *> &typeVars,
+             std::vector<unsigned> &components);
 
   /// Retrieve the set of "orphaned" constraints, which are known to the
   /// constraint graph but have no type variables to anchor them.

lib/Sema/ConstraintSystem.cpp

@@ -2254,7 +2254,7 @@ size_t Solution::getTotalMemory() const {
          llvm::capacity_in_bytes(Fixes) + DisjunctionChoices.getMemorySize() +
          OpenedTypes.getMemorySize() + OpenedExistentialTypes.getMemorySize() +
          (DefaultedConstraints.size() * sizeof(void *)) +
-         llvm::capacity_in_bytes(Conformances);
+         Conformances.size() * sizeof(std::pair<ConstraintLocator *, ProtocolConformanceRef>);
 }
 
 DeclName OverloadChoice::getName() const {

lib/Sema/ConstraintSystem.h

@@ -609,14 +609,14 @@ class Solution {
   ConstraintSystem &getConstraintSystem() const { return *constraintSystem; }
 
   /// The set of type bindings.
-  llvm::SmallDenseMap<TypeVariableType *, Type> typeBindings;
+  llvm::DenseMap<TypeVariableType *, Type> typeBindings;
 
   /// The set of overload choices along with their types.
-  llvm::SmallDenseMap<ConstraintLocator *, SelectedOverload> overloadChoices;
+  llvm::DenseMap<ConstraintLocator *, SelectedOverload> overloadChoices;
 
   /// The set of constraint restrictions used to arrive at this restriction,
   /// which informs constraint application.
-  llvm::SmallDenseMap<std::pair<CanType, CanType>, ConversionRestrictionKind>
+  llvm::DenseMap<std::pair<CanType, CanType>, ConversionRestrictionKind>
     ConstraintRestrictions;
 
   /// The list of fixes that need to be applied to the initial expression
@@ -628,19 +628,19 @@ class Solution {
 
   /// The set of disjunction choices used to arrive at this solution,
   /// which informs constraint application.
-  llvm::SmallDenseMap<ConstraintLocator *, unsigned> DisjunctionChoices;
+  llvm::DenseMap<ConstraintLocator *, unsigned> DisjunctionChoices;
 
   /// The set of opened types for a given locator.
-  llvm::SmallDenseMap<ConstraintLocator *, ArrayRef<OpenedType>> OpenedTypes;
+  llvm::DenseMap<ConstraintLocator *, ArrayRef<OpenedType>> OpenedTypes;
 
   /// The opened existential type for a given locator.
-  llvm::SmallDenseMap<ConstraintLocator *, OpenedArchetypeType *>
+  llvm::DenseMap<ConstraintLocator *, OpenedArchetypeType *>
     OpenedExistentialTypes;
 
   /// The locators of \c Defaultable constraints whose defaults were used.
-  llvm::SmallPtrSet<ConstraintLocator *, 8> DefaultedConstraints;
+  llvm::SmallPtrSet<ConstraintLocator *, 2> DefaultedConstraints;
 
-  llvm::SmallVector<std::pair<ConstraintLocator *, ProtocolConformanceRef>, 8>
+  std::vector<std::pair<ConstraintLocator *, ProtocolConformanceRef>>
       Conformances;
 
   /// Simplify the given type by substituting all occurrences of
@@ -1055,7 +1055,7 @@ class ConstraintSystem {
   /// solution it represents.
   Score CurrentScore;
 
-  SmallVector<TypeVariableType *, 16> TypeVariables;
+  std::vector<TypeVariableType *> TypeVariables;
 
   /// Maps expressions to types for choosing a favored overload
   /// type in a disjunction constraint.
@@ -1090,7 +1090,7 @@ class ConstraintSystem {
   /// there are multiple ways in which one type could convert to another, e.g.,
   /// given class types A and B, the solver might choose either a superclass
   /// conversion or a user-defined conversion.
-  SmallVector<std::tuple<Type, Type, ConversionRestrictionKind>, 32>
+  std::vector<std::tuple<Type, Type, ConversionRestrictionKind>>
       ConstraintRestrictions;
 
   /// The set of fixes applied to make the solution work.
@@ -1100,7 +1100,7 @@ class ConstraintSystem {
 
   /// The set of remembered disjunction choices used to reach
   /// the current constraint system.
-  SmallVector<std::pair<ConstraintLocator*, unsigned>, 32>
+  std::vector<std::pair<ConstraintLocator*, unsigned>>
       DisjunctionChoices;
 
   /// The worklist of "active" constraints that should be revisited
@@ -1124,12 +1124,12 @@ class ConstraintSystem {
   SmallVector<std::pair<ConstraintLocator *, OpenedArchetypeType *>, 4>
     OpenedExistentialTypes;
 
-  SmallVector<std::pair<ConstraintLocator *, ProtocolConformanceRef>, 8>
+  std::vector<std::pair<ConstraintLocator *, ProtocolConformanceRef>>
       CheckedConformances;
 
 public:
   /// The locators of \c Defaultable constraints whose defaults were used.
-  SmallVector<ConstraintLocator *, 8> DefaultedConstraints;
+  std::vector<ConstraintLocator *> DefaultedConstraints;
 
   /// A cache that stores the @dynamicCallable required methods implemented by
   /// types.