RequirementMachine: Diagnose recursive requirements

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/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)
+  }
+}