RequirementMachine: Fix MaxConcreteNesting check to take initial rules into account

Fixes rdar://123357717.

Author: slavapestov

lib/AST/RequirementMachine/KnuthBendix.cpp

@@ -325,10 +325,8 @@ RewriteSystem::computeCriticalPair(ArrayRef<Symbol>::const_iterator from,
   return true;
 }
 
-/// Computes the confluent completion using the Knuth-Bendix algorithm and
-/// returns a status code.
-///
-/// The first element of the pair is a status.
+/// Runs the Knuth-Bendix algorithm and returns a pair consisting of a
+/// status code and code-specific result.
 ///
 /// The status is CompletionResult::MaxRuleCount if we add more than
 /// \p maxRuleCount rules.
@@ -341,8 +339,8 @@ RewriteSystem::computeCriticalPair(ArrayRef<Symbol>::const_iterator from,
 /// Otherwise, the status is CompletionResult::Success and the second element
 /// is zero.
 std::pair<CompletionResult, unsigned>
-RewriteSystem::computeConfluentCompletion(unsigned maxRuleCount,
-                                          unsigned maxRuleLength) {
+RewriteSystem::performKnuthBendix(unsigned maxRuleCount,
+                                  unsigned maxRuleLength) {
   assert(Initialized);
   assert(!Minimized);
   assert(!Frozen);

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -449,7 +449,7 @@ RequirementMachine::computeCompletion(RewriteSystem::ValidityPolicy policy) {
       unsigned ruleCount = System.getRules().size();
 
       // First, run the Knuth-Bendix algorithm to resolve overlapping rules.
-      auto result = System.computeConfluentCompletion(MaxRuleCount, MaxRuleLength);
+      auto result = System.performKnuthBendix(MaxRuleCount, MaxRuleLength);
 
       unsigned rulesAdded = (System.getRules().size() - ruleCount);
 
@@ -492,7 +492,7 @@ RequirementMachine::computeCompletion(RewriteSystem::ValidityPolicy policy) {
           return std::make_pair(CompletionResult::MaxRuleLength,
                                 ruleCount + i);
         }
-        if (newRule.getNesting() > MaxConcreteNesting) {
+        if (newRule.getNesting() > MaxConcreteNesting + System.getDeepestInitialRule()) {
           return std::make_pair(CompletionResult::MaxConcreteNesting,
                                 ruleCount + i);
         }

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -33,6 +33,7 @@ RewriteSystem::RewriteSystem(RewriteContext &ctx)
   Frozen = 0;
   RecordLoops = 0;
   LongestInitialRule = 0;
+  DeepestInitialRule = 0;
 }
 
 RewriteSystem::~RewriteSystem() {
@@ -88,6 +89,7 @@ void RewriteSystem::initialize(
 
   for (const auto &rule : getLocalRules()) {
     LongestInitialRule = std::max(LongestInitialRule, rule.getDepth());
+    DeepestInitialRule = std::max(DeepestInitialRule, rule.getNesting());
   }
 }
 

lib/AST/RequirementMachine/RewriteSystem.h

@@ -72,8 +72,6 @@ class RewriteSystem final {
   /// as rules introduced by the completion procedure.
   std::vector<Rule> Rules;
 
-  unsigned FirstLocalRule = 0;
-
   /// A prefix trie of rule left hand sides to optimize lookup. The value
   /// type is an index into the Rules array defined above.
   Trie<unsigned, MatchKind::Shortest> Trie;
@@ -90,6 +88,8 @@ class RewriteSystem final {
 
   DebugOptions Debug;
 
+  unsigned FirstLocalRule = 0;
+
   /// Whether we've initialized the rewrite system with a call to initialize().
   unsigned Initialized : 1;
 
@@ -114,6 +114,10 @@ class RewriteSystem final {
   /// completion non-termination heuristic.
   unsigned LongestInitialRule : 16;
 
+  /// The most deeply nested concrete type appearing in an initial rule, used
+  /// for the MaxConcreteNesting completion non-termination heuristic.
+  unsigned DeepestInitialRule : 16;
+
 public:
   explicit RewriteSystem(RewriteContext &ctx);
   ~RewriteSystem();
@@ -142,6 +146,10 @@ class RewriteSystem final {
     return LongestInitialRule;
   }
 
+  unsigned getDeepestInitialRule() const {
+    return DeepestInitialRule;
+  }
+
   ArrayRef<const ProtocolDecl *> getProtocols() const {
     return Protos;
   }
@@ -204,8 +212,7 @@ class RewriteSystem final {
   llvm::DenseSet<std::pair<unsigned, unsigned>> CheckedOverlaps;
 
   std::pair<CompletionResult, unsigned>
-  computeConfluentCompletion(unsigned maxRuleCount,
-                             unsigned maxRuleLength);
+  performKnuthBendix(unsigned maxRuleCount, unsigned maxRuleLength);
 
   void simplifyLeftHandSides();
 

test/Constraints/same_types.swift

@@ -285,7 +285,7 @@ protocol P2 {
 // CHECK-NEXT: Generic signature: <T, U>
 
 // expected-error@+2 {{cannot build rewrite system for generic signature; concrete nesting limit exceeded}}
-// expected-note@+1 {{failed rewrite rule is τ_0_0.[P2:Assoc1].[concrete: ((((((((((((((((((((((((((((((τ_0_0.[P2:Assoc1], τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1)] => τ_0_0.[P2:Assoc1]}}
+// expected-note@+1 {{τ_0_0.[P2:Assoc1].[concrete: ((((((((((((((((((((((((((((((((τ_0_0.[P2:Assoc1], τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1)] => τ_0_0.[P2:Assoc1]}}
 func structuralSameTypeRecursive1<T: P2, U>(_: T, _: U)
   where T.Assoc1 == Tuple2<T.Assoc1, U>
   // expected-error@-1 {{'Assoc1' is not a member type of type 'T'}}

test/Generics/infinite_concrete_type.swift

@@ -3,7 +3,7 @@
 class G<T> {}
 
 protocol P1 { // expected-error {{cannot build rewrite system for protocol; concrete nesting limit exceeded}}
-// expected-note@-1 {{failed rewrite rule is [P1:A].[concrete: G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<[P1].A>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => [P1:A]}}
+// expected-note@-1 {{failed rewrite rule is [P1:A].[concrete: G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<[P1].A>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => [P1:A]}}
   associatedtype A where A == G<B>
   associatedtype B where B == G<A>
 }

test/Generics/max_concrete_nesting.swift

@@ -0,0 +1,13 @@
+// RUN: %target-typecheck-verify-swift -requirement-machine-max-concrete-nesting=4
+// RUN: not %target-typecheck-verify-swift -requirement-machine-max-concrete-nesting=3
+
+struct G<T> {}
+
+// The nesting limit is relative to the initial set of rules, so here we
+// can form a type with nesting depth 8.
+
+func f<T, U>(_: T, _: U)
+  where T: Sequence,
+        U: Sequence,
+        T.Element == G<G<G<G<U.Element>>>>,
+        U.Element == G<G<G<G<T>>>> {}

test/Generics/rdar90402519.swift

@@ -27,4 +27,4 @@ protocol P1 : P0 where C == G1<I> {
 
 protocol P2 : P1 where C == G2<I> {}
 // expected-error@-1 {{cannot build rewrite system for protocol; concrete nesting limit exceeded}}
-// expected-note@-2 {{failed rewrite rule is [P2:I].[concrete: G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<[P2:I]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => [P2:I]}}
+// expected-note@-2 {{failed rewrite rule is [P2:I].[concrete: G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<G<[P2:I]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => [P2:I]}}

test/attr/attr_specialize.swift

@@ -53,7 +53,7 @@ class G<T> {
   // expected-note@-1 {{missing constraint for 'T' in '_specialize' attribute}}
   @_specialize(where T == S<T>)
   // expected-error@-1 {{cannot build rewrite system for generic signature; concrete nesting limit exceeded}}
-  // expected-note@-2 {{failed rewrite rule is τ_0_0.[concrete: S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<τ_0_0>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => τ_0_0}}
+  // expected-note@-2 {{failed rewrite rule is τ_0_0.[concrete: S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<τ_0_0>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => τ_0_0}}
   // expected-error@-3 {{too few generic parameters are specified in '_specialize' attribute (got 0, but expected 1)}}
   // expected-note@-4 {{missing constraint for 'T' in '_specialize' attribute}}
   @_specialize(where T == Int, U == Int) // expected-error{{cannot find type 'U' in scope}}

test/decl/protocol/req/recursion.swift

@@ -9,13 +9,13 @@ protocol SomeProtocol {
 
 extension SomeProtocol where T == Optional<T> { }
 // expected-error@-1 {{cannot build rewrite system for generic signature; concrete nesting limit exceeded}}
-// expected-note@-2 {{failed rewrite rule is τ_0_0.[SomeProtocol:T].[concrete: Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<τ_0_0.[SomeProtocol:T]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => τ_0_0.[SomeProtocol:T]}}
+// expected-note@-2 {{failed rewrite rule is τ_0_0.[SomeProtocol:T].[concrete: Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<Optional<τ_0_0.[SomeProtocol:T]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => τ_0_0.[SomeProtocol:T]}}
 
 // rdar://problem/19840527
 
 class X<T> where T == X {
 // expected-error@-1 {{cannot build rewrite system for generic signature; concrete nesting limit exceeded}}
-// expected-note@-2 {{failed rewrite rule is τ_0_0.[concrete: X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<τ_0_0>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => τ_0_0}}
+// expected-note@-2 {{failed rewrite rule is τ_0_0.[concrete: X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<X<τ_0_0>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] => τ_0_0}}
 // expected-error@-3 {{generic class 'X' has self-referential generic requirements}}
     var type: T { return Swift.type(of: self) } // expected-error{{cannot convert return expression of type 'X<T>.Type' to return type 'T'}}
 }