[ConstraintSystem] Make sure that system is returned into its original state after solving

Currently (with or w/o failures) constraint system is not returned
back to its original state after solving, because constraints from
initial "active" list are not returned to the system. To fix that
let's allocate "initial" scope which captures state right before
solving begins, and add "active" list to the solver state to capture
information about "active" constraints at the time of its creation.

This is follow-up to swiftlang#19873

Author: xedin

lib/Sema/CSSolver.cpp

@@ -406,6 +406,10 @@ ConstraintSystem::SolverState::SolverState(
   ++NumSolutionAttempts;
   SolutionAttempt = NumSolutionAttempts;
 
+  // Record active constraints for re-activation at the end of lifetime.
+  for (auto &constraint : cs.ActiveConstraints)
+    activeConstraints.push_back(&constraint);
+
   // If we're supposed to debug a specific constraint solver attempt,
   // turn on debugging now.
   ASTContext &ctx = CS.getTypeChecker().Context;
@@ -425,6 +429,34 @@ ConstraintSystem::SolverState::~SolverState() {
          "Expected constraint system to have this solver state!");
   CS.solverState = nullptr;
 
+  // Make sure that all of the retired constraints have been returned
+  // to constraint system.
+  assert(!hasRetiredConstraints());
+
+  // Make sure that all of the generated constraints have been handled.
+  assert(generatedConstraints.empty());
+
+  // Re-activate constraints which were initially marked as "active"
+  // to restore original state of the constraint system.
+  for (auto *constraint : activeConstraints) {
+    // If the constraint is already active we can just move on.
+    if (constraint->isActive())
+      continue;
+
+    // Make sure that constraint is present in the "inactive" set
+    // before transferring it to "active".
+    auto existing = llvm::find_if(CS.InactiveConstraints,
+                                  [&constraint](const Constraint &inactive) {
+                                    return &inactive == constraint;
+                                  });
+    assert(existing != CS.InactiveConstraints.end());
+
+    // Transfer the constraint to "active" set.
+    CS.InactiveConstraints.erase(existing);
+    CS.ActiveConstraints.push_back(constraint);
+    constraint->setActive(true);
+  }
+
   // Restore debugging state.
   LangOptions &langOpts = CS.getTypeChecker().Context.LangOpts;
   langOpts.DebugConstraintSolver = OldDebugConstraintSolver;
@@ -1230,6 +1262,17 @@ bool ConstraintSystem::solve(Expr *const expr,
 void ConstraintSystem::solve(SmallVectorImpl<Solution> &solutions) {
   assert(solverState);
 
+  // If constraint system failed while trying to
+  // genenerate constraints, let's stop right here.
+  if (failedConstraint)
+    return;
+
+  // Allocate new solver scope, so constraint system
+  // could be restored to its original state afterwards.
+  // Otherwise there is a risk that some of the constraints
+  // are not going to be re-introduced to the system.
+  SolverScope scope(*this);
+
   SmallVector<std::unique_ptr<SolverStep>, 16> workList;
   // First step is always wraps whole constraint system.
   workList.push_back(llvm::make_unique<SplitterStep>(*this, solutions));

lib/Sema/ConstraintSystem.cpp

@@ -2045,15 +2045,6 @@ bool ConstraintSystem::salvage(SmallVectorImpl<Solution> &viable, Expr *expr) {
     SolverState state(expr, *this, FreeTypeVariableBinding::Disallow);
     state.recordFixes = true;
 
-    // Retry all inactive and failed constraints
-    if (failedConstraint) {
-      addUnsolvedConstraint(failedConstraint);
-      failedConstraint = nullptr;
-    }
-    ActiveConstraints.splice(ActiveConstraints.end(), InactiveConstraints);
-    for (auto &constraint : ActiveConstraints)
-      constraint.setActive(true);
-
     // Solve the system.
     solve(viable);
 

lib/Sema/ConstraintSystem.h

@@ -1308,6 +1308,10 @@ class ConstraintSystem {
     /// are added back to the circulation.
     ConstraintList retiredConstraints;
 
+    /// 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 current set of generated constraints.
     SmallVector<Constraint *, 4> generatedConstraints;
 

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

@@ -1,4 +1,4 @@
-// RUN: %scale-test --begin 1 --end 10 --step 1 --select incrementScopeCounter %s --expected-exit-code 0
+// RUN: %scale-test --begin 8 --end 40 --step 2 --select incrementScopeCounter %s --expected-exit-code 0
 // REQUIRES: OS=macosx
 // REQUIRES: asserts