RequirementMachine: Remove old implementation of simplifySubstitutions()

Author: slavapestov

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -374,8 +374,15 @@ MutableTerm PropertyMap::computeConstraintTermForTypeWitness(
 
   // Simplify the substitution terms in the type witness symbol.
   RewritePath substPath;
-  System.simplifySubstitutions(typeWitnessSymbol, &substPath);
-  substPath.invert();
+  auto differenceID = System.simplifySubstitutions(
+      key, typeWitnessSymbol, /*map=*/this,
+      &substPath);
+  if (differenceID) {
+    const auto &difference = System.getTypeDifference(*differenceID);
+    assert(difference.LHS == typeWitnessSymbol);
+    typeWitnessSymbol = difference.RHS;
+    substPath.invert();
+  }
 
   // If it is equal to the parent type, introduce a same-type requirement
   // between the two parameters.

lib/AST/RequirementMachine/RewriteSystem.h

@@ -316,8 +316,6 @@ class RewriteSystem final {
 
   bool simplify(MutableTerm &term, RewritePath *path=nullptr) const;
 
-  bool simplifySubstitutions(Symbol &symbol, RewritePath *path=nullptr) const;
-
   Optional<unsigned>
   simplifySubstitutions(Term baseTerm, Symbol symbol, const PropertyMap *map,
                         RewritePath *path);

lib/AST/RequirementMachine/SimplifySubstitutions.cpp

@@ -16,81 +16,6 @@
 using namespace swift;
 using namespace rewriting;
 
-/// Simplify terms appearing in the substitutions of the last symbol of \p term,
-/// which must be a superclass or concrete type symbol.
-bool RewriteSystem::simplifySubstitutions(Symbol &symbol,
-                                          RewritePath *path) const {
-  assert(symbol.hasSubstitutions());
-
-  // Fast path if the type is fully concrete.
-  auto substitutions = symbol.getSubstitutions();
-  if (substitutions.empty())
-    return false;
-
-  // Save the original rewrite path length so that we can reset if if we don't
-  // find anything to simplify.
-  unsigned oldSize = (path ? path->size() : 0);
-
-  if (path) {
-    // The term is at the top of the primary stack. Push all substitutions onto
-    // the primary stack.
-    path->add(RewriteStep::forDecompose(substitutions.size(),
-                                        /*inverse=*/false));
-
-    // Move all substitutions but the first one to the secondary stack.
-    for (unsigned i = 1; i < substitutions.size(); ++i)
-      path->add(RewriteStep::forShift(/*inverse=*/false));
-  }
-
-  // Simplify and collect substitutions.
-  SmallVector<Term, 2> newSubstitutions;
-  newSubstitutions.reserve(substitutions.size());
-
-  bool first = true;
-  bool anyChanged = false;
-  for (auto substitution : substitutions) {
-    // Move the next substitution from the secondary stack to the primary stack.
-    if (!first && path)
-      path->add(RewriteStep::forShift(/*inverse=*/true));
-    first = false;
-
-    // The current substitution is at the top of the primary stack; simplify it.
-    MutableTerm mutTerm(substitution);
-    anyChanged |= simplify(mutTerm, path);
-
-    // Record the new substitution.
-    newSubstitutions.push_back(Term::get(mutTerm, Context));
-  }
-
-  // All simplified substitutions are now on the primary stack. Collect them to
-  // produce the new term.
-  if (path) {
-    path->add(RewriteStep::forDecompose(substitutions.size(),
-                                        /*inverse=*/true));
-  }
-
-  // If nothing changed, we don't have to rebuild the symbol.
-  if (!anyChanged) {
-    if (path) {
-      // The rewrite path should consist of a Decompose, followed by a number
-      // of Shifts, followed by a Compose.
-  #ifndef NDEBUG
-      for (auto iter = path->begin() + oldSize; iter < path->end(); ++iter) {
-        assert(iter->Kind == RewriteStep::Shift ||
-               iter->Kind == RewriteStep::Decompose);
-      }
-  #endif
-
-      path->resize(oldSize);
-    }
-    return false;
-  }
-
-  // Build the new symbol with simplified substitutions.
-  symbol = symbol.withConcreteSubstitutions(newSubstitutions, Context);
-  return true;
-}
-
 /// Simplify terms appearing in the substitutions of the last symbol of \p term,
 /// which must be a superclass or concrete type symbol.
 ///