RequirementMachine: Simplify RewriteStep::Decompose

The inverted form no longer has to replace substitutions; we use
the inverted form of DecomposeConcrete for that. So just assert
that the substitutions are equal.

Author: slavapestov

lib/AST/RequirementMachine/RewriteLoop.cpp

@@ -367,7 +367,6 @@ void RewritePathEvaluator::applyDecompose(const RewriteStep &step,
                                           const RewriteSystem &system) {
   assert(step.Kind == RewriteStep::Decompose);
 
-  auto &ctx = system.getRewriteContext();
   unsigned numSubstitutions = step.Arg;
 
   if (!step.Inverse) {
@@ -405,15 +404,8 @@ void RewritePathEvaluator::applyDecompose(const RewriteStep &step,
 
     // The term immediately underneath the substitutions is the one we're
     // updating with new substitutions.
-    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 primary stack\n";
-      dump(llvm::errs());
-      abort();
-    }
+    const auto &term = *(Primary.end() - numSubstitutions - 1);
+    auto symbol = *(term.end() - step.EndOffset - 1);
 
     // The symbol at the end of this term must have the expected number of
     // substitutions.
@@ -423,17 +415,16 @@ void RewritePathEvaluator::applyDecompose(const RewriteStep &step,
       abort();
     }
 
-    // Collect the substitutions from the primary stack.
-    SmallVector<Term, 2> substitutions;
-    substitutions.reserve(numSubstitutions);
     for (unsigned i = 0; i < numSubstitutions; ++i) {
       const auto &substitution = *(Primary.end() - numSubstitutions + i);
-      substitutions.push_back(Term::get(substitution, ctx));
+      if (MutableTerm(symbol.getSubstitutions()[i]) != substitution) {
+        llvm::errs() << "Expected " << symbol.getSubstitutions()[i] << "\n";
+        llvm::errs() << "Got " << substitution << "\n";
+        dump(llvm::errs());
+        abort();
+      }
     }
 
-    // Build the new symbol with the new substitutions.
-    symbol = symbol.withConcreteSubstitutions(substitutions, ctx);
-
     // Pop the substitutions from the primary stack.
     Primary.resize(Primary.size() - numSubstitutions);
   }

lib/AST/RequirementMachine/RewriteLoop.h

@@ -82,20 +82,15 @@ struct RewriteStep {
     ///
     ///    T.[concrete: C<...> with <X1, X2...>] X1 X2...
     ///
-    /// If inverted: pop concrete substitutions Xn' from the primary stack,
+    /// If inverted: pop concrete substitutions Xn from the primary stack,
     /// which must follow a term ending with a superclass or concrete type
     /// symbol:
     ///
-    ///    T.[concrete: C<...> with <X1, X2...>] X1' X2'...
-    ///
-    /// The new substitutions replace the substitutions in that symbol:
-    ///
-    ///    T.[concrete: C<...> with <X1', X2'...>]
+    ///    T.[concrete: C<...> with <X1, X2...>] X1 X2...
     ///
     /// The Arg field encodes the number of substitutions.
     ///
-    /// Used by RewriteSystem::simplifyLeftHandSideSubstitutions() and
-    /// PropertyMap::concretelySimplifyLeftHandSideSubstitutions().
+    /// Used by RewriteSystem::simplifyLeftHandSideSubstitutions().
     Decompose,
 
     ///
@@ -155,8 +150,7 @@ struct RewriteStep {
     ///
     ///    T.[concrete: C'<...> with <X1', X2'...>]
     ///
-    /// Used by PropertyMap::concretelySimplifyLeftHandSideSubstitutions() and
-    /// PropertyMap::processTypeDifference().
+    /// Used by RewriteSystem::simplifyLeftHandSideSubstitutions().
     DecomposeConcrete,
 
     /// For decomposing the left hand side of an induced rule in concrete type