RequirementMachine: Rename RewriteStep::ApplyRewriteRule to RewriteStep::Rule

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -86,7 +86,7 @@ RewriteLoop::findRulesAppearingOnceInEmptyContext(
 
   for (auto step : Path) {
     switch (step.Kind) {
-    case RewriteStep::ApplyRewriteRule: {
+    case RewriteStep::Rule: {
       if (!step.isInContext() && !evaluator.isInContext())
         rulesInEmptyContext.insert(step.getRuleID());
 
@@ -207,7 +207,7 @@ RewritePath RewritePath::splitCycleAtRule(unsigned ruleID) const {
 
   for (auto step : Steps) {
     switch (step.Kind) {
-    case RewriteStep::ApplyRewriteRule: {
+    case RewriteStep::Rule: {
       if (step.getRuleID() != ruleID)
         break;
 
@@ -263,7 +263,7 @@ bool RewritePath::replaceRuleWithPath(unsigned ruleID,
   bool foundAny = false;
 
   for (const auto &step : Steps) {
-    if (step.Kind == RewriteStep::ApplyRewriteRule &&
+    if (step.Kind == RewriteStep::Rule &&
         step.getRuleID() == ruleID) {
       foundAny = true;
       break;
@@ -283,7 +283,7 @@ bool RewritePath::replaceRuleWithPath(unsigned ruleID,
 
   for (const auto &step : Steps) {
     switch (step.Kind) {
-    case RewriteStep::ApplyRewriteRule: {
+    case RewriteStep::Rule: {
       if (step.getRuleID() != ruleID) {
         newSteps.push_back(step);
         break;

lib/AST/RequirementMachine/MinimalConformances.cpp

@@ -112,7 +112,7 @@ void RewriteLoop::findProtocolConformanceRules(
   for (const auto &step : Path) {
     if (!evaluator.isInContext()) {
       switch (step.Kind) {
-      case RewriteStep::ApplyRewriteRule: {
+      case RewriteStep::Rule: {
         const auto &rule = system.getRule(step.getRuleID());
 
         if (rule.isIdentityConformanceRule())
@@ -268,7 +268,7 @@ MinimalConformances::decomposeTermIntoConformanceRuleLeftHandSides(
   assert(!rule.isIdentityConformanceRule());
 #endif
 
-  assert(step.Kind == RewriteStep::ApplyRewriteRule);
+  assert(step.Kind == RewriteStep::Rule);
   assert(step.EndOffset == 0);
   assert(!step.Inverse);
 

lib/AST/RequirementMachine/RewriteLoop.cpp

@@ -24,7 +24,7 @@ void RewriteStep::dump(llvm::raw_ostream &out,
                        RewritePathEvaluator &evaluator,
                        const RewriteSystem &system) const {
   switch (Kind) {
-  case ApplyRewriteRule: {
+  case Rule: {
     auto result = evaluator.applyRewriteRule(*this, system);
 
     if (!result.prefix.empty()) {
@@ -190,7 +190,7 @@ RewritePathEvaluator::applyRewriteRule(const RewriteStep &step,
                                        const RewriteSystem &system) {
   auto &term = getCurrentTerm();
 
-  assert(step.Kind == RewriteStep::ApplyRewriteRule);
+  assert(step.Kind == RewriteStep::Rule);
 
   const auto &rule = system.getRule(step.getRuleID());
 
@@ -662,7 +662,7 @@ RewritePathEvaluator::applyAbstractTypeWitness(const RewriteStep &step,
 void RewritePathEvaluator::apply(const RewriteStep &step,
                                  const RewriteSystem &system) {
   switch (step.Kind) {
-  case RewriteStep::ApplyRewriteRule:
+  case RewriteStep::Rule:
     (void) applyRewriteRule(step, system);
     break;
 

lib/AST/RequirementMachine/RewriteLoop.h

@@ -52,7 +52,7 @@ struct RewriteStep {
     /// The StartOffset field encodes the offset where to apply the rule.
     ///
     /// The Arg field encodes the rule to apply.
-    ApplyRewriteRule,
+    Rule,
 
     /// The term at the top of the primary stack must be a term ending with a
     /// superclass or concrete type symbol.
@@ -167,7 +167,7 @@ struct RewriteStep {
   /// after the rule is applied. In A.(X => Y).B, this is |B|=1.
   unsigned EndOffset : 16;
 
-  /// If Kind is ApplyRewriteRule, the index of the rule in the rewrite system.
+  /// If Kind is Rule, the index of the rule in the rewrite system.
   ///
   /// If Kind is AdjustConcreteType, the length of the prefix to add or remove
   /// at the beginning of each concrete substitution.
@@ -190,7 +190,7 @@ struct RewriteStep {
 
   static RewriteStep forRewriteRule(unsigned startOffset, unsigned endOffset,
                                     unsigned ruleID, bool inverse) {
-    return RewriteStep(ApplyRewriteRule, startOffset, endOffset, ruleID, inverse);
+    return RewriteStep(Rule, startOffset, endOffset, ruleID, inverse);
   }
 
   static RewriteStep forAdjustment(unsigned offset, unsigned endOffset,
@@ -249,7 +249,7 @@ struct RewriteStep {
   }
 
   unsigned getRuleID() const {
-    assert(Kind == RewriteStep::ApplyRewriteRule);
+    assert(Kind == RewriteStep::Rule);
     return Arg;
   }
 
@@ -375,15 +375,16 @@ 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 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 primary stack (if not inverted) or assembles a
 ///   new superclass or concrete type symbol at the top of the primary stack
 ///   (if inverted).
+///
+/// - All other rewrite step kinds manipulate the term at the top of the primary
+///   stack.
+///
 struct RewritePathEvaluator {
   /// The primary stack. Most rewrite steps operate on the top of this stack.
   SmallVector<MutableTerm, 2> Primary;