RequirementMachine: Fixes to get stdlib to build

Author: slavapestov

include/swift/AST/RewriteSystem.h

@@ -114,6 +114,10 @@ class Atom final {
     return (lhs.Proto == rhs.Proto &&
             lhs.Value == rhs.Value);
   }
+
+  friend bool operator!=(Atom lhs, Atom rhs) {
+    return !(lhs == rhs);
+  }
 };
 
 class Term final {
@@ -196,16 +200,26 @@ class Rule final {
     return LHS.size();
   }
 
+  int compare(const Rule &other,
+              ProtocolOrder protocolOrder) const {
+    return LHS.compare(other.LHS, protocolOrder);
+  }
+
   void dump(llvm::raw_ostream &out) const;
 };
 
 class RewriteSystem final {
   std::vector<Rule> Rules;
   ProtocolOrder Order;
-  bool Debug = false;
+
+  unsigned DebugSimplify : 1;
+  unsigned DebugAdd : 1;
 
 public:
-  explicit RewriteSystem(ProtocolOrder order) : Order(order) {}
+  explicit RewriteSystem(ProtocolOrder order) : Order(order) {
+    DebugSimplify = false;
+    DebugAdd = false;
+  }
 
   RewriteSystem(const RewriteSystem &) = delete;
   RewriteSystem(RewriteSystem &&) = delete;

lib/AST/RequirementMachine.cpp

@@ -63,6 +63,7 @@ struct ProtocolInfo {
 struct ProtocolGraph {
   llvm::DenseMap<const ProtocolDecl *, ProtocolInfo> Info;
   std::vector<const ProtocolDecl *> Protocols;
+  bool Debug = false;
 
   void visitRequirements(ArrayRef<Requirement> reqs) {
     for (auto req : reqs) {
@@ -105,7 +106,7 @@ struct ProtocolGraph {
     std::sort(
         Protocols.begin(), Protocols.end(),
         [&](const ProtocolDecl *lhs,
-            const ProtocolDecl *rhs) -> int {
+            const ProtocolDecl *rhs) -> bool {
           const auto &lhsInfo = getProtocolInfo(lhs);
           const auto &rhsInfo = getProtocolInfo(rhs);
 
@@ -114,14 +115,23 @@ struct ProtocolGraph {
           //
           // Derived < Base in the linear order.
           if (lhsInfo.Depth != rhsInfo.Depth)
-            return lhsInfo.Depth - rhsInfo.Depth;
+            return lhsInfo.Depth > rhsInfo.Depth;
 
-          return TypeDecl::compare(lhs, rhs);
+          return TypeDecl::compare(lhs, rhs) < 0;
         });
 
     for (unsigned i : indices(Protocols)) {
       Info[Protocols[i]].Index = i;
     }
+
+    if (Debug) {
+      for (const auto *proto : Protocols) {
+        const auto &info = getProtocolInfo(proto);
+        llvm::dbgs() << "@ Protocol " << proto->getName()
+                     << " Depth=" << info.Depth
+                     << " Index=" << info.Index << "\n";
+      }
+    }
   }
 
   void computeInheritedAssociatedTypes() {
@@ -197,6 +207,10 @@ void RewriteSystemBuilder::addGenericSignature(CanGenericSignature sig) {
   Protocols.computeInheritedAssociatedTypes();
 
   for (auto *proto : Protocols.Protocols) {
+    if (Context.LangOpts.DebugRequirementMachine) {
+      llvm::dbgs() << "protocol " << proto->getName() << " {\n";
+    }
+
     const auto &info = Protocols.getProtocolInfo(proto);
 
     for (auto *type : info.AssociatedTypes)
@@ -317,12 +331,10 @@ struct RequirementMachine::Implementation {
   Implementation()
       : Order([&](const ProtocolDecl *lhs,
                   const ProtocolDecl *rhs) -> int {
-          auto infoLHS = Protocols.Info.find(lhs);
-          assert(infoLHS != Protocols.Info.end());
-          auto infoRHS = Protocols.Info.find(rhs);
-          assert(infoRHS != Protocols.Info.end());
+          const auto &infoLHS = Protocols.getProtocolInfo(lhs);
+          const auto &infoRHS = Protocols.getProtocolInfo(rhs);
 
-          return infoRHS->second.Index - infoLHS->second.Index;
+          return infoLHS.Index - infoRHS.Index;
         }),
         System(Order) {}
 };
@@ -351,6 +363,11 @@ void RequirementMachine::addGenericSignature(CanGenericSignature sig) {
 
   Impl->Protocols = builder.Protocols;
 
+  std::sort(builder.Rules.begin(), builder.Rules.end(),
+            [&](std::pair<Term, Term> lhs,
+                std::pair<Term, Term> rhs) -> int {
+              return lhs.first.compare(rhs.first, Impl->Order) < 0;
+            });
   for (const auto &rule : builder.Rules)
     Impl->System.addRule(rule.first, rule.second);
 
@@ -364,14 +381,14 @@ void RequirementMachine::addGenericSignature(CanGenericSignature sig) {
   case RewriteSystem::CompletionResult::MaxIterations:
     llvm::errs() << "Generic signature " << sig
                  << " exceeds maximum completion step count\n";
-    break;
-    // abort();
+    Impl->System.dump(llvm::errs());
+    abort();
 
   case RewriteSystem::CompletionResult::MaxDepth:
     llvm::errs() << "Generic signature " << sig
                  << " exceeds maximum completion depth\n";
-    break;
-    // abort();
+    Impl->System.dump(llvm::errs());
+    abort();
   }
 
   markComplete();

lib/AST/RewriteSystem.cpp

@@ -13,6 +13,7 @@
 #include "swift/AST/RewriteSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <deque>
 #include <vector>
 
 using namespace swift;
@@ -42,7 +43,7 @@ int Atom::compare(Atom other, ProtocolOrder protocolOrder) const {
 
   case Kind::GenericParam: {
     auto *param = getGenericParam();
-    auto *otherParam = getGenericParam();
+    auto *otherParam = other.getGenericParam();
 
     if (param->getDepth() != otherParam->getDepth())
       return param->getDepth() < otherParam->getDepth() ? -1 : 1;
@@ -90,8 +91,12 @@ int Term::compare(const Term &other, ProtocolOrder protocolOrder) const {
     auto rhs = other[i];
 
     int result = lhs.compare(rhs, protocolOrder);
-    if (result != 0)
+    if (result != 0) {
+      assert(lhs != rhs);
       return result;
+    }
+
+    assert(lhs == rhs);
   }
 
   return 0;
@@ -201,6 +206,15 @@ bool RewriteSystem::addRule(Term lhs, Term rhs) {
   if (result < 0)
     std::swap(lhs, rhs);
 
+  assert(lhs.compare(rhs, Order) > 0);
+
+  if (DebugAdd) {
+    llvm::dbgs() << "# Adding rule ";
+    lhs.dump(llvm::dbgs());
+    llvm::dbgs() << " => ";
+    rhs.dump(llvm::dbgs());
+    llvm::dbgs() << "\n";
+  }
   Rules.emplace_back(lhs, rhs);
 
   return true;
@@ -209,7 +223,7 @@ bool RewriteSystem::addRule(Term lhs, Term rhs) {
 bool RewriteSystem::simplify(Term &term) const {
   bool changed = false;
 
-  if (Debug) {
+  if (DebugSimplify) {
     llvm::dbgs() << "= Term ";
     term.dump(llvm::dbgs());
     llvm::dbgs() << "\n";
@@ -221,14 +235,14 @@ bool RewriteSystem::simplify(Term &term) const {
       if (rule.isDeleted())
         continue;
 
-      if (Debug) {
+      if (DebugSimplify) {
         llvm::dbgs() << "== Rule ";
         rule.dump(llvm::dbgs());
         llvm::dbgs() << "\n";
       }
 
       if (rule.apply(term)) {
-        if (Debug) {
+        if (DebugSimplify) {
           llvm::dbgs() << "=== Result ";
           term.dump(llvm::dbgs());
           llvm::dbgs() << "\n";
@@ -250,7 +264,7 @@ RewriteSystem::CompletionResult
 RewriteSystem::computeConfluentCompletion(
     unsigned maxIterations,
     unsigned maxDepth) {
-  SmallVector<std::pair<unsigned, unsigned>, 16> worklist;
+  std::deque<std::pair<unsigned, unsigned>> worklist;
 
   for (unsigned i : indices(Rules)) {
     for (unsigned j : indices(Rules)) {
@@ -262,8 +276,8 @@ RewriteSystem::computeConfluentCompletion(
   }
 
   while (!worklist.empty()) {
-    auto pair = worklist.back();
-    worklist.pop_back();
+    auto pair = worklist.front();
+    worklist.pop_front();
 
     Term first;