RequirementMachine: Rewrite steps are instructions for a two-stack machine

I need to simplify concrete substitutions when adding a rewrite rule, so
for example if X.Y => Z, we want to simplify

  A.[concrete: G<τ_0_0, τ_0_1> with <X.Y, X>] => A

to

  A.[concrete: G<τ_0_0, τ_0_1> with <Z, X>] => A

The requirement machine used to do this, but I took it out, because it
didn't fit with the rewrite path representation. However, I found a case
where this is needed so I need to bring it back.

Until now, a rewrite path was a composition of rewrite steps where each
step would transform a source term into a destination term.

The question then becomes, how do we represent concrete substitution
simplification with such a scheme.

One approach is to rework rewrite paths to a 'nested' representation,
where a new kind of rewrite step applies a sequence of rewrite paths to
the concrete substitution terms. Unfortunately this would complicate
memory management and require recursion when visiting the steps of a
rewrite path.

Another, simpler approach that I'm going with here is to generalize a
rewrite path to a stack machine program instead.

I'm adding two new kinds of rewrite steps which manipulate a pair of
stacks, called 'A' and 'B':

- Decompose, which takes a term ending in a superclass or concrete type
  symbol, and pushes each concrete substitution on the 'A' stack.

- A>B, which pops the top of the 'A' stack and pushes it onto the 'B'
  stack.

Since all rewrite steps are invertible, the inverse of the two new
step kinds are as follows:

- Compose, which pops a series of terms from the 'A' stack, and replaces
  the concrete substitutions in the term ending in a superclass or
  concrete type symbol underneath.

- B>A, which pops the top of the 'B' stack and pushes it onto the
  'B' stack.

Both Decompose and Compose take an operand, which is the number of
concrete substitutions to expect. This is encoded in the RuleID field
of RewriteStep.

The two existing rewrite steps ApplyRewriteRule and AdjustConcreteType
simply pop and push the term at the top of the 'A' stack.

Now, if addRule() wishes to transform

  A.[concrete: G<τ_0_0, τ_0_1> with <X.Y, X>] => A

into

  A.[concrete: G<τ_0_0, τ_0_1> with <Z, X>] => A

it can construct the rewrite path

  Decompose(2) ⊗ A>B ⊗ <<rewrite path from X.Y to Z>> ⊗ B>A ⊗ Compose(2)

This commit lays down the plumbing for these new rewrite steps, and
replaces the existing 'evaluation' walks over rewrite paths that
mutate a single MutableTerm with a new RewritePathEvaluator type, that
stores the two stacks.

The changes to addRule() are coming in a subsequent commit.

Author: slavapestov

lib/AST/RequirementMachine/GeneratingConformances.cpp

@@ -84,7 +84,7 @@ void HomotopyGenerator::findProtocolConformanceRules(
                         &result,
     const RewriteSystem &system) const {
 
-  auto redundantRules = Path.findRulesAppearingOnceInEmptyContext();
+  auto redundantRules = findRulesAppearingOnceInEmptyContext(system);
 
   bool foundAny = false;
   for (unsigned ruleID : redundantRules) {
@@ -98,34 +98,39 @@ void HomotopyGenerator::findProtocolConformanceRules(
   if (!foundAny)
     return;
 
-  MutableTerm term = Basepoint;
+  RewritePathEvaluator evaluator(Basepoint);
 
   // Now look for rewrite steps with conformance rules in empty right context,
   // that is something like X.(Y.[P] => Z) (or it's inverse, X.(Z => Y.[P])).
   for (const auto &step : Path) {
-    switch (step.Kind) {
-    case RewriteStep::ApplyRewriteRule: {
-      const auto &rule = system.getRule(step.RuleID);
-      if (auto *proto = rule.isProtocolConformanceRule()) {
-        if (step.StartOffset > 0 &&
-            step.EndOffset == 0) {
-          // Record the prefix term that is left unchanged by this rewrite step.
-          //
-          // In the above example where the rewrite step is X.(Y.[P] => Z),
-          // the prefix term is 'X'.
-          MutableTerm prefix(term.begin(), term.begin() + step.StartOffset);
-          result[proto].second.emplace_back(prefix, step.RuleID);
+    if (!evaluator.isInContext()) {
+      switch (step.Kind) {
+      case RewriteStep::ApplyRewriteRule: {
+        const auto &rule = system.getRule(step.RuleID);
+        if (auto *proto = rule.isProtocolConformanceRule()) {
+          if (step.StartOffset > 0 &&
+              step.EndOffset == 0) {
+            // Record the prefix term that is left unchanged by this rewrite step.
+            //
+            // In the above example where the rewrite step is X.(Y.[P] => Z),
+            // the prefix term is 'X'.
+            const auto &term = evaluator.getCurrentTerm();
+            MutableTerm prefix(term.begin(), term.begin() + step.StartOffset);
+            result[proto].second.emplace_back(prefix, step.RuleID);
+          }
         }
-      }
 
-      break;
-    }
+        break;
+      }
 
-    case RewriteStep::AdjustConcreteType:
-      break;
+      case RewriteStep::AdjustConcreteType:
+      case RewriteStep::Shift:
+      case RewriteStep::Decompose:
+        break;
+      }
     }
 
-    step.apply(term, system);
+    step.apply(evaluator, system);
   }
 }