RequirementMachine: Introduce Term::compare() to complement MutableTerm::compare()

Author: slavapestov

lib/AST/RequirementMachine/Term.cpp

@@ -122,20 +122,32 @@ bool Term::containsUnresolvedSymbols() const {
   return false;
 }
 
-/// Shortlex order on terms.
+namespace {
+
+/// Shortlex order on symbol ranges.
 ///
 /// First we compare length, then perform a lexicographic comparison
-/// on symbols if the two terms have the same length.
-int MutableTerm::compare(const MutableTerm &other,
-                         const ProtocolGraph &graph) const {
-  if (size() != other.size())
-    return size() < other.size() ? -1 : 1;
-
-  for (unsigned i = 0, e = size(); i < e; ++i) {
-    auto lhs = (*this)[i];
-    auto rhs = other[i];
-
-    int result = lhs.compare(rhs, graph);
+/// on symbols if the two ranges have the same length.
+///
+/// This is used to implement Term::compare() and MutableTerm::compare()
+/// below.
+template<typename Iter>
+int shortlexCompare(Iter lhsBegin, Iter lhsEnd,
+                    Iter rhsBegin, Iter rhsEnd,
+                    const ProtocolGraph &protos) {
+  unsigned lhsSize = (lhsEnd - lhsBegin);
+  unsigned rhsSize = (rhsEnd - rhsBegin);
+  if (lhsSize != rhsSize)
+    return lhsSize < rhsSize ? -1 : 1;
+
+  while (lhsBegin != lhsEnd) {
+    auto lhs = *lhsBegin;
+    auto rhs = *rhsBegin;
+
+    ++lhsBegin;
+    ++rhsBegin;
+
+    int result = lhs.compare(rhs, protos);
     if (result != 0) {
       assert(lhs != rhs);
       return result;
@@ -147,6 +159,20 @@ int MutableTerm::compare(const MutableTerm &other,
   return 0;
 }
 
+}
+
+/// Shortlex order on terms.
+int Term::compare(Term other,
+                  const ProtocolGraph &protos) const {
+  return shortlexCompare(begin(), end(), other.begin(), other.end(), protos);
+}
+
+/// Shortlex order on mutable terms.
+int MutableTerm::compare(const MutableTerm &other,
+                         const ProtocolGraph &protos) const {
+  return shortlexCompare(begin(), end(), other.begin(), other.end(), protos);
+}
+
 /// Replace the subterm in the range [from,to) with \p rhs.
 ///
 /// Note that \p rhs must precede [from,to) in the linear

lib/AST/RequirementMachine/Term.h

@@ -79,6 +79,8 @@ class Term final {
 
   void dump(llvm::raw_ostream &out) const;
 
+  int compare(Term other, const ProtocolGraph &protos) const;
+
   friend bool operator==(Term lhs, Term rhs) {
     return lhs.Ptr == rhs.Ptr;
   }