RequirementMachine: Rename A/B stack to primary/secondary stack

Author: slavapestov

lib/AST/RequirementMachine/RewriteLoop.cpp

@@ -139,35 +139,35 @@ void RewriteLoop::dump(llvm::raw_ostream &out,
 }
 
 void RewritePathEvaluator::dump(llvm::raw_ostream &out) const {
-  out << "A stack:\n";
-  for (const auto &term : A) {
+  out << "Primary stack:\n";
+  for (const auto &term : Primary) {
     out << term << "\n";
   }
-  out << "\nB stack:\n";
-  for (const auto &term : B) {
+  out << "\nSecondary stack:\n";
+  for (const auto &term : Secondary) {
     out << term << "\n";
   }
 }
 
-void RewritePathEvaluator::checkA() const {
-  if (A.empty()) {
-    llvm::errs() << "Empty A stack\n";
+void RewritePathEvaluator::checkPrimary() const {
+  if (Primary.empty()) {
+    llvm::errs() << "Empty primary stack\n";
     dump(llvm::errs());
     abort();
   }
 }
 
-void RewritePathEvaluator::checkB() const {
-  if (B.empty()) {
-    llvm::errs() << "Empty B stack\n";
+void RewritePathEvaluator::checkSecondary() const {
+  if (Secondary.empty()) {
+    llvm::errs() << "Empty secondary stack\n";
     dump(llvm::errs());
     abort();
   }
 }
 
 MutableTerm &RewritePathEvaluator::getCurrentTerm() {
-  checkA();
-  return A.back();
+  checkPrimary();
+  return Primary.back();
 }
 
 AppliedRewriteStep
@@ -268,15 +268,15 @@ void RewritePathEvaluator::applyShift(const RewriteStep &step,
   assert(step.RuleID == 0);
 
   if (!step.Inverse) {
-    // Move top of A stack to B stack.
-    checkA();
-    B.push_back(A.back());
-    A.pop_back();
+    // Move top of primary stack to secondary stack.
+    checkPrimary();
+    Secondary.push_back(Primary.back());
+    Primary.pop_back();
   } else {
-    // Move top of B stack to A stack.
-    checkB();
-    A.push_back(B.back());
-    B.pop_back();
+    // Move top of secondary stack to primary stack.
+    checkSecondary();
+    Primary.push_back(Secondary.back());
+    Secondary.pop_back();
   }
 }
 
@@ -294,7 +294,7 @@ void RewritePathEvaluator::applyDecompose(const RewriteStep &step,
     auto symbol = *(term.end() - step.EndOffset - 1);
     if (!symbol.hasSubstitutions()) {
       llvm::errs() << "Expected term with superclass or concrete type symbol"
-                   << " on A stack\n";
+                   << " on primary stack\n";
       dump(llvm::errs());
       abort();
     }
@@ -306,28 +306,28 @@ void RewritePathEvaluator::applyDecompose(const RewriteStep &step,
       abort();
     }
 
-    // Push each substitution on the A stack.
+    // Push each substitution on the primary stack.
     for (auto substitution : symbol.getSubstitutions()) {
-      A.push_back(MutableTerm(substitution));
+      Primary.push_back(MutableTerm(substitution));
     }
   } else {
-    // The A stack must store the number of substitutions, together with a
-    // term that takes the form U.[concrete: C].V or U.[superclass: C].V,
+    // The primary stack must store the number of substitutions, together with
+    // a term that takes the form U.[concrete: C].V or U.[superclass: C].V,
     // where |V| == EndOffset.
-    if (A.size() < numSubstitutions + 1) {
-      llvm::errs() << "Not enough terms on A stack\n";
+    if (Primary.size() < numSubstitutions + 1) {
+      llvm::errs() << "Not enough terms on primary stack\n";
       dump(llvm::errs());
       abort();
     }
 
     // The term immediately underneath the substitutions is the one we're
     // updating with new substitutions.
-    auto &term = *(A.end() - numSubstitutions - 1);
+    auto &term = *(Primary.end() - numSubstitutions - 1);
 
     auto &symbol = *(term.end() - step.EndOffset - 1);
     if (!symbol.hasSubstitutions()) {
       llvm::errs() << "Expected term with superclass or concrete type symbol"
-                   << " on A stack\n";
+                   << " on primary stack\n";
       dump(llvm::errs());
       abort();
     }
@@ -340,27 +340,27 @@ void RewritePathEvaluator::applyDecompose(const RewriteStep &step,
       abort();
     }
 
-    // Collect the substitutions from the A stack.
+    // Collect the substitutions from the primary stack.
     SmallVector<Term, 2> substitutions;
     substitutions.reserve(numSubstitutions);
     for (unsigned i = 0; i < numSubstitutions; ++i) {
-      const auto &substitution = *(A.end() - numSubstitutions + i);
+      const auto &substitution = *(Primary.end() - numSubstitutions + i);
       substitutions.push_back(Term::get(substitution, ctx));
     }
 
     // Build the new symbol with the new substitutions.
     symbol = symbol.withConcreteSubstitutions(substitutions, ctx);
 
-    // Pop the substitutions from the A stack.
-    A.resize(A.size() - numSubstitutions);
+    // Pop the substitutions from the primary stack.
+    Primary.resize(Primary.size() - numSubstitutions);
   }
 }
 
 void
 RewritePathEvaluator::applyConcreteConformance(const RewriteStep &step,
                                                const RewriteSystem &system) {
-  checkA();
-  auto &term = A.back();
+  checkPrimary();
+  auto &term = Primary.back();
   Symbol *last = term.end() - step.EndOffset;
 
   auto &ctx = system.getRewriteContext();
@@ -440,8 +440,8 @@ RewritePathEvaluator::applyConcreteConformance(const RewriteStep &step,
 
 void RewritePathEvaluator::applyConcreteTypeWitness(const RewriteStep &step,
                                                   const RewriteSystem &system) {
-  checkA();
-  auto &term = A.back();
+  checkPrimary();
+  auto &term = Primary.back();
 
   const auto &witness = system.getTypeWitness(step.RuleID);
   auto fail = [&]() {
@@ -498,8 +498,8 @@ void RewritePathEvaluator::applyConcreteTypeWitness(const RewriteStep &step,
 
 void RewritePathEvaluator::applySameTypeWitness(const RewriteStep &step,
                                                 const RewriteSystem &system) {
-  checkA();
-  auto &term = A.back();
+  checkPrimary();
+  auto &term = Primary.back();
 
   const auto &witness = system.getTypeWitness(step.RuleID);
   auto fail = [&]() {
@@ -571,8 +571,8 @@ void RewritePathEvaluator::applySameTypeWitness(const RewriteStep &step,
 void
 RewritePathEvaluator::applyAbstractTypeWitness(const RewriteStep &step,
                                                const RewriteSystem &system) {
-  checkA();
-  auto &term = A.back();
+  checkPrimary();
+  auto &term = Primary.back();
 
   const auto &witness = system.getTypeWitness(step.RuleID);
   auto fail = [&]() {

lib/AST/RequirementMachine/RewriteLoop.h

@@ -38,7 +38,7 @@ struct RewriteStep {
     /// *** Rewrite step kinds introduced by Knuth-Bendix completion ***
     ///
 
-    /// Apply a rewrite rule to the term at the top of the A stack.
+    /// Apply a rewrite rule to the term at the top of the primary stack.
     ///
     /// Formally, this is a whiskered, oriented rewrite rule. For example,
     /// given a rule (X => Y) and the term A.X.B, the application at
@@ -54,7 +54,7 @@ struct RewriteStep {
     /// The RuleID field encodes the rule to apply.
     ApplyRewriteRule,
 
-    /// The term at the top of the A stack must be a term ending with a
+    /// The term at the top of the primary stack must be a term ending with a
     /// superclass or concrete type symbol.
     ///
     /// If not inverted: prepend the prefix to each substitution.
@@ -68,17 +68,17 @@ struct RewriteStep {
     /// *** Rewrite step kinds introduced by simplifySubstitutions() ***
     ///
 
-    /// Move a term from the A stack to the B stack (if not inverted) or
-    /// B stack to A stack (if inverted).
+    /// Move a term from the primary stack to the secondary stack (if not
+    /// inverted) or the secondary stack to primary stack (if inverted).
     Shift,
 
-    /// If not inverted: the top of the A stack must be a term ending with a
-    /// superclass or concrete type symbol. Each concrete substitution in the
-    /// term is pushed onto the A stack.
+    /// If not inverted: the top of the primary stack must be a term ending
+    /// with a superclass or concrete type symbol. Each concrete substitution
+    /// in the term is pushed onto the primary stack.
     ///
-    /// If inverted: pop concrete substitutions from the A stack, which must
-    /// follow a term ending with a superclass or concrete type symbol. The
-    /// new substitutions replace the substitutions in that symbol.
+    /// If inverted: pop concrete substitutions from the primary stack, which
+    /// must follow a term ending with a superclass or concrete type symbol.
+    /// The new substitutions replace the substitutions in that symbol.
     ///
     /// The RuleID field encodes the number of substitutions.
     Decompose,
@@ -87,29 +87,29 @@ struct RewriteStep {
     /// *** Rewrite step kinds introduced by the property map ***
     ///
 
-    /// If not inverted: the top of the A stack must be a term ending in a
-    /// concrete type symbol [concrete: C] followed by a protocol symbol [P].
+    /// If not inverted: the top of the primary stack must be a term ending in
+    /// a concrete type symbol [concrete: C] followed by a protocol symbol [P].
     /// These two symbols are combined into a single concrete conformance
     /// symbol [concrete: C : P].
     ///
-    /// If inverted: the top of the A stack must be a term ending in a
+    /// If inverted: the top of the primary stack must be a term ending in a
     /// concrete conformance symbol [concrete: C : P]. This symbol is replaced
     /// with the concrete type symbol [concrete: C] followed by the protocol
     /// symbol [P].
     ConcreteConformance,
 
-    /// If not inverted: the top of the A stack must be a term ending in a
-    /// superclass symbol [superclass: C] followed by a protocol symbol [P].
+    /// If not inverted: the top of the primary stack must be a term ending in
+    /// a superclass symbol [superclass: C] followed by a protocol symbol [P].
     /// These two symbols are combined into a single concrete conformance
     /// symbol [concrete: C : P].
     ///
-    /// If inverted: the top of the A stack must be a term ending in a
+    /// If inverted: the top of the primary stack must be a term ending in a
     /// concrete conformance symbol [concrete: C : P]. This symbol is replaced
     /// with the superclass symbol [superclass: C] followed by the protocol
     /// symbol [P].
     SuperclassConformance,
 
-    /// If not inverted: the top of the A stack must be a term ending in a
+    /// If not inverted: the top of the primary stack must be a term ending in a
     /// concrete conformance symbol [concrete: C : P] followed by an associated
     /// type symbol [P:X], and the concrete type symbol [concrete: C.X] for the
     /// type witness of 'X' in the conformance 'C : P'. The concrete type symbol
@@ -123,7 +123,7 @@ struct RewriteStep {
     /// the step.
     ConcreteTypeWitness,
 
-    /// If not inverted: the top of the A stack must be a term ending in a
+    /// If not inverted: the top of the primary stack must be a term ending in a
     /// concrete conformance symbol [concrete: C : P] followed by an associated
     /// type symbol [P:X]. The associated type symbol is eliminated.
     ///
@@ -361,32 +361,36 @@ struct AppliedRewriteStep {
 /// A rewrite path is a list of instructions for a two-stack interpreter.
 ///
 /// - ApplyRewriteRule and AdjustConcreteType manipulate the term at the top of
-///   the A stack.
+///   the primary stack.
 ///
 /// - Shift moves a term from A to B (if not inverted) or B to A (if inverted).
 ///
 /// - Decompose splits off the substitutions from a superclass or concrete type
-///   symbol at the top of the A stack (if not inverted) or assembles a new
-///   superclass or concrete type symbol at the top of the A stack
+///   symbol at the top of the primary stack (if not inverted) or assembles a
+///   new superclass or concrete type symbol at the top of the primary stack
 ///   (if inverted).
 struct RewritePathEvaluator {
-  SmallVector<MutableTerm, 2> A;
-  SmallVector<MutableTerm, 2> B;
+  /// The primary stack. Most rewrite steps operate on the top of this stack.
+  SmallVector<MutableTerm, 2> Primary;
+
+  /// The secondary stack. The 'Shift' rewrite step moves terms between the
+  /// primary and secondary stacks.
+  SmallVector<MutableTerm, 2> Secondary;
 
   explicit RewritePathEvaluator(const MutableTerm &term) {
-    A.push_back(term);
+    Primary.push_back(term);
   }
 
-  void checkA() const;
-  void checkB() const;
+  void checkPrimary() const;
+  void checkSecondary() const;
 
   MutableTerm &getCurrentTerm();
 
   /// We're "in context" if we're in the middle of rewriting concrete
   /// substitutions.
   bool isInContext() const {
-    assert(A.size() > 0);
-    return (A.size() > 1 || B.size() > 0);
+    assert(Primary.size() > 0);
+    return (Primary.size() > 1 || Secondary.size() > 0);
   }
 
   void apply(const RewriteStep &step,