RequirementMachine: Compute recursive rules

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -180,6 +180,41 @@ void RewriteSystem::propagateRedundantRequirementIDs() {
   }
 }
 
+/// Find concrete type or superclass rules where the right hand side occurs as a
+/// proper prefix of one of its substitutions.
+///
+/// eg, (T.[concrete: G<T.[P:A]>] => T).
+void RewriteSystem::computeRecursiveRules() {
+  for (unsigned ruleID = FirstLocalRule, e = Rules.size();
+       ruleID < e; ++ruleID) {
+    auto &rule = getRule(ruleID);
+
+    if (rule.isPermanent() ||
+        rule.isRedundant())
+      continue;
+
+    auto optSymbol = rule.isPropertyRule();
+    if (!optSymbol)
+      continue;
+
+    auto kind = optSymbol->getKind();
+    if (kind != Symbol::Kind::ConcreteType &&
+        kind != Symbol::Kind::Superclass) {
+      continue;
+    }
+
+    auto rhs = rule.getRHS();
+    for (auto term : optSymbol->getSubstitutions()) {
+      if (term.size() > rhs.size() &&
+          std::equal(rhs.begin(), rhs.end(), term.begin())) {
+        RecursiveRules.push_back(ruleID);
+        rule.markRecursive();
+        break;
+      }
+    }
+  }
+}
+
 /// Find a rule to delete by looking through all loops for rewrite rules appearing
 /// once in empty context. Returns a pair consisting of a loop ID and a rule ID,
 /// otherwise returns None.
@@ -580,6 +615,7 @@ void RewriteSystem::minimizeRewriteSystem(const PropertyMap &map) {
   });
 
   propagateRedundantRequirementIDs();
+  computeRecursiveRules();
 
   // Check invariants after homotopy reduction.
   verifyRewriteLoops();
@@ -629,7 +665,7 @@ GenericSignatureErrors RewriteSystem::getErrors() const {
         rule.containsUnresolvedSymbols())
       result |= GenericSignatureErrorFlags::HasInvalidRequirements;
 
-    if (rule.isConflicting())
+    if (rule.isConflicting() || rule.isRecursive())
       result |= GenericSignatureErrorFlags::HasInvalidRequirements;
 
     if (!rule.isRedundant())

lib/AST/RequirementMachine/RewriteSystem.h

@@ -357,10 +357,18 @@ class RewriteSystem final {
   /// minimization.
   std::vector<std::pair<unsigned, unsigned>> ConflictingRules;
 
+  /// A 'recursive' rule is a concrete type or superclass rule where the right
+  /// hand side occurs as a prefix of one of its substitutions.
+  ///
+  /// Populated by computeRecursiveRules().
+  std::vector<unsigned> RecursiveRules;
+
   void propagateExplicitBits();
 
   void propagateRedundantRequirementIDs();
 
+  void computeRecursiveRules();
+
   using EliminationPredicate = llvm::function_ref<bool(unsigned loopID,
                                                        unsigned ruleID)>;
 

lib/AST/RequirementMachine/Rule.cpp

@@ -286,4 +286,6 @@ void Rule::dump(llvm::raw_ostream &out) const {
     out << " [redundant]";
   if (Conflicting)
     out << " [conflicting]";
+  if (Recursive)
+    out << " [recursive]";
 }

lib/AST/RequirementMachine/Rule.h

@@ -80,6 +80,13 @@ class Rule final {
   /// dropped from the minimal set of requirements.
   unsigned Conflicting : 1;
 
+  /// A 'recursive' rule is a concrete type or superclass rule where the right
+  /// hand side occurs as a proper prefix of one of its substitutions.
+  ///
+  /// Recursive rules are detected in RewriteSystem::computeRecursiveRules(),
+  /// and are dropped from the minimal set of requirements.
+  unsigned Recursive : 1;
+
   /// Whether this rule is now finalized and immutable.
   unsigned Frozen : 1;
 
@@ -94,6 +101,7 @@ class Rule final {
     SubstitutionSimplified = false;
     Redundant = false;
     Conflicting = false;
+    Recursive = false;
     Frozen = false;
   }
 
@@ -156,6 +164,10 @@ class Rule final {
     return Conflicting;
   }
 
+  bool isRecursive() const {
+    return Recursive;
+  }
+
   bool isFrozen() const {
     return Frozen;
   }
@@ -217,6 +229,13 @@ class Rule final {
     Conflicting = true;
   }
 
+  void markRecursive() {
+    assert(!Frozen);
+    assert(!Permanent && "Permanent rule should not be recursive");
+    assert(!Recursive);
+    Recursive = true;
+  }
+
   void freeze() {
     Redundant = false;
     RequirementID = 0;