Sema: Record retired constraints in the trail

Author: slavapestov

include/swift/Sema/CSTrail.def

@@ -61,6 +61,7 @@ CLOSURE_CHANGE(RecordedPreconcurrencyClosure)
 CONSTRAINT_CHANGE(DisabledConstraint)
 CONSTRAINT_CHANGE(FavoredConstraint)
 CONSTRAINT_CHANGE(GeneratedConstraint)
+CONSTRAINT_CHANGE(RetiredConstraint)
 
 CHANGE(AddedTypeVariable)
 CHANGE(AddedConstraint)

include/swift/Sema/ConstraintSystem.h

@@ -2540,26 +2540,11 @@ class ConstraintSystem {
     #define CS_STATISTIC(Name, Description) unsigned Name = 0;
     #include "ConstraintSolverStats.def"
 
-    /// Check whether there are any retired constraints present.
-    bool hasRetiredConstraints() const {
-      return !retiredConstraints.empty();
-    }
-
     /// Mark given constraint as retired along current solver path.
     ///
     /// \param constraint The constraint to retire temporarily.
     void retireConstraint(Constraint *constraint) {
-      retiredConstraints.push_front(constraint);
-    }
-
-    /// Iterate over all of the retired constraints registered with
-    /// current solver state.
-    ///
-    /// \param processor The processor function to be applied to each of
-    /// the constraints retrieved.
-    void forEachRetired(llvm::function_ref<void(Constraint &)> processor) {
-      for (auto &constraint : retiredConstraints)
-        processor(constraint);
+      Trail.recordChange(SolverTrail::Change::RetiredConstraint(constraint));
     }
 
     /// Add new "generated" constraint along the current solver path.
@@ -2569,49 +2554,26 @@ class ConstraintSystem {
       Trail.recordChange(SolverTrail::Change::GeneratedConstraint(constraint));
     }
 
-    /// Register given scope to be tracked by the current solver state,
-    /// this helps to make sure that all of the retired/generated constraints
-    /// are dealt with correctly when the life time of the scope ends.
+    /// Update statistics when a scope begins.
     ///
     /// \param scope The scope to associate with current solver state.
-    void registerScope(SolverScope *scope) {
+    void beginScope(SolverScope *scope) {
       ++depth;
       maxDepth = std::max(maxDepth, depth);
       scope->scopeNumber = NumStatesExplored++;
 
       CS.incrementScopeCounter();
-      auto scopeInfo =
-        std::make_tuple(scope, retiredConstraints.begin());
-      scopes.push_back(scopeInfo);
     }
 
-    /// Restore all of the retired/generated constraints to the state
-    /// before given scope. This is required because retired constraints have
-    /// to be re-introduced to the system in order of arrival (LIFO) and list
-    /// of the generated constraints has to be truncated back to the
-    /// original size.
+    /// Update statistics when a scope ends.
     ///
     /// \param scope The solver scope to rollback.
-    void rollback(SolverScope *scope) {
+    void endScope(SolverScope *scope) {
       --depth;
 
       unsigned countScopesExplored = NumStatesExplored - scope->scopeNumber;
       if (countScopesExplored == 1)
         CS.incrementLeafScopes();
-
-      SolverScope *savedScope;
-      // The position of last retired constraint before given scope.
-      ConstraintList::iterator lastRetiredPos;
-
-      std::tie(savedScope, lastRetiredPos) =
-        scopes.pop_back_val();
-
-      assert(savedScope == scope && "Scope rollback not in LIFO order!");
-
-      // Restore all of the retired constraints.
-      CS.InactiveConstraints.splice(CS.InactiveConstraints.end(),
-                                    retiredConstraints,
-                                    retiredConstraints.begin(), lastRetiredPos);
     }
 
     /// Check whether constraint system is allowed to form solutions
@@ -2638,25 +2600,12 @@ class ConstraintSystem {
     }
 
   private:
-    /// The list of constraints that have been retired along the
-    /// current path, this list is used in LIFO fashion when
-    /// constraints are added back to the circulation.
-    ConstraintList retiredConstraints;
+    /// Depth of the solution stack.
+    unsigned depth = 0;
 
     /// The set of constraints which were active at the time of this state
     /// creating, it's used to re-activate them on destruction.
     SmallVector<Constraint *, 4> activeConstraints;
-
-    /// The collection which holds association between solver scope
-    /// and position of the last retired constraint and number of
-    /// constraints generated before registration of given scope,
-    /// this helps to rollback all of the constraints retired/generated
-    /// each of the registered scopes correct (LIFO) order.
-    llvm::SmallVector<
-      std::tuple<SolverScope *, ConstraintList::iterator>, 4> scopes;
-
-    /// Depth of the solution stack.
-    unsigned depth = 0;
   };
 
   class CacheExprTypes : public ASTWalker {

lib/Sema/CSSolver.cpp

@@ -654,10 +654,6 @@ ConstraintSystem::SolverState::~SolverState() {
   if (CS.inInvalidState())
     return;
 
-  // Make sure that all of the retired constraints have been returned
-  // to constraint system.
-  assert(!hasRetiredConstraints());
-
   // Re-activate constraints which were initially marked as "active"
   // to restore original state of the constraint system.
   for (auto *constraint : activeConstraints) {
@@ -715,7 +711,7 @@ ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
   numTypeVariables = cs.TypeVariables.size();
   numFixes = cs.Fixes.size();
 
-  cs.solverState->registerScope(this);
+  cs.solverState->beginScope(this);
   assert(!cs.failedConstraint && "Unexpected failed constraint!");
 }
 
@@ -739,10 +735,7 @@ ConstraintSystem::SolverScope::~SolverScope() {
   // Roll back changes to the constraint system.
   cs.solverState->Trail.undo(numTrailChanges);
 
-  // Rollback all of the changes done to constraints by the current scope,
-  // e.g. add retired constraints back to the circulation and remove generated
-  // constraints introduced by the current scope.
-  cs.solverState->rollback(this);
+  cs.solverState->endScope(this);
 
   // Clear out other "failed" state.
   cs.failedConstraint = nullptr;

lib/Sema/CSTrail.cpp

@@ -520,6 +520,10 @@ void SolverTrail::Change::undo(ConstraintSystem &cs) const {
     cs.InactiveConstraints.erase(iter);
     break;
   }
+
+  case ChangeKind::RetiredConstraint:
+    cs.InactiveConstraints.push_back(TheConstraint.Constraint);
+    break;
   }
 }
 

lib/Sema/TypeCheckConstraints.cpp

@@ -1508,15 +1508,6 @@ void ConstraintSystem::print(raw_ostream &out) const {
     }
   }
 
-  if (solverState && solverState->hasRetiredConstraints()) {
-    out.indent(indent) << "Retired Constraints:\n";
-    solverState->forEachRetired([&](Constraint &constraint) {
-      out.indent(indent + 2);
-      constraint.print(out, &getASTContext().SourceMgr);
-      out << "\n";
-    });
-  }
-
   if (!ResolvedOverloads.empty()) {
     out.indent(indent) << "Resolved overloads:\n";