AST: Make the 'decl' name lookup behavior match type resolution more closely

Extension binding and resolution of inherited protocols uses a more primitive
'declaration' based lookup that resolves a TypeRepr directly to a set of
NominalTypeDecls.

This lookup differs from type resolution in a few subtle ways, namely the
handling of ambiguity. In particular, if there are multiple declarations
with the same name, the primitive lookup returns all of them, since it
cannot perform the full ambiguity check done in type resolution, which
looks at typealias underlying types.

However, in the case where the multiple results are all nominal types, we
can definitely fail the 'decl' name lookup right away.

Author: slavapestov

lib/AST/NameLookup.cpp

@@ -2105,11 +2105,22 @@ directReferencesForUnqualifiedTypeLookup(DeclNameRef name,
   auto descriptor = UnqualifiedLookupDescriptor(name, dc, loc, options);
   auto lookup = evaluateOrDefault(ctx.evaluator,
                                   UnqualifiedLookupRequest{descriptor}, {});
+
+  unsigned nominalTypeDeclCount = 0;
   for (const auto &result : lookup.allResults()) {
     auto typeDecl = cast<TypeDecl>(result.getValueDecl());
+
+    if (isa<NominalTypeDecl>(typeDecl))
+      nominalTypeDeclCount++;
+
     results.push_back(typeDecl);
   }
 
+  // If we saw multiple nominal type declarations with the same name,
+  // the result of the lookup is definitely ambiguous.
+  if (nominalTypeDeclCount > 1)
+    results.clear();
+
   return results;
 }
 

test/Generics/ambiguous_protocol_inheritance.swift

@@ -0,0 +1,15 @@
+// RUN: %target-typecheck-verify-swift -requirement-machine=verify
+
+protocol Base { // expected-note {{'Base' previously declared here}}
+// expected-note@-1 {{found this candidate}}
+  associatedtype E
+}
+
+struct Base<T> {} // expected-error {{invalid redeclaration of 'Base'}}
+// expected-note@-1 {{found this candidate}}
+
+protocol Derived : Base { // expected-error {{'Base' is ambiguous for type lookup in this context}}
+  associatedtype E
+}
+
+func foo<T : Derived>(_: T.E, _: T) {}