[RequirementMachine] Store a requirement ID for explicit rules in the

rewrite system.

This ID can be used to index into the WrittenRequirements array in the
rewrite system to retrieve the structural requirement, e.g. for the
purpose of diagnostics.

Author: hborla

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -195,17 +195,21 @@ void RewriteSystem::propagateExplicitBits() {
       loop.findRulesAppearingOnceInEmptyContext(*this);
 
     bool sawExplicitRule = false;
+    Optional<unsigned> requirementID = None;
 
     for (unsigned ruleID : rulesInEmptyContext) {
       const auto &rule = getRule(ruleID);
-      if (rule.isExplicit())
+      if (rule.isExplicit()) {
         sawExplicitRule = true;
+        requirementID = rule.getRequirementID();
+        break;
+      }
     }
     if (sawExplicitRule) {
       for (unsigned ruleID : rulesInEmptyContext) {
         auto &rule = getRule(ruleID);
         if (!rule.isPermanent() && !rule.isExplicit())
-          rule.markExplicit();
+          rule.markExplicit(requirementID);
       }
     }
   }

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -498,7 +498,7 @@ bool RewriteSystem::addExplicitRule(MutableTerm lhs, MutableTerm rhs,
                                     Optional<unsigned> requirementID) {
   bool added = addRule(std::move(lhs), std::move(rhs));
   if (added) {
-    Rules.back().markExplicit();
+    Rules.back().markExplicit(requirementID);
   } else if (requirementID.hasValue()) {
     auto req = WrittenRequirements[requirementID.getValue()];
     Errors.push_back(
@@ -723,7 +723,15 @@ void RewriteSystem::verifyRewriteRules(ValidityPolicy policy) const {
 void RewriteSystem::dump(llvm::raw_ostream &out) const {
   out << "Rewrite system: {\n";
   for (const auto &rule : Rules) {
-    out << "- " << rule << "\n";
+    out << "- " << rule;
+    if (auto ID = rule.getRequirementID()) {
+      auto requirement = WrittenRequirements[*ID];
+      out << ", ";
+      requirement.req.dump(out);
+      out << " at ";
+      requirement.loc.print(out, Context.getASTContext().SourceMgr);
+    }
+    out << "\n";
   }
   out << "}\n";
   if (!Relations.empty()) {

lib/AST/RequirementMachine/RewriteSystem.h

@@ -46,6 +46,11 @@ class Rule final {
   Term LHS;
   Term RHS;
 
+  /// The written requirement ID, which can be used to index into the
+  /// \c WrittenRequirements array in the rewrite system to retrieve
+  /// the structural requirement.
+  Optional<unsigned> requirementID;
+
   /// A 'permanent' rule cannot be deleted by homotopy reduction. These
   /// do not correspond to generic requirements and are re-added when the
   /// rewrite system is built.
@@ -98,6 +103,10 @@ class Rule final {
   const Term &getLHS() const { return LHS; }
   const Term &getRHS() const { return RHS; }
 
+  Optional<unsigned> getRequirementID() const {
+    return requirementID;
+  }
+
   Optional<Symbol> isPropertyRule() const;
 
   const ProtocolDecl *isProtocolConformanceRule() const;
@@ -167,9 +176,10 @@ class Rule final {
     Permanent = true;
   }
 
-  void markExplicit() {
+  void markExplicit(Optional<unsigned> requirementID) {
     assert(!Explicit && !Permanent &&
            "Permanent and explicit are mutually exclusive");
+    this->requirementID = requirementID;
     Explicit = true;
   }