Sema: Add recursion guard to AssociatedTypeInference::computeFixedTypeWitness()

Author: slavapestov

lib/Sema/TypeCheckProtocolInference.cpp

@@ -809,8 +809,6 @@ AssociatedTypeDecl *AssociatedTypeInference::findDefaultedAssociatedType(
 Type AssociatedTypeInference::computeFixedTypeWitness(
                                             AssociatedTypeDecl *assocType) {
   Type resultType;
-  auto *const structuralTy = DependentMemberType::get(
-      proto->getSelfInterfaceType(), assocType->getName());
 
   // Look at all of the inherited protocols to determine whether they
   // require a fixed type for this associated type.
@@ -823,17 +821,23 @@ Type AssociatedTypeInference::computeFixedTypeWitness(
 
     // FIXME: The RequirementMachine will assert on re-entrant construction.
     // We should find a more principled way of breaking this cycle.
-    if (ctx.isRecursivelyConstructingRequirementMachine(sig.getCanonicalSignature()))
+    if (ctx.isRecursivelyConstructingRequirementMachine(sig.getCanonicalSignature()) ||
+        conformedProto->isComputingRequirementSignature())
       continue;
 
+    auto selfTy = conformedProto->getSelfInterfaceType();
+    if (!sig->requiresProtocol(selfTy, assocType->getProtocol()))
+      continue;
+
+    auto structuralTy = DependentMemberType::get(selfTy, assocType->getName());
     const auto ty = sig->getCanonicalTypeInContext(structuralTy);
 
     // A dependent member type with an identical base and name indicates that
     // the protocol does not same-type constrain it in any way; move on to
     // the next protocol.
     if (auto *const memberTy = ty->getAs<DependentMemberType>()) {
-      if (memberTy->getBase()->isEqual(structuralTy->getBase()) &&
-          memberTy->getName() == structuralTy->getName())
+      if (memberTy->getBase()->isEqual(selfTy) &&
+          memberTy->getName() == assocType->getName())
         continue;
     }
 

test/decl/protocol/req/associated_type_inference.swift

@@ -658,19 +658,27 @@ struct S39<B>: P39 {}
 
 // Test that we can handle an analogous complex case involving all kinds of
 // type witness resolution.
+//
+// FIXME: Except there's too much circularity here, and this really can't
+// work. The problem is that S40 conforms to P40c, and we can't check the
+// conformance without computing the requirement signature of P40c, but the
+// requirement signature computation depends on the conformance, via the
+// 'D == S40<Never>' requirement.
 protocol P40a {
   associatedtype A
   associatedtype B: P40a
 
   func foo(arg: A)
 }
 protocol P40b: P40a {
-  associatedtype C = (A, B.A, D.D, E) -> Self
-  associatedtype D: P40b
-  associatedtype E: Equatable
+  associatedtype C = (A, B.A, D.D, E) -> Self // expected-note {{protocol requires nested type 'C'; do you want to add it?}}
+  associatedtype D: P40b // expected-note {{protocol requires nested type 'D'; do you want to add it?}}
+  associatedtype E: Equatable // expected-note {{protocol requires nested type 'E'; do you want to add it?}}
 }
 protocol P40c: P40b where D == S40<Never> {}
 struct S40<E: Equatable>: P40c {
+  // expected-error@-1 {{type 'S40<E>' does not conform to protocol 'P40b'}}
+  // expected-error@-2 {{type 'S40<E>' does not conform to protocol 'P40c'}}
   func foo(arg: Never) {}
 
   typealias B = Self