RequirementMachine: Diagnose recursive requirements

Note the test cases in abstract_type_witnesses used to pass but are now
rejected. This is fine, because doing anything more complicated used to
crash, and the GSB would crash or misbehave with these examples.

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -2508,6 +2508,10 @@ ERROR(recursive_generic_signature,none,
       "%0 %1 has self-referential generic requirements", (DescriptiveDeclKind, DeclBaseName))
 ERROR(recursive_generic_signature_extension,none,
       "extension of %0 %1 has self-referential generic requirements", (DescriptiveDeclKind, DeclBaseName))
+ERROR(recursive_same_type_constraint,none,
+      "same-type constraint %0 == %1 is recursive", (Type, Type))
+ERROR(recursive_superclass_constraint,none,
+      "superclass constraint %0 : %1 is recursive", (Type, Type))
 ERROR(requires_same_concrete_type,none,
       "generic signature requires types %0 and %1 to be the same", (Type, Type))
 WARNING(redundant_conformance_constraint,none,

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -137,6 +137,26 @@ bool swift::rewriting::diagnoseRequirementErrors(
       break;
     }
 
+    case RequirementError::Kind::RecursiveRequirement: {
+      auto requirement = error.requirement;
+
+      if (requirement.hasError())
+        break;
+
+      assert(requirement.getKind() == RequirementKind::SameType ||
+             requirement.getKind() == RequirementKind::Superclass);
+
+      ctx.Diags.diagnose(loc,
+                         (requirement.getKind() == RequirementKind::SameType ?
+                          diag::recursive_same_type_constraint :
+                          diag::recursive_superclass_constraint),
+                         requirement.getFirstType(),
+                         requirement.getSecondType());
+
+      diagnosedError = true;
+      break;
+    }
+
     case RequirementError::Kind::RedundantRequirement: {
       // We only emit redundant requirement warnings if the user passed
       // the -warn-redundant-requirements frontend flag.
@@ -390,7 +410,7 @@ getRequirementForDiagnostics(Type subject, Symbol property,
   }
 }
 
-void RewriteSystem::computeConflictDiagnostics(
+void RewriteSystem::computeConflictingRequirementDiagnostics(
     SmallVectorImpl<RequirementError> &errors, SourceLoc signatureLoc,
     const PropertyMap &propertyMap,
     TypeArrayView<GenericTypeParamType> genericParams) {
@@ -427,11 +447,30 @@ void RewriteSystem::computeConflictDiagnostics(
   }
 }
 
+void RewriteSystem::computeRecursiveRequirementDiagnostics(
+    SmallVectorImpl<RequirementError> &errors, SourceLoc signatureLoc,
+    const PropertyMap &propertyMap,
+    TypeArrayView<GenericTypeParamType> genericParams) {
+  for (unsigned ruleID : RecursiveRules) {
+    const auto &rule = getRule(ruleID);
+
+    assert(isInMinimizationDomain(rule.getRHS()[0].getRootProtocol()));
+
+    Type subjectType = propertyMap.getTypeForTerm(rule.getRHS(), genericParams);
+    errors.push_back(RequirementError::forRecursiveRequirement(
+        getRequirementForDiagnostics(subjectType, *rule.isPropertyRule(),
+                                     propertyMap, genericParams, MutableTerm()),
+        signatureLoc));
+  }
+}
+
 void RequirementMachine::computeRequirementDiagnostics(
     SmallVectorImpl<RequirementError> &errors, SourceLoc signatureLoc) {
   System.computeRedundantRequirementDiagnostics(errors);
-  System.computeConflictDiagnostics(errors, signatureLoc, Map,
-                                    getGenericParams());
+  System.computeConflictingRequirementDiagnostics(errors, signatureLoc, Map,
+                                                  getGenericParams());
+  System.computeRecursiveRequirementDiagnostics(errors, signatureLoc, Map,
+                                                getGenericParams());
 }
 
 std::string RequirementMachine::getRuleAsStringForDiagnostics(

lib/AST/RequirementMachine/Diagnostics.h

@@ -36,6 +36,8 @@ struct RequirementError {
     InvalidRequirementSubject,
     /// A pair of conflicting requirements, T == Int, T == String
     ConflictingRequirement,
+    /// A recursive requirement, e.g. T == G<T.A>.
+    RecursiveRequirement,
     /// A redundant requirement, e.g. T == T.
     RedundantRequirement,
   } kind;
@@ -86,6 +88,11 @@ struct RequirementError {
                                                   SourceLoc loc) {
     return {Kind::RedundantRequirement, req, loc};
   }
+
+  static RequirementError forRecursiveRequirement(Requirement req,
+                                                  SourceLoc loc) {
+    return {Kind::RecursiveRequirement, req, loc};
+  }
 };
 
 /// Policy for the fixit that transforms 'T : S' where 'S' is not a protocol

lib/AST/RequirementMachine/RewriteSystem.h

@@ -229,10 +229,15 @@ class RewriteSystem final {
 
   void computeRedundantRequirementDiagnostics(SmallVectorImpl<RequirementError> &errors);
 
-  void computeConflictDiagnostics(SmallVectorImpl<RequirementError> &errors,
-                                  SourceLoc signatureLoc,
-                                  const PropertyMap &map,
-                                  TypeArrayView<GenericTypeParamType> genericParams);
+  void computeConflictingRequirementDiagnostics(SmallVectorImpl<RequirementError> &errors,
+                                                SourceLoc signatureLoc,
+                                                const PropertyMap &map,
+                                                TypeArrayView<GenericTypeParamType> genericParams);
+
+  void computeRecursiveRequirementDiagnostics(SmallVectorImpl<RequirementError> &errors,
+                                              SourceLoc signatureLoc,
+                                              const PropertyMap &map,
+                                              TypeArrayView<GenericTypeParamType> genericParams);
 
 private:
   struct CriticalPair {

test/Constraints/same_types.swift

@@ -367,7 +367,7 @@ func testSameTypeCommutativity5<U, T: P1>(_ t: T, _ u: U)
   where PPP & P3 == T.Assoc { } // Ok, equivalent to T.Assoc == PPP & P3
 
 // CHECK-LABEL: same_types.(file).testSameTypeCommutativity6@
-// CHECK-NEXT: Generic signature: <U, T where T : P1>
+// CHECK-NEXT: Generic signature: <U, T where T : P1, T.[P1]Assoc == <<error type>>>
 func testSameTypeCommutativity6<U, T: P1>(_ t: T, _ u: U)
   where U & P3 == T.Assoc { } // Equivalent to T.Assoc == U & P3
 // expected-error@-1 {{non-protocol, non-class type 'U' cannot be used within a protocol-constrained type}}

test/Generics/abstract_type_witnesses_in_protocols.swift

@@ -1,5 +1,5 @@
-// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures 2>&1 | %FileCheck %s
-// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -disable-requirement-machine-concrete-contraction 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck -verify %s -debug-generic-signatures 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck -verify %s -debug-generic-signatures -disable-requirement-machine-concrete-contraction 2>&1 | %FileCheck %s
 
 protocol P {
   associatedtype T
@@ -15,49 +15,60 @@ protocol Q {
 protocol R {}
 
 // CHECK-LABEL: abstract_type_witnesses_in_protocols.(file).Q1@
-// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<Self.[Q]A.[P]T>, Self.[Q1]B : P, Self.[Q]A.[P]T == Self.[Q1]B.[P]T>
+// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<<<error type>>>, Self.[Q1]B : P, Self.[Q]A.[P]T == Self.[Q1]B.[P]T>
 
 // GSB: Non-canonical requirement
+// expected-error@+1 {{same-type constraint 'Self.A' == 'G<Self.A.T>' is recursive}}
 protocol Q1 : Q {
   associatedtype B : P where A == G<B.T>
 }
 
+// This used to crash
+func useQ1<T : Q1>(_: T) -> T.A.T.Type {
+  return T.A.T.Type
+}
+
 // CHECK-LABEL: abstract_type_witnesses_in_protocols.(file).Q1a@
-// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<Self.[Q]A.[P]T>, Self.[Q1a]B : P, Self.[Q]A.[P]T : R, Self.[Q]A.[P]T == Self.[Q1a]B.[P]T>
+// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<<<error type>>>, Self.[Q1a]B : P, Self.[Q]A.[P]T : R, Self.[Q]A.[P]T == Self.[Q1a]B.[P]T>
 
 // GSB: Missing requirement
+// expected-error@+1 {{same-type constraint 'Self.A' == 'G<Self.A.T>' is recursive}}
 protocol Q1a : Q {
   associatedtype B : P where A.T : R, A == G<B.T>
 }
 
 // CHECK-LABEL: abstract_type_witnesses_in_protocols.(file).Q1b@
-// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<Self.[Q]A.[P]T>, Self.[Q1b]B : P, Self.[Q]A.[P]T : R, Self.[Q]A.[P]T == Self.[Q1b]B.[P]T>
+// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<<<error type>>>, Self.[Q1b]B : P, Self.[Q]A.[P]T : R, Self.[Q]A.[P]T == Self.[Q1b]B.[P]T>
 
 // GSB: Non-canonical requirement
+// expected-error@+1 {{same-type constraint 'Self.A' == 'G<Self.A.T>' is recursive}}
 protocol Q1b : Q {
   associatedtype B : P where B.T : R, A == G<B.T>
 }
 
 // CHECK-LABEL: abstract_type_witnesses_in_protocols.(file).Q2@
-// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<Self.[Q]A.[P]T>, Self.[Q2]B : P, Self.[Q]A.[P]T == Self.[Q2]B.[P]T>
+// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<<<error type>>>, Self.[Q2]B : P, Self.[Q]A.[P]T == Self.[Q2]B.[P]T>
 
 // GSB: Missing requirement
+// expected-error@+1 {{same-type constraint 'Self.A' == 'G<Self.A.T>' is recursive}}
 protocol Q2 : Q {
   associatedtype B : P where A.T == B.T, A == G<B.T>
 }
 
 // CHECK-LABEL: abstract_type_witnesses_in_protocols.(file).Q3@
-// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<Self.[Q]A.[P]T>, Self.[Q3]B : P, Self.[Q]A.[P]T == Self.[Q3]B.[P]T>
+// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<<<error type>>>, Self.[Q3]B : P, Self.[Q]A.[P]T == Self.[Q3]B.[P]T>
 
 // GSB: Unsupported recursive requirement
+// expected-error@+1 {{same-type constraint 'Self.A' == 'G<Self.A.T>' is recursive}}
 protocol Q3 : Q {
   associatedtype B : P where A == G<A.T>, A.T == B.T
 }
 
 // CHECK-LABEL: abstract_type_witnesses_in_protocols.(file).Q4@
-// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<Self.[Q]A.[P]T>, Self.[Q4]B : P, Self.[Q]A.[P]T == Self.[Q4]B.[P]T>
+// CHECK-NEXT: Requirement signature: <Self where Self : Q, Self.[Q]A == G<<<error type>>>, Self.[Q4]B : P, Self.[Q]A.[P]T == Self.[Q4]B.[P]T>
 
 // GSB: Unsupported recursive requirement
+// expected-error@+1 {{same-type constraint 'Self.A' == 'G<Self.A.T>' is recursive}}
 protocol Q4 : Q {
   associatedtype B : P where A.T == B.T, A == G<A.T>
 }

test/Generics/occurs_check_diagnostic.swift

@@ -0,0 +1,62 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol P {
+    associatedtype A
+}
+
+struct S<A>: P {}
+
+// expected-error@+1 {{same-type constraint 'Self' == 'S<Self.A>' is recursive}}
+extension P where Self == S<A> {
+  func f1(_: A) -> Self {}
+}
+
+// expected-error@+1 {{same-type constraint 'Self' == 'S<Self.A>' is recursive}}
+extension P where Self == S<Self.A> {
+  func f2(_: A) -> Self {}
+}
+
+class C<A>: P {}
+
+// expected-note@+3 {{while resolving type 'A'}}
+// expected-note@+2 {{while resolving type 'C<A>'}}
+// expected-error@+1 {{extension of protocol 'P' has self-referential generic requirements}}
+extension P where Self : C<A> {
+  func f(_: A) -> Self {}
+}
+
+// expected-error@+1 {{superclass constraint 'Self' : 'C<Self.A>' is recursive}}
+extension P where Self : C<Self.A> {
+  func f(_: A) -> Self {}
+}
+
+// https://github.com/apple/swift/issues/59476
+protocol Fruit {
+    associatedtype Output
+    var output: Output? { get }
+}
+
+struct MapFruit<F: Fruit, Output>: Fruit {
+    var output: Output? { fatalError() }
+}
+
+struct Garden<F: Fruit>: Fruit {
+  // expected-error@+1 {{same-type constraint 'F' == 'MapFruit<G, F.Output>' is recursive}}
+  init<G: Fruit>(fruit1: G) where F == MapFruit<G, Output> { }
+
+  // expected-error@+1 {{same-type constraint 'F' == 'MapFruit<G, F.Output>' is recursive}}
+  init<G: Fruit>(fruit2: G) where F == MapFruit<G, F.Output> { }
+
+  var output: F.Output? { fatalError() }
+}
+
+// rdar://problem/90062518
+extension Slice {
+  // expected-error@+1 {{same-type constraint 'Base' == 'UnsafeBufferPointer<Base.Element>' is recursive}}
+  public func withMemoryRebound<T, Result>(
+    to type: T.Type, _ body: (UnsafeBufferPointer<T>) throws -> Result
+  ) rethrows -> Result where Base == UnsafeBufferPointer<Element> {
+    let rebased = UnsafeBufferPointer<Element>(rebased: self)
+    return try rebased.withMemoryRebound(to: T.self, body)
+  }
+}

test/attr/attr_specialize.swift

@@ -28,8 +28,6 @@ class NonSub {}
 @_specialize(where T == S<Int>)
 @_specialize(where T == Int, U == Int) // expected-error{{cannot find type 'U' in scope}},
 @_specialize(where T == T1) // expected-error{{cannot find type 'T1' in scope}}
-// expected-error@-1 {{too few generic parameters are specified in '_specialize' attribute (got 0, but expected 1)}}
-// expected-note@-2 {{missing constraint for 'T' in '_specialize' attribute}}
 public func oneGenericParam<T>(_ t: T) -> T {
   return t
 }

test/type/opaque.swift

@@ -87,7 +87,7 @@ func blibble(blobble: some P) {}
 func blib() -> P & some Q { return 1 } // expected-error{{'some' should appear at the beginning}}
 func blab() -> some P? { return 1 } // expected-error{{must specify only}} expected-note{{did you mean to write an optional of an 'opaque' type?}}
 func blorb<T: some P>(_: T) { } // expected-error{{'some' types are only permitted}}
-func blub<T>() -> T where T == some P { return 1 } // expected-error{{'some' types are only permitted}} expected-error{{cannot convert}}
+func blub<T>() -> T where T == some P { return 1 } // expected-error{{'some' types are only permitted}}
 
 protocol OP: some P {} // expected-error{{'some' types are only permitted}}