RequirementMachine: Rename Term to MutableTerm

MutableTerm will be used for temporaries; I'm going to add a new
Term type for uniqued permanently-allocated terms shortly.

Author: slavapestov

include/swift/AST/RewriteSystem.h

@@ -269,29 +269,32 @@ class Atom final {
 
 /// A term is a sequence of one or more atoms.
 ///
+/// The MutableTerm type is a dynamically-allocated representation,
+/// used to represent temporary values in simplification and completion.
+///
 /// The first atom in the term must be a protocol, generic parameter, or
 /// associated type atom.
 ///
 /// A layout constraint atom must only appear at the end of a term.
 ///
 /// Out-of-line methods are documented in RewriteSystem.cpp.
-class Term final {
+class MutableTerm final {
   llvm::SmallVector<Atom, 3> Atoms;
 
 public:
-  Term() {}
+  MutableTerm() {}
 
-  explicit Term(llvm::SmallVector<Atom, 3> &&atoms)
+  explicit MutableTerm(llvm::SmallVector<Atom, 3> &&atoms)
     : Atoms(std::move(atoms)) {}
 
-  explicit Term(ArrayRef<Atom> atoms)
+  explicit MutableTerm(ArrayRef<Atom> atoms)
     : Atoms(atoms.begin(), atoms.end()) {}
 
   void add(Atom atom) {
     Atoms.push_back(atom);
   }
 
-  int compare(const Term &other, const ProtocolGraph &protos) const;
+  int compare(const MutableTerm &other, const ProtocolGraph &protos) const;
 
   size_t size() const { return Atoms.size(); }
 
@@ -317,18 +320,20 @@ class Term final {
     return Atoms[index];
   }
 
-  decltype(Atoms)::const_iterator findSubTerm(const Term &other) const;
+  decltype(Atoms)::const_iterator findSubTerm(
+      const MutableTerm &other) const;
 
-  decltype(Atoms)::iterator findSubTerm(const Term &other);
+  decltype(Atoms)::iterator findSubTerm(
+      const MutableTerm &other);
 
   /// Returns true if this term contains, or is equal to, \p other.
-  bool containsSubTerm(const Term &other) const {
+  bool containsSubTerm(const MutableTerm &other) const {
     return findSubTerm(other) != end();
   }
 
-  bool rewriteSubTerm(const Term &lhs, const Term &rhs);
+  bool rewriteSubTerm(const MutableTerm &lhs, const MutableTerm &rhs);
 
-  bool checkForOverlap(const Term &other, Term &result) const;
+  bool checkForOverlap(const MutableTerm &other, MutableTerm &result) const;
 
   void dump(llvm::raw_ostream &out) const;
 };
@@ -358,8 +363,8 @@ class RewriteContext final {
 
   RewriteContext(UnifiedStatsReporter *stats) : Stats(stats) {}
 
-  Term getTermForType(CanType paramType,
-                      const ProtocolDecl *proto);
+  MutableTerm getTermForType(CanType paramType,
+                             const ProtocolDecl *proto);
 };
 
 /// A rewrite rule that replaces occurrences of LHS with RHS.
@@ -368,22 +373,22 @@ class RewriteContext final {
 ///
 /// Out-of-line methods are documented in RewriteSystem.cpp.
 class Rule final {
-  Term LHS;
-  Term RHS;
+  MutableTerm LHS;
+  MutableTerm RHS;
   bool deleted;
 
 public:
-  Rule(const Term &lhs, const Term &rhs)
+  Rule(const MutableTerm &lhs, const MutableTerm &rhs)
       : LHS(lhs), RHS(rhs), deleted(false) {}
 
-  const Term &getLHS() const { return LHS; }
-  const Term &getRHS() const { return RHS; }
+  const MutableTerm &getLHS() const { return LHS; }
+  const MutableTerm &getRHS() const { return RHS; }
 
-  bool apply(Term &term) const {
+  bool apply(MutableTerm &term) const {
     return term.rewriteSubTerm(LHS, RHS);
   }
 
-  bool checkForOverlap(const Rule &other, Term &result) const {
+  bool checkForOverlap(const Rule &other, MutableTerm &result) const {
     return LHS.checkForOverlap(other.LHS, result);
   }
 
@@ -445,7 +450,7 @@ class RewriteSystem final {
   /// - the last atom in both lhs and rhs has the same name
   ///
   /// See RewriteSystem::processMergedAssociatedTypes() for details.
-  std::vector<std::pair<Term, Term>> MergedAssociatedTypes;
+  std::vector<std::pair<MutableTerm, MutableTerm>> MergedAssociatedTypes;
 
   /// A list of pending pairs for checking overlap in the completion
   /// procedure.
@@ -476,12 +481,12 @@ class RewriteSystem final {
   /// Return the object recording information about known protocols.
   const ProtocolGraph &getProtocols() const { return Protos; }
 
-  void initialize(std::vector<std::pair<Term, Term>> &&rules,
+  void initialize(std::vector<std::pair<MutableTerm, MutableTerm>> &&rules,
                   ProtocolGraph &&protos);
 
-  bool addRule(Term lhs, Term rhs);
+  bool addRule(MutableTerm lhs, MutableTerm rhs);
 
-  bool simplify(Term &term) const;
+  bool simplify(MutableTerm &term) const;
 
   enum class CompletionResult {
     /// Confluent completion was computed successfully.

lib/AST/RequirementMachine.cpp

@@ -35,7 +35,7 @@ struct RewriteSystemBuilder {
   bool Debug;
 
   ProtocolGraph Protocols;
-  std::vector<std::pair<Term, Term>> Rules;
+  std::vector<std::pair<MutableTerm, MutableTerm>> Rules;
 
   RewriteSystemBuilder(RewriteContext &ctx, bool debug)
     : Context(ctx), Debug(debug) {}
@@ -88,11 +88,11 @@ void RewriteSystemBuilder::addGenericSignature(CanGenericSignature sig) {
 /// named T".
 void RewriteSystemBuilder::addAssociatedType(const AssociatedTypeDecl *type,
                                              const ProtocolDecl *proto) {
-  Term lhs;
+  MutableTerm lhs;
   lhs.add(Atom::forProtocol(proto, Context));
   lhs.add(Atom::forName(type->getName(), Context));
 
-  Term rhs;
+  MutableTerm rhs;
   rhs.add(Atom::forAssociatedType(proto, type->getName(), Context));
 
   Rules.emplace_back(lhs, rhs);

lib/AST/RewriteSystem.cpp

@@ -267,7 +267,8 @@ void Atom::dump(llvm::raw_ostream &out) const {
 ///
 /// First we compare length, then perform a lexicographic comparison
 /// on atoms if the two terms have the same length.
-int Term::compare(const Term &other, const ProtocolGraph &graph) const {
+int MutableTerm::compare(const MutableTerm &other,
+                         const ProtocolGraph &graph) const {
   if (size() != other.size())
     return size() < other.size() ? -1 : 1;
 
@@ -289,17 +290,17 @@ int Term::compare(const Term &other, const ProtocolGraph &graph) const {
 
 /// Find the start of \p other in this term, returning end() if
 /// \p other does not occur as a subterm of this term.
-decltype(Term::Atoms)::const_iterator
-Term::findSubTerm(const Term &other) const {
+decltype(MutableTerm::Atoms)::const_iterator
+MutableTerm::findSubTerm(const MutableTerm &other) const {
   if (other.size() > size())
     return end();
 
   return std::search(begin(), end(), other.begin(), other.end());
 }
 
 /// Non-const variant of the above.
-decltype(Term::Atoms)::iterator
-Term::findSubTerm(const Term &other) {
+decltype(MutableTerm::Atoms)::iterator
+MutableTerm::findSubTerm(const MutableTerm &other) {
   if (other.size() > size())
     return end();
 
@@ -311,7 +312,8 @@ Term::findSubTerm(const Term &other) {
 /// order on terms. Returns true if the term contained \p lhs;
 /// otherwise returns false, in which case the term remains
 /// unchanged.
-bool Term::rewriteSubTerm(const Term &lhs, const Term &rhs) {
+bool MutableTerm::rewriteSubTerm(const MutableTerm &lhs,
+                                 const MutableTerm &rhs) {
   // Find the start of lhs in this term.
   auto found = findSubTerm(lhs);
 
@@ -362,7 +364,8 @@ bool Term::rewriteSubTerm(const Term &lhs, const Term &rhs) {
 ///
 /// Note that this relation is not commutative; we need to check
 /// for overlap between both (X and Y) and (Y and X).
-bool Term::checkForOverlap(const Term &other, Term &result) const {
+bool MutableTerm::checkForOverlap(const MutableTerm &other,
+                                  MutableTerm &result) const {
   assert(result.size() == 0);
 
   // If the other term is longer than this term, there's no way
@@ -420,7 +423,7 @@ bool Term::checkForOverlap(const Term &other, Term &result) const {
   return false;
 }
 
-void Term::dump(llvm::raw_ostream &out) const {
+void MutableTerm::dump(llvm::raw_ostream &out) const {
   bool first = true;
 
   for (auto atom : Atoms) {
@@ -445,8 +448,8 @@ void Term::dump(llvm::raw_ostream &out) const {
 /// The bound associated types in the interface type are ignored; the
 /// resulting term consists entirely of a root atom followed by zero
 /// or more name atoms.
-Term RewriteContext::getTermForType(CanType paramType,
-                                    const ProtocolDecl *proto) {
+MutableTerm RewriteContext::getTermForType(CanType paramType,
+                                           const ProtocolDecl *proto) {
   assert(paramType->isTypeParameter());
 
   // Collect zero or more nested type names in reverse order.
@@ -467,7 +470,7 @@ Term RewriteContext::getTermForType(CanType paramType,
 
   std::reverse(atoms.begin(), atoms.end());
 
-  return Term(atoms);
+  return MutableTerm(atoms);
 }
 
 void Rule::dump(llvm::raw_ostream &out) const {
@@ -478,21 +481,22 @@ void Rule::dump(llvm::raw_ostream &out) const {
     out << " [deleted]";
 }
 
-void RewriteSystem::initialize(std::vector<std::pair<Term, Term>> &&rules,
-                               ProtocolGraph &&graph) {
+void RewriteSystem::initialize(
+    std::vector<std::pair<MutableTerm, MutableTerm>> &&rules,
+    ProtocolGraph &&graph) {
   Protos = graph;
 
   // FIXME: Probably this sort is not necessary
   std::sort(rules.begin(), rules.end(),
-            [&](std::pair<Term, Term> lhs,
-                std::pair<Term, Term> rhs) -> int {
+            [&](std::pair<MutableTerm, MutableTerm> lhs,
+                std::pair<MutableTerm, MutableTerm> rhs) -> int {
               return lhs.first.compare(rhs.first, graph) < 0;
             });
   for (const auto &rule : rules)
     addRule(rule.first, rule.second);
 }
 
-bool RewriteSystem::addRule(Term lhs, Term rhs) {
+bool RewriteSystem::addRule(MutableTerm lhs, MutableTerm rhs) {
   // Simplify the rule as much as possible with the rules we have so far.
   //
   // This avoids unnecessary work in the completion algorithm.
@@ -564,7 +568,7 @@ bool RewriteSystem::addRule(Term lhs, Term rhs) {
 }
 
 /// Reduce a term by applying all rewrite rules until fixed point.
-bool RewriteSystem::simplify(Term &term) const {
+bool RewriteSystem::simplify(MutableTerm &term) const {
   bool changed = false;
 
   if (DebugSimplify) {
@@ -754,7 +758,7 @@ void RewriteSystem::processMergedAssociatedTypes() {
     }
 
     // Build the term X.[P1&P2:T].
-    Term mergedTerm = lhs;
+    MutableTerm mergedTerm = lhs;
     mergedTerm.back() = mergedAtom;
 
     // Add the rule X.[P1:T] => X.[P1&P2:T].
@@ -789,11 +793,11 @@ void RewriteSystem::processMergedAssociatedTypes() {
           //
           //   [P1&P2].[Q] => [P1&P2]
           //
-          Term newLHS;
+          MutableTerm newLHS;
           newLHS.add(mergedAtom);
           newLHS.add(otherLHS[1]);
 
-          Term newRHS;
+          MutableTerm newRHS;
           newRHS.add(mergedAtom);
 
           addRule(newLHS, newRHS);
@@ -832,7 +836,7 @@ RewriteSystem::computeConfluentCompletion(unsigned maxIterations,
     auto pair = Worklist.front();
     Worklist.pop_front();
 
-    Term first;
+    MutableTerm first;
 
     const auto &lhs = Rules[pair.first];
     const auto &rhs = Rules[pair.second];
@@ -867,7 +871,7 @@ RewriteSystem::computeConfluentCompletion(unsigned maxIterations,
     //
     // 1) lhs == TUV and rhs == U
     // 2) lhs == TU and rhs == UV
-    Term second = first;
+    MutableTerm second = first;
 
     // In both cases, rewrite the term TUV using both rules to
     // produce two new terms X and Y.