Merge pull request #42165 from slavapestov/rqm-propagate-requirement-id-debug

RequirementMachine: More debug output from 'propagateRedundantRequirementIDs()' and some other small tweaks

Author: slavapestov

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -599,6 +599,17 @@ bool ConcreteContraction::performConcreteContraction(
     // requirement where the left hand side is not a type parameter.
     SmallVector<Requirement, 4> reqs;
     if (req.inferred) {
+      // Discard errors from desugaring a substituted requirement that
+      // was inferred. For example, if we have something like
+      //
+      //   <T, U where T == Int, U == Set<T>>
+      //
+      // The inferred requirement 'T : Hashable' from 'Set<>' will
+      // be substituted with 'T == Int' to get 'Int : Hashable'.
+      //
+      // Desugaring will diagnose a redundant conformance requirement,
+      // but we want to ignore that, since the user did not explicitly
+      // write 'Int : Hashable' (or 'T : Hashable') anywhere.
       SmallVector<RequirementError, 4> discardErrors;
       desugarRequirement(substReq, SourceLoc(), reqs, discardErrors);
     } else {

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -126,39 +126,51 @@ void RewriteSystem::propagateRedundantRequirementIDs() {
     llvm::dbgs() << "\nPropagating requirement IDs: {";
   }
 
-  for (auto ruleAndReplacement : RedundantRules) {
-    auto ruleID = ruleAndReplacement.first;
-    auto rewritePath = ruleAndReplacement.second;
-    auto &rule = Rules[ruleID];
+  for (const auto &ruleAndReplacement : RedundantRules) {
+    unsigned ruleID = ruleAndReplacement.first;
+    const auto &rewritePath = ruleAndReplacement.second;
+    const auto &rule = Rules[ruleID];
 
     auto requirementID = rule.getRequirementID();
-    if (!requirementID.hasValue())
+    if (!requirementID.hasValue()) {
+      if (Debug.contains(DebugFlags::PropagateRequirementIDs)) {
+        llvm::dbgs() << "\n- rule does not have a requirement ID: "
+                     << rule;
+      }
       continue;
+    }
 
     MutableTerm lhs(rule.getLHS());
-    for (auto ruleID : rewritePath.getRulesInEmptyContext(lhs, *this)) {
+    for (auto ruleID : rewritePath.findRulesAppearingOnceInEmptyContext(lhs, *this)) {
       auto &replacement = Rules[ruleID];
-      if (!replacement.isPermanent()) {
-        // If the replacement rule already has a requirementID, overwrite
-        // it if the existing ID corresponds to an inferred requirement.
-        // This effectively makes the inferred requirement the redundant
-        // one, which makes it easier to suppress redundancy warnings for
-        // inferred requirements later on.
-        auto existingID = replacement.getRequirementID();
-        if (existingID.hasValue() && !WrittenRequirements[*existingID].inferred)
-          continue;
+      if (replacement.isPermanent()) {
+        if (Debug.contains(DebugFlags::PropagateRequirementIDs)) {
+          llvm::dbgs() << "\n- skipping permanent rule: " << rule;
+        }
+        continue;
+      }
 
+      // If the replacement rule already has a requirementID, overwrite
+      // it if the existing ID corresponds to an inferred requirement.
+      // This effectively makes the inferred requirement the redundant
+      // one, which makes it easier to suppress redundancy warnings for
+      // inferred requirements later on.
+      auto existingID = replacement.getRequirementID();
+      if (existingID.hasValue() && !WrittenRequirements[*existingID].inferred) {
         if (Debug.contains(DebugFlags::PropagateRequirementIDs)) {
-          llvm::dbgs() << "\n- propagating ID = "
-            << requirementID
-            << "\n  from ";
-          rule.dump(llvm::dbgs());
-          llvm::dbgs() << "\n  to ";
-          replacement.dump(llvm::dbgs());
+          llvm::dbgs() << "\n- rule already has a requirement ID: "
+                       << rule;
         }
+        continue;
+      }
 
-        replacement.setRequirementID(requirementID);
+      if (Debug.contains(DebugFlags::PropagateRequirementIDs)) {
+        llvm::dbgs() << "\n- propagating ID = " << requirementID
+                     << "\n  from " << rule;
+        llvm::dbgs() << "\n  to " << replacement;
       }
+
+      replacement.setRequirementID(requirementID);
     }
   }
 

lib/AST/RequirementMachine/RewriteLoop.cpp

@@ -345,8 +345,8 @@ bool RewritePath::replaceRuleWithPath(unsigned ruleID,
 }
 
 SmallVector<unsigned, 1>
-RewritePath::getRulesInEmptyContext(const MutableTerm &term,
-                                    const RewriteSystem &system) {
+RewritePath::findRulesAppearingOnceInEmptyContext(const MutableTerm &term,
+                                                  const RewriteSystem &system) const {
   // Rules appearing in empty context (possibly more than once).
   llvm::SmallDenseSet<unsigned, 2> rulesInEmptyContext;
   // The number of times each rule appears (with or without context).
@@ -485,7 +485,8 @@ void RewriteLoop::recompute(const RewriteSystem &system) {
     evaluator.apply(step, system);
   }
 
-  RulesInEmptyContext = Path.getRulesInEmptyContext(Basepoint, system);
+  RulesInEmptyContext =
+      Path.findRulesAppearingOnceInEmptyContext(Basepoint, system);
 }
 
 /// A rewrite rule is redundant if it appears exactly once in a loop

lib/AST/RequirementMachine/RewriteLoop.h

@@ -411,8 +411,9 @@ class RewritePath {
 
   bool replaceRuleWithPath(unsigned ruleID, const RewritePath &path);
 
-  SmallVector<unsigned, 1> getRulesInEmptyContext(const MutableTerm &term,
-                                                  const RewriteSystem &system);
+  SmallVector<unsigned, 1>
+  findRulesAppearingOnceInEmptyContext(const MutableTerm &term,
+                                       const RewriteSystem &system) const;
 
   void invert();
 

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -910,5 +910,17 @@ void RewriteSystem::dump(llvm::raw_ostream &out) const {
       out << "\n";
     }
   }
+  if (!WrittenRequirements.empty()) {
+    out << "Written requirements: {\n";
+
+    for (unsigned reqID : indices(WrittenRequirements)) {
+      out << " - ID: " << reqID << " - ";
+      const auto &requirement = WrittenRequirements[reqID];
+      requirement.req.dump(out);
+      out << " at ";
+      requirement.loc.print(out, Context.getASTContext().SourceMgr);
+      out << "\n";
+    }
+  }
   out << "}\n";
 }