Sema: Tighten up getReferencedAssociatedTypes()

If a protocol requirement has a type that's a nested member
type of another member type, eg,

protocol P {
  associatedtype A : Q
  func f(_: A.B)
}

Then we don't actually want to use 'f()' to infer the witness
for 'A'. By avoiding doing so, we eliminate some cycles which
can allow some programs to type check that didn't before.

Author: slavapestov

lib/Sema/TypeCheckProtocol.cpp

@@ -2219,16 +2219,39 @@ ConformanceChecker::getReferencedAssociatedTypes(ValueDecl *req) {
     return known->second;
 
   // Collect the set of associated types rooted on Self in the
-  // signature.
+  // signature. Note that for references to nested types, we only
+  // want to consider the outermost dependent member type.
+  //
+  // For example, a requirement typed '(Iterator.Element) -> ()'
+  // is not considered to reference the associated type 'Iterator'.
   auto &assocTypes = ReferencedAssociatedTypes[req];
-  llvm::SmallPtrSet<AssociatedTypeDecl *, 4> knownAssocTypes;
-  req->getInterfaceType()->getCanonicalType().visit([&](CanType type) {
-      if (auto assocType = getReferencedAssocTypeOfProtocol(type, Proto)) {
-        if (knownAssocTypes.insert(assocType).second) {
-          assocTypes.push_back(assocType);
+
+  class Walker : public TypeWalker {
+    ProtocolDecl *Proto;
+    llvm::SmallVectorImpl<AssociatedTypeDecl *> &assocTypes;
+    llvm::SmallPtrSet<AssociatedTypeDecl *, 4> knownAssocTypes;
+
+  public:
+    Walker(ProtocolDecl *Proto,
+           llvm::SmallVectorImpl<AssociatedTypeDecl *> &assocTypes)
+      : Proto(Proto), assocTypes(assocTypes) {}
+
+    Action walkToTypePre(Type type) override {
+      if (type->is<DependentMemberType>()) {
+        if (auto assocType = getReferencedAssocTypeOfProtocol(type, Proto)) {
+          if (knownAssocTypes.insert(assocType).second)
+            assocTypes.push_back(assocType);
         }
+
+        return Action::SkipChildren;
       }
-    });
+
+      return Action::Continue;
+    }
+  };
+
+  Walker walker(Proto, assocTypes);
+  req->getInterfaceType()->getCanonicalType().walk(walker);
 
   return assocTypes;
 }

test/decl/protocol/req/associated_type_inference_valid.swift

@@ -0,0 +1,24 @@
+// RUN: %target-swift-frontend -emit-silgen %s
+
+// This is a SILGen test to ensure we can completely check these conformances
+// and build valid AST.
+
+protocol P {
+  associatedtype T : Q = S
+  typealias Y = T.X
+
+  func foo(_: T.X)
+}
+
+protocol Q {
+  associatedtype X
+}
+
+struct S : Q {
+  typealias X = ()
+}
+
+struct R : P {
+  let x: Y? = nil
+  func foo(_: Y) {}
+}

validation-test/compiler_crashers_2_fixed/sr11052-typealias.swift

@@ -19,7 +19,7 @@ struct Concrete<AType2: ProtoA>: ProtoB {
         fatalError()
     }
 
-    func protoFunc() -> Alias { // expected-error{{unsupported recursion for reference to type alias 'Alias' of type 'Concrete<AType2>'}}
+    func protoFunc() -> Alias {
         fatalError()
     }
 }