Sema: Remove last heap allocation of Scope

Author: slavapestov

include/swift/Sema/ConstraintSystem.h

@@ -2143,8 +2143,6 @@ class ConstraintSystem {
   friend struct ClosureIsolatedByPreconcurrency;
   friend class SolverTrail;
 
-  class SolverScope;
-
   /// Expressions that are known to be unevaluated.
   /// Note: this is only used to support ObjCSelectorExpr at the moment.
   llvm::SmallPtrSet<Expr *, 2> UnevaluatedRootExprs;
@@ -2555,23 +2553,21 @@ class ConstraintSystem {
     }
 
     /// Update statistics when a scope begins.
-    ///
-    /// \param scope The scope to associate with current solver state.
-    void beginScope(SolverScope *scope) {
+    unsigned beginScope() {
       ++depth;
       maxDepth = std::max(maxDepth, depth);
-      scope->scopeNumber = NumStatesExplored++;
 
       CS.incrementScopeCounter();
+
+      return NumStatesExplored++;
     }
 
     /// Update statistics when a scope ends.
-    ///
-    /// \param scope The solver scope to rollback.
-    void endScope(SolverScope *scope) {
+    void endScope(unsigned scopeNumber) {
+      ASSERT(depth > 0);
       --depth;
 
-      unsigned countScopesExplored = NumStatesExplored - scope->scopeNumber;
+      unsigned countScopesExplored = NumStatesExplored - scopeNumber;
       if (countScopesExplored == 1)
         CS.incrementLeafScopes();
     }
@@ -2775,7 +2771,7 @@ class ConstraintSystem {
   /// this object is destroyed.
   ///
   ///
-  class SolverScope {
+  struct SolverScope {
     ConstraintSystem &cs;
 
     /// The length of \c TypeVariables.
@@ -2785,15 +2781,19 @@ class ConstraintSystem {
     unsigned numTrailChanges;
 
     /// The scope number of this scope. Set when the scope is registered.
-    unsigned scopeNumber = 0;
+    unsigned scopeNumber : 31;
+
+    /// A moved-from scope skips doing anything in the destructor.
+    unsigned moved : 1;
+
+    explicit SolverScope(ConstraintSystem &cs);
 
     SolverScope(const SolverScope &) = delete;
-    SolverScope &operator=(const SolverScope &) = delete;
+    SolverScope(SolverScope &&other);
 
-    friend class ConstraintSystem;
+    SolverScope &operator=(const SolverScope &) = delete;
+    SolverScope &operator=(SolverScope &&) = delete;
 
-  public:
-    explicit SolverScope(ConstraintSystem &cs);
     ~SolverScope();
   };
 

lib/Sema/CSSolver.cpp

@@ -702,21 +702,32 @@ ConstraintSystem::SolverState::~SolverState() {
 }
 
 ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
-  : cs(cs) {
-  numTrailChanges = cs.solverState->Trail.size();
-
-  numTypeVariables = cs.TypeVariables.size();
+  : cs(cs),
+    numTypeVariables(cs.TypeVariables.size()),
+    numTrailChanges(cs.solverState->Trail.size()),
+    scopeNumber(cs.solverState->beginScope()),
+    moved(0) {
+  ASSERT(!cs.failedConstraint && "Unexpected failed constraint!");
+}
 
-  cs.solverState->beginScope(this);
-  assert(!cs.failedConstraint && "Unexpected failed constraint!");
+ConstraintSystem::SolverScope::SolverScope(SolverScope &&other)
+  : cs(other.cs),
+    numTypeVariables(other.numTypeVariables),
+    numTrailChanges(other.numTrailChanges),
+    scopeNumber(other.scopeNumber),
+    moved(0) {
+  other.moved = 1;
 }
 
 ConstraintSystem::SolverScope::~SolverScope() {
+  if (moved)
+    return;
+
   // Don't attempt to rollback from an incorrect state.
   if (cs.inInvalidState())
     return;
 
-  // Erase the end of various lists.
+  // Roll back introduced type variables.
   truncate(cs.TypeVariables, numTypeVariables);
 
   // Move any remaining active constraints into the inactive list.
@@ -731,7 +742,8 @@ ConstraintSystem::SolverScope::~SolverScope() {
   // Roll back changes to the constraint system.
   cs.solverState->Trail.undo(numTrailChanges);
 
-  cs.solverState->endScope(this);
+  // Update statistics.
+  cs.solverState->endScope(scopeNumber);
 
   // Clear out other "failed" state.
   cs.failedConstraint = nullptr;

lib/Sema/CSStep.h

@@ -519,7 +519,7 @@ template <typename P> class BindingStep : public SolverStep {
   /// being attempted, helps to rewind state of the
   /// constraint system back to original before attempting
   /// next binding, if any.
-  std::optional<std::pair<std::unique_ptr<Scope>, typename P::Element>>
+  std::optional<std::pair<Scope, typename P::Element>>
       ActiveChoice;
 
   BindingStep(ConstraintSystem &cs, P producer,
@@ -548,16 +548,14 @@ template <typename P> class BindingStep : public SolverStep {
       }
 
       {
-        auto &trail = CS.solverState->Trail;
-        unsigned size = trail.size();
-
-        auto scope = std::make_unique<Scope>(CS);
+        Scope scope(CS);
         if (attempt(*choice)) {
           ActiveChoice.emplace(std::move(scope), *choice);
 
           if (CS.isDebugMode()) {
-            trail.dumpActiveScopeChanges(
-              llvm::errs(), size, CS.solverState->getCurrentIndent());
+            CS.solverState->Trail.dumpActiveScopeChanges(
+              llvm::errs(), ActiveChoice->first.numTrailChanges,
+              CS.solverState->getCurrentIndent());
           }
 
           return suspend(std::make_unique<SplitterStep>(CS, Solutions));