RequirementMachine: Rename RewriteStep::RuleID to RewriteStep::Arg

It's used to store more than just the rule ID. However, add a
getRuleID() method that also asserts that Kind is ApplyRewriteRule
for readability.

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -88,9 +88,9 @@ RewriteLoop::findRulesAppearingOnceInEmptyContext(
     switch (step.Kind) {
     case RewriteStep::ApplyRewriteRule: {
       if (!step.isInContext() && !evaluator.isInContext())
-        rulesInEmptyContext.insert(step.RuleID);
+        rulesInEmptyContext.insert(step.getRuleID());
 
-      ++ruleMultiplicity[step.RuleID];
+      ++ruleMultiplicity[step.getRuleID()];
       break;
     }
 
@@ -207,7 +207,7 @@ RewritePath RewritePath::splitCycleAtRule(unsigned ruleID) const {
   for (auto step : Steps) {
     switch (step.Kind) {
     case RewriteStep::ApplyRewriteRule: {
-      if (step.RuleID != ruleID)
+      if (step.getRuleID() != ruleID)
         break;
 
       assert(!sawRule && "Rule appears more than once?");
@@ -262,7 +262,7 @@ bool RewritePath::replaceRuleWithPath(unsigned ruleID,
 
   for (const auto &step : Steps) {
     if (step.Kind == RewriteStep::ApplyRewriteRule &&
-        step.RuleID == ruleID) {
+        step.getRuleID() == ruleID) {
       foundAny = true;
       break;
     }
@@ -282,7 +282,7 @@ bool RewritePath::replaceRuleWithPath(unsigned ruleID,
   for (const auto &step : Steps) {
     switch (step.Kind) {
     case RewriteStep::ApplyRewriteRule: {
-      if (step.RuleID != ruleID) {
+      if (step.getRuleID() != ruleID) {
         newSteps.push_back(step);
         break;
       }

lib/AST/RequirementMachine/MinimalConformances.cpp

@@ -113,7 +113,7 @@ void RewriteLoop::findProtocolConformanceRules(
     if (!evaluator.isInContext()) {
       switch (step.Kind) {
       case RewriteStep::ApplyRewriteRule: {
-        const auto &rule = system.getRule(step.RuleID);
+        const auto &rule = system.getRule(step.getRuleID());
 
         if (rule.isIdentityConformanceRule())
           break;
@@ -127,7 +127,7 @@ void RewriteLoop::findProtocolConformanceRules(
             // the prefix term is 'X'.
             const auto &term = evaluator.getCurrentTerm();
             MutableTerm prefix(term.begin(), term.begin() + step.StartOffset);
-            result[proto].RulesInContext.emplace_back(prefix, step.RuleID);
+            result[proto].RulesInContext.emplace_back(prefix, step.getRuleID());
           }
         }
 
@@ -262,7 +262,7 @@ MinimalConformances::decomposeTermIntoConformanceRuleLeftHandSides(
   const auto &step = *steps.begin();
 
 #ifndef NDEBUG
-  const auto &rule = System.getRule(step.RuleID);
+  const auto &rule = System.getRule(step.getRuleID());
   assert(rule.isAnyConformanceRule());
   assert(!rule.isIdentityConformanceRule());
 #endif
@@ -277,9 +277,10 @@ MinimalConformances::decomposeTermIntoConformanceRuleLeftHandSides(
     // Build the term U.
     MutableTerm prefix(term.begin(), term.begin() + step.StartOffset);
 
-    decomposeTermIntoConformanceRuleLeftHandSides(prefix, step.RuleID, result);
+    decomposeTermIntoConformanceRuleLeftHandSides(
+        prefix, step.getRuleID(), result);
   } else {
-    result.push_back(step.RuleID);
+    result.push_back(step.getRuleID());
   }
 }
 

lib/AST/RequirementMachine/RewriteLoop.cpp

@@ -61,7 +61,7 @@ void RewriteStep::dump(llvm::raw_ostream &out,
     evaluator.applyDecompose(*this, system);
 
     out << (Inverse ? "Compose(" : "Decompose(");
-    out << RuleID << ")";
+    out << Arg << ")";
     break;
   }
   case ConcreteConformance: {
@@ -177,7 +177,7 @@ RewritePathEvaluator::applyRewriteRule(const RewriteStep &step,
 
   assert(step.Kind == RewriteStep::ApplyRewriteRule);
 
-  const auto &rule = system.getRule(step.RuleID);
+  const auto &rule = system.getRule(step.getRuleID());
 
   auto lhs = (step.Inverse ? rule.getRHS() : rule.getLHS());
   auto rhs = (step.Inverse ? rule.getLHS() : rule.getRHS());
@@ -220,7 +220,7 @@ RewritePathEvaluator::applyAdjustment(const RewriteStep &step,
 
   auto &ctx = system.getRewriteContext();
   MutableTerm prefix(term.begin() + step.StartOffset,
-                     term.begin() + step.StartOffset + step.RuleID);
+                     term.begin() + step.StartOffset + step.Arg);
   MutableTerm suffix(term.end() - step.EndOffset - 1, term.end());
 
   // We're either adding or removing the prefix to each concrete substitution.
@@ -237,7 +237,7 @@ RewritePathEvaluator::applyAdjustment(const RewriteStep &step,
     [&](Term t) -> Term {
       if (step.Inverse) {
         if (!std::equal(t.begin(),
-                        t.begin() + step.RuleID,
+                        t.begin() + step.Arg,
                         prefix.begin())) {
           llvm::errs() << "Invalid rewrite path\n";
           llvm::errs() << "- Term: " << term << "\n";
@@ -248,7 +248,7 @@ RewritePathEvaluator::applyAdjustment(const RewriteStep &step,
           abort();
         }
 
-        MutableTerm mutTerm(t.begin() + step.RuleID, t.end());
+        MutableTerm mutTerm(t.begin() + step.Arg, t.end());
         return Term::get(mutTerm, ctx);
       } else {
         MutableTerm mutTerm(prefix);
@@ -265,7 +265,7 @@ void RewritePathEvaluator::applyShift(const RewriteStep &step,
   assert(step.Kind == RewriteStep::Shift);
   assert(step.StartOffset == 0);
   assert(step.EndOffset == 0);
-  assert(step.RuleID == 0);
+  assert(step.Arg == 0);
 
   if (!step.Inverse) {
     // Move top of primary stack to secondary stack.
@@ -285,7 +285,7 @@ void RewritePathEvaluator::applyDecompose(const RewriteStep &step,
   assert(step.Kind == RewriteStep::Decompose);
 
   auto &ctx = system.getRewriteContext();
-  unsigned numSubstitutions = step.RuleID;
+  unsigned numSubstitutions = step.Arg;
 
   if (!step.Inverse) {
     // The input term takes the form U.[concrete: C].V or U.[superclass: C].V,
@@ -443,7 +443,7 @@ void RewritePathEvaluator::applyConcreteTypeWitness(const RewriteStep &step,
   checkPrimary();
   auto &term = Primary.back();
 
-  const auto &witness = system.getTypeWitness(step.RuleID);
+  const auto &witness = system.getTypeWitness(step.Arg);
   auto fail = [&]() {
     llvm::errs() << "Bad concrete type witness term:\n";
     llvm::errs() << term << "\n\n";
@@ -501,7 +501,7 @@ void RewritePathEvaluator::applySameTypeWitness(const RewriteStep &step,
   checkPrimary();
   auto &term = Primary.back();
 
-  const auto &witness = system.getTypeWitness(step.RuleID);
+  const auto &witness = system.getTypeWitness(step.Arg);
   auto fail = [&]() {
     llvm::errs() << "Bad same-type witness term:\n";
     llvm::errs() << term << "\n\n";
@@ -574,7 +574,7 @@ RewritePathEvaluator::applyAbstractTypeWitness(const RewriteStep &step,
   checkPrimary();
   auto &term = Primary.back();
 
-  const auto &witness = system.getTypeWitness(step.RuleID);
+  const auto &witness = system.getTypeWitness(step.Arg);
   auto fail = [&]() {
     llvm::errs() << "Bad abstract type witness term:\n";
     llvm::errs() << term << "\n\n";

lib/AST/RequirementMachine/RewriteLoop.h

@@ -51,7 +51,7 @@ struct RewriteStep {
     ///
     /// The StartOffset field encodes the offset where to apply the rule.
     ///
-    /// The RuleID field encodes the rule to apply.
+    /// The Arg field encodes the rule to apply.
     ApplyRewriteRule,
 
     /// The term at the top of the primary stack must be a term ending with a
@@ -80,7 +80,7 @@ struct RewriteStep {
     /// 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.
+    /// The Arg field encodes the number of substitutions.
     Decompose,
 
     ///
@@ -117,10 +117,7 @@ struct RewriteStep {
     ///
     /// If inverted: the concrete type symbol [concrete: C.X] is introduced.
     ///
-    /// The RuleID field is repurposed to store the result of calling
-    /// RewriteSystem::recordTypeWitness(). This index is then passed in
-    /// to RewriteSystem::getTypeWitness() when applying
-    /// the step.
+    /// The Arg field stores the result of RewriteSystem::recordTypeWitness().
     ConcreteTypeWitness,
 
     /// If not inverted: the top of the primary stack must be a term ending in a
@@ -129,8 +126,7 @@ struct RewriteStep {
     ///
     /// If inverted: the associated type symbol [P:X] is introduced.
     ///
-    /// The RuleID field is a TypeWitness ID as above.
-    /// the step.
+    /// The Arg field stores the result of RewriteSystem::recordTypeWitness().
     SameTypeWitness,
 
     /// If not inverted: replaces the abstract type witness term with the
@@ -139,7 +135,7 @@ struct RewriteStep {
     /// If inverted: replaces the subject type term with the abstract type
     /// term.
     ///
-    /// The RuleID field is a TypeWitness ID as above.
+    /// The Arg field stores the result of RewriteSystem::recordTypeWitness().
     AbstractTypeWitness,
   };
 
@@ -164,18 +160,18 @@ struct RewriteStep {
   /// at the beginning of each concrete substitution.
   ///
   /// If Kind is Concrete, the number of substitutions to push or pop.
-  unsigned RuleID : 16;
+  unsigned Arg : 16;
 
   RewriteStep(StepKind kind, unsigned startOffset, unsigned endOffset,
-              unsigned ruleID, bool inverse) {
+              unsigned arg, bool inverse) {
     Kind = kind;
 
     StartOffset = startOffset;
     assert(StartOffset == startOffset && "Overflow");
     EndOffset = endOffset;
     assert(EndOffset == endOffset && "Overflow");
-    RuleID = ruleID;
-    assert(RuleID == ruleID && "Overflow");
+    Arg = arg;
+    assert(Arg == arg && "Overflow");
     Inverse = inverse;
   }
 
@@ -187,42 +183,42 @@ struct RewriteStep {
   static RewriteStep forAdjustment(unsigned offset, unsigned endOffset,
                                    bool inverse) {
     return RewriteStep(AdjustConcreteType, /*startOffset=*/0, endOffset,
-                       /*ruleID=*/offset, inverse);
+                       /*arg=*/offset, inverse);
   }
 
   static RewriteStep forShift(bool inverse) {
     return RewriteStep(Shift, /*startOffset=*/0, /*endOffset=*/0,
-                       /*ruleID=*/0, inverse);
+                       /*arg=*/0, inverse);
   }
 
   static RewriteStep forDecompose(unsigned numSubstitutions, bool inverse) {
     return RewriteStep(Decompose, /*startOffset=*/0, /*endOffset=*/0,
-                       /*ruleID=*/numSubstitutions, inverse);
+                       /*arg=*/numSubstitutions, inverse);
   }
 
   static RewriteStep forConcreteConformance(bool inverse) {
     return RewriteStep(ConcreteConformance, /*startOffset=*/0, /*endOffset=*/0,
-                       /*ruleID=*/0, inverse);
+                       /*arg=*/0, inverse);
   }
 
   static RewriteStep forSuperclassConformance(bool inverse) {
     return RewriteStep(SuperclassConformance, /*startOffset=*/0, /*endOffset=*/0,
-                       /*ruleID=*/0, inverse);
+                       /*arg=*/0, inverse);
   }
 
   static RewriteStep forConcreteTypeWitness(unsigned witnessID, bool inverse) {
     return RewriteStep(ConcreteTypeWitness, /*startOffset=*/0, /*endOffset=*/0,
-                       /*ruleID=*/witnessID, inverse);
+                       /*arg=*/witnessID, inverse);
   }
 
   static RewriteStep forSameTypeWitness(unsigned witnessID, bool inverse) {
     return RewriteStep(SameTypeWitness, /*startOffset=*/0, /*endOffset=*/0,
-                       /*ruleID=*/witnessID, inverse);
+                       /*arg=*/witnessID, inverse);
   }
 
   static RewriteStep forAbstractTypeWitness(unsigned witnessID, bool inverse) {
     return RewriteStep(AbstractTypeWitness, /*startOffset=*/0, /*endOffset=*/0,
-                       /*ruleID=*/witnessID, inverse);
+                       /*arg=*/witnessID, inverse);
   }
 
   bool isInContext() const {
@@ -233,10 +229,10 @@ struct RewriteStep {
     Inverse = !Inverse;
   }
 
-  bool isInverseOf(const RewriteStep &other) const;
-
-  bool maybeSwapRewriteSteps(RewriteStep &other,
-                             const RewriteSystem &system);
+  unsigned getRuleID() const {
+    assert(Kind == RewriteStep::ApplyRewriteRule);
+    return Arg;
+  }
 
   void dump(llvm::raw_ostream &out,
             RewritePathEvaluator &evaluator,