RequirementMachine: Define operator<< overloads

Author: slavapestov

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -885,9 +885,7 @@ MutableTerm RewriteContext::getMutableTermForType(CanType paramType,
 }
 
 void Rule::dump(llvm::raw_ostream &out) const {
-  LHS.dump(out);
-  out << " => ";
-  RHS.dump(out);
+  out << LHS << " => " << RHS;
   if (deleted)
     out << " [deleted]";
 }
@@ -946,11 +944,7 @@ bool RewriteSystem::addRule(MutableTerm lhs, MutableTerm rhs) {
   assert(lhs.compare(rhs, Protos) > 0);
 
   if (DebugAdd) {
-    llvm::dbgs() << "# Adding rule ";
-    lhs.dump(llvm::dbgs());
-    llvm::dbgs() << " => ";
-    rhs.dump(llvm::dbgs());
-    llvm::dbgs() << "\n";
+    llvm::dbgs() << "# Adding rule " << lhs << " => " << rhs << "\n";
   }
 
   unsigned i = Rules.size();
@@ -1001,9 +995,7 @@ bool RewriteSystem::simplify(MutableTerm &term) const {
   bool changed = false;
 
   if (DebugSimplify) {
-    llvm::dbgs() << "= Term ";
-    term.dump(llvm::dbgs());
-    llvm::dbgs() << "\n";
+    llvm::dbgs() << "= Term " << term << "\n";
   }
 
   while (true) {
@@ -1013,16 +1005,12 @@ bool RewriteSystem::simplify(MutableTerm &term) const {
         continue;
 
       if (DebugSimplify) {
-        llvm::dbgs() << "== Rule ";
-        rule.dump(llvm::dbgs());
-        llvm::dbgs() << "\n";
+        llvm::dbgs() << "== Rule " << rule << "\n";
       }
 
       if (rule.apply(term)) {
         if (DebugSimplify) {
-          llvm::dbgs() << "=== Result ";
-          term.dump(llvm::dbgs());
-          llvm::dbgs() << "\n";
+          llvm::dbgs() << "=== Result " << term << "\n";
         }
 
         changed = true;
@@ -1051,9 +1039,7 @@ void RewriteSystem::simplifyRightHandSides() {
 
 #define ASSERT_RULE(expr) \
   if (!(expr)) { \
-    llvm::errs() << "&&& Malformed rewrite rule: "; \
-    rule.dump(llvm::errs()); \
-    llvm::errs() << "\n\n"; \
+    llvm::errs() << "&&& Malformed rewrite rule: " << rule << "\n\n"; \
     dump(llvm::errs()); \
     assert(expr); \
   }
@@ -1107,9 +1093,7 @@ void RewriteSystem::simplifyRightHandSides() {
 void RewriteSystem::dump(llvm::raw_ostream &out) const {
   out << "Rewrite system: {\n";
   for (const auto &rule : Rules) {
-    out << "- ";
-    rule.dump(out);
-    out << "\n";
+    out << "- " << rule << "\n";
   }
   out << "}\n";
 }

lib/AST/RequirementMachine/RewriteSystem.h

@@ -203,6 +203,11 @@ class Atom final {
   friend bool operator!=(Atom lhs, Atom rhs) {
     return !(lhs == rhs);
   }
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &out, Atom atom) {
+    atom.dump(out);
+    return out;
+  }
 };
 
 /// See the implementation of MutableTerm::checkForOverlap() for a discussion.
@@ -264,6 +269,11 @@ class Term final {
   friend bool operator!=(Term lhs, Term rhs) {
     return !(lhs == rhs);
   }
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &out, Term term) {
+    term.dump(out);
+    return out;
+  }
 };
 
 /// A term is a sequence of one or more atoms.
@@ -357,6 +367,12 @@ class MutableTerm final {
                               MutableTerm &v) const;
 
   void dump(llvm::raw_ostream &out) const;
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &out,
+                                       const MutableTerm &term) {
+    term.dump(out);
+    return out;
+  }
 };
 
 /// A global object that can be shared by multiple rewrite systems.
@@ -456,6 +472,12 @@ class Rule final {
   }
 
   void dump(llvm::raw_ostream &out) const;
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &out,
+                                       const Rule &rule) {
+    rule.dump(out);
+    return out;
+  }
 };
 
 /// A term rewrite system for working with types in a generic signature.

lib/AST/RequirementMachine/RewriteSystemCompletion.cpp

@@ -293,17 +293,12 @@ void RewriteSystem::processMergedAssociatedTypes() {
     // X.[P2:T] => X.[P1&P2:T]
     if (DebugMerge) {
       llvm::dbgs() << "## Associated type merge candidate ";
-      lhs.dump(llvm::dbgs());
-      llvm::dbgs() << " => ";
-      rhs.dump(llvm::dbgs());
-      llvm::dbgs() << "\n";
+      llvm::dbgs() << lhs << " => " << rhs << "\n";
     }
 
     auto mergedAtom = mergeAssociatedTypes(lhs.back(), rhs.back());
     if (DebugMerge) {
-      llvm::dbgs() << "### Merged atom ";
-      mergedAtom.dump(llvm::dbgs());
-      llvm::dbgs() << "\n";
+      llvm::dbgs() << "### Merged atom " << mergedAtom << "\n";
     }
 
     // Build the term X.[P1&P2:T].
@@ -331,9 +326,7 @@ void RewriteSystem::processMergedAssociatedTypes() {
           //
           //   [P2:T].[Q] => [P2:T]
           if (DebugMerge) {
-            llvm::dbgs() << "### Lifting conformance rule ";
-            otherRule.dump(llvm::dbgs());
-            llvm::dbgs() << "\n";
+            llvm::dbgs() << "### Lifting conformance rule " << otherRule << "\n";
           }
 
           // We know that [P1:T] or [P2:T] conforms to Q, therefore the
@@ -462,11 +455,9 @@ RewriteSystem::computeConfluentCompletion(unsigned maxIterations,
 
     if (DebugCompletion) {
       llvm::dbgs() << "$ Check for overlap: (#" << next.first << ") ";
-      lhs.dump(llvm::dbgs());
-      llvm::dbgs() << "\n";
+      llvm::dbgs() << lhs << "\n";
       llvm::dbgs() << "                -vs- (#" << next.second << ") ";
-      rhs.dump(llvm::dbgs());
-      llvm::dbgs() << ":\n";
+      llvm::dbgs() << rhs << ":\n";
     }
 
     auto pair = computeCriticalPair(lhs, rhs);
@@ -483,13 +474,8 @@ RewriteSystem::computeConfluentCompletion(unsigned maxIterations,
     std::tie(first, second) = *pair;
 
     if (DebugCompletion) {
-      llvm::dbgs() << "$$ First term of critical pair is ";
-      first.dump(llvm::dbgs());
-      llvm::dbgs() << "\n";
-
-      llvm::dbgs() << "$$ Second term of critical pair is ";
-      second.dump(llvm::dbgs());
-      llvm::dbgs() << "\n\n";
+      llvm::dbgs() << "$$ First term of critical pair is " << first << "\n";
+      llvm::dbgs() << "$$ Second term of critical pair is " << second << "\n\n";
     }
     unsigned i = Rules.size();
 
@@ -521,9 +507,9 @@ RewriteSystem::computeConfluentCompletion(unsigned maxIterations,
       // If this rule reduces some existing rule, delete the existing rule.
       if (rule.canReduceLeftHandSide(newRule)) {
         if (DebugCompletion) {
-          llvm::dbgs() << "$ Deleting rule ";
-          rule.dump(llvm::dbgs());
-          llvm::dbgs() << "\n";
+          llvm::dbgs() << "$ Deleting rule " << rule << " because "
+                       << "its left hand side contains " << newRule
+                       << "\n";
         }
         rule.markDeleted();
       }