Change a cycle condition

Not having the generic signature is the real culprit here.

Author: CodaFi

include/swift/AST/TypeCheckRequests.h

@@ -434,6 +434,9 @@ class RequirementRequest :
   // Source location
   SourceLoc getNearestLoc() const;
 
+  // Cycle handling.
+  void noteCycleStep(DiagnosticEngine &diags) const;
+                           
   // Separate caching.
   bool isCached() const;
   Optional<Requirement> getCachedResult() const;
@@ -1120,6 +1123,9 @@ class InferredGenericSignatureRequest :
   SourceLoc getNearestLoc() const {
     return SourceLoc();
   }
+                           
+  // Cycle handling.
+  void noteCycleStep(DiagnosticEngine &diags) const;
 };
 
 void simple_display(llvm::raw_ostream &out, const TypeLoc source);
@@ -1174,7 +1180,7 @@ class GenericSignatureRequest :
   llvm::Expected<GenericSignature *>
   evaluate(Evaluator &evaluator, GenericContext *value) const;
 
-public:              
+public:
   // Separate caching.
   bool isCached() const { return true; }
   Optional<GenericSignature *> getCachedResult() const;

lib/AST/TypeCheckRequests.cpp

@@ -364,6 +364,14 @@ SourceLoc RequirementRequest::getNearestLoc() const {
   return owner.getLoc();
 }
 
+void RequirementRequest::noteCycleStep(DiagnosticEngine &diags) const {
+  // For now, the GSB does a better job of describing the exact structure of
+  // the cycle.
+  //
+  // FIXME: We should consider merging the circularity handling the GSB does
+  // into this request.  See rdar://55263708
+}
+
 MutableArrayRef<RequirementRepr> WhereClauseOwner::getRequirements() const {
   if (auto genericParams = source.dyn_cast<GenericParamList *>()) {
     return genericParams->getRequirements();
@@ -823,6 +831,18 @@ void GenericSignatureRequest::cacheResult(GenericSignature *value) const {
   GC->GenericSigAndBit.setPointerAndInt(value, true);
 }
 
+//----------------------------------------------------------------------------//
+// GenericSignatureRequest computation.
+//----------------------------------------------------------------------------//
+
+void InferredGenericSignatureRequest::noteCycleStep(DiagnosticEngine &d) const {
+  // For now, the GSB does a better job of describing the exact structure of
+  // the cycle.
+  //
+  // FIXME: We should consider merging the circularity handling the GSB does
+  // into this request.  See rdar://55263708
+}
+
 //----------------------------------------------------------------------------//
 // IsImplicitlyUnwrappedOptionalRequest computation.
 //----------------------------------------------------------------------------//

lib/Sema/TypeCheckType.cpp

@@ -768,7 +768,7 @@ Type TypeChecker::applyGenericArguments(Type type,
   }
 
   // FIXME: More principled handling of circularity.
-  if (!genericDecl->hasValidSignature()) {
+  if (!genericDecl->getGenericSignature()) {
     diags.diagnose(loc, diag::recursive_decl_reference,
              genericDecl->getDescriptiveKind(), genericDecl->getName());
     genericDecl->diagnose(diag::kind_declared_here, DescriptiveDeclKind::Type);

test/Generics/generic_types.swift

@@ -230,6 +230,8 @@ class Top {}
 class Bottom<T : Bottom<Top>> {}
 // expected-error@-1 {{generic class 'Bottom' references itself}}
 // expected-note@-2 {{type declared here}}
+// expected-error@-3 {{circular reference}}
+// expected-note@-4 {{through reference here}}
 
 // Invalid inheritance clause
 

test/decl/protocol/req/recursion.swift

@@ -43,7 +43,7 @@ public protocol P {
   associatedtype T
 }
 
-public struct S<A: P> where A.T == S<A> {
+public struct S<A: P> where A.T == S<A> { // expected-error {{circular reference}}
 // expected-note@-1 {{type declared here}}
 // expected-error@-2 {{generic struct 'S' references itself}}
   func f(a: A.T) {
@@ -71,7 +71,7 @@ protocol PI {
   associatedtype T : I
 }
 
-struct SI<A: PI> : I where A : I, A.T == SI<A> {
+struct SI<A: PI> : I where A : I, A.T == SI<A> { // expected-error {{circular reference}}
 // expected-note@-1 {{type declared here}}
 // expected-error@-2 {{generic struct 'SI' references itself}}
   func ggg<T : I>(t: T.Type) -> T {