RequirementMachine: Treat LHS-simplified and RHS-simplified/substitution-simplified rules separately in minimization

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -481,20 +481,20 @@ void RewriteSystem::minimizeRewriteSystem() {
   propagateExplicitBits();
 
   // First pass:
-  // - Eliminate all simplified non-conformance rules.
+  // - Eliminate all LHS-simplified non-conformance rules.
+  // - Eliminate all RHS-simplified and substitution-simplified rules.
   // - Eliminate all rules with unresolved symbols.
   performHomotopyReduction([&](unsigned ruleID) -> bool {
     const auto &rule = getRule(ruleID);
 
-    if ((rule.isLHSSimplified() ||
-         rule.isRHSSimplified() ||
-         rule.isSubstitutionSimplified()) &&
+    if (rule.isLHSSimplified() &&
         !rule.isAnyConformanceRule())
       return true;
 
-    // Other rules involving unresolved name symbols are derived from an
-    // associated type introduction rule together with a conformance rule.
-    // They are eliminated in the first pass.
+    if (rule.isRHSSimplified() ||
+        rule.isSubstitutionSimplified())
+      return true;
+
     if (rule.getLHS().containsUnresolvedSymbols())
       return true;
 
@@ -694,22 +694,31 @@ void RewriteSystem::verifyMinimizedRules(
       continue;
     }
 
-    // Simplified rules should be redundant, unless they're protocol conformance
-    // rules, which unfortunately might no be redundant, because we try to keep
-    // them in the original protocol definition for compatibility with the
-    // GenericSignatureBuilder's minimization algorithm.
-    if ((rule.isLHSSimplified() ||
-         rule.isRHSSimplified() ||
-         rule.isSubstitutionSimplified()) &&
+    // LHS-simplified rules should be redundant, unless they're protocol
+    // conformance rules, which unfortunately might no be redundant, because
+    // we try to keep them in the original protocol definition for
+    // compatibility with the GenericSignatureBuilder's minimization algorithm.
+    if (rule.isLHSSimplified() &&
         !rule.isRedundant() &&
         !rule.isProtocolConformanceRule()) {
       llvm::errs() << "Simplified rule is not redundant: " << rule << "\n\n";
       dump(llvm::errs());
       abort();
     }
 
+    // RHS-simplified and substitution-simplified rules should be redundant.
+    if ((rule.isRHSSimplified() ||
+         rule.isSubstitutionSimplified()) &&
+        !rule.isRedundant()) {
+      llvm::errs() << "Simplified rule is not redundant: " << rule << "\n\n";
+      dump(llvm::errs());
+      abort();
+    }
+
     if (rule.isRedundant() &&
         rule.isAnyConformanceRule() &&
+        !rule.isRHSSimplified() &&
+        !rule.isSubstitutionSimplified() &&
         !rule.containsUnresolvedSymbols() &&
         !redundantConformances.count(ruleID)) {
       llvm::errs() << "Minimal conformance is redundant: " << rule << "\n\n";

lib/AST/RequirementMachine/MinimalConformances.cpp

@@ -375,6 +375,10 @@ void MinimalConformances::collectConformanceRules() {
     if (rule.isRedundant())
       continue;
 
+    if (rule.isRHSSimplified() ||
+        rule.isSubstitutionSimplified())
+      continue;
+
     if (rule.containsUnresolvedSymbols())
       continue;