[Name lookup] Use decl-based name lookup for the conformance lookup table.

Add API to get all of the nominal types directly referenced from the
inheritance clause of a given declaration. Use that to find the protocols
to enter into the conformance lookup table based on a given declaration,
without going through the type checker [*].

[*] Except for unqualified lookup still needing to use the type checker.

Author: DougGregor

include/swift/AST/NameLookup.h

@@ -351,6 +351,24 @@ void lookupInModule(ModuleDecl *module, ModuleDecl::AccessPathTy accessPath,
                     ArrayRef<ModuleDecl::ImportedModule> extraImports = {});
 
 } // end namespace namelookup
+
+/// Retrieve the set of nominal type declarations that are directly
+/// "inherited" by the given declaration at a particular position in the
+/// list of "inherited" types.
+///
+/// Add anything we find to the
+void getDirectlyInheritedNominalTypeDecls(
+    llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
+    unsigned i,
+    llvm::SmallVectorImpl<std::pair<SourceLoc, NominalTypeDecl *>> &result);
+
+/// Retrieve the set of nominal type declarations that are directly
+/// "inherited" by the given declaration, looking through typealiases
+/// and splitting out the components of compositions.
+SmallVector<std::pair<SourceLoc, NominalTypeDecl *>, 4>
+getDirectlyInheritedNominalTypeDecls(
+                      llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl);
+
 } // end namespace swift
 
 #endif

lib/AST/ConformanceLookupTable.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/NameLookup.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "llvm/Support/SaveAndRestore.h"
@@ -488,22 +489,10 @@ bool ConformanceLookupTable::addProtocol(ProtocolDecl *protocol, SourceLoc loc,
 void ConformanceLookupTable::addInheritedProtocols(
                           llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
                           ConformanceSource source) {
-  // Visit each of the types in the inheritance list to find
-  // protocols.
-  auto typeDecl = decl.dyn_cast<TypeDecl *>();
-  auto extDecl = decl.dyn_cast<ExtensionDecl *>();
-  unsigned numInherited = typeDecl ? typeDecl->getInherited().size()
-                                   : extDecl->getInherited().size();
-  for (auto index : range(numInherited)) {
-    Type inheritedType = typeDecl ? typeDecl->getInheritedType(index)
-                                  : extDecl->getInheritedType(index);
-    if (!inheritedType || !inheritedType->isExistentialType())
-      continue;
-    SourceLoc loc = typeDecl ? typeDecl->getInherited()[index].getLoc()
-                             : extDecl->getInherited()[index].getLoc();
-    auto layout = inheritedType->getExistentialLayout();
-    for (auto *proto : layout.getProtocols())
-      addProtocol(proto->getDecl(), loc, source);
+  // Find all of the protocols in the inheritance list.
+  for (const auto &found : getDirectlyInheritedNominalTypeDecls(decl)) {
+    if (auto proto = dyn_cast<ProtocolDecl>(found.second))
+      addProtocol(proto, found.first, source);
   }
 }
 

lib/AST/NameLookup.cpp

@@ -2277,3 +2277,53 @@ NominalTypeDecl *ExtendedNominalRequest::evaluate(Evaluator &evaluator,
     = resolveTypeDeclsToNominal(evaluator, ctx, referenced, modulesFound);
   return nominalTypes.empty() ? nullptr : nominalTypes.front();
 }
+
+void swift::getDirectlyInheritedNominalTypeDecls(
+    llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
+    unsigned i,
+    llvm::SmallVectorImpl<std::pair<SourceLoc, NominalTypeDecl *>> &result) {
+  auto typeDecl = decl.dyn_cast<TypeDecl *>();
+  auto extDecl = decl.dyn_cast<ExtensionDecl *>();
+
+  ASTContext &ctx = typeDecl ? typeDecl->getASTContext()
+                             : extDecl->getASTContext();
+
+  // Find inherited declarations.
+  auto referenced = ctx.evaluator(InheritedDeclsReferencedRequest{decl, i});
+
+  // Resolve those type declarations to nominal type declarations.
+  SmallVector<ModuleDecl *, 2> modulesFound;
+  auto nominalTypes
+    = resolveTypeDeclsToNominal(ctx.evaluator, ctx, referenced, modulesFound);
+
+  // Dig out the source location
+  // FIXME: This is a hack. We need cooperation from
+  // InheritedDeclsReferencedRequest to make this work.
+  SourceLoc loc;
+  if (TypeRepr *typeRepr = typeDecl ? typeDecl->getInherited()[i].getTypeRepr()
+                                    : extDecl->getInherited()[i].getTypeRepr()){
+    loc = typeRepr->getLoc();
+  }
+
+  // Form the result.
+  for (auto nominal : nominalTypes) {
+    result.push_back({loc, nominal});
+  }
+}
+
+SmallVector<std::pair<SourceLoc, NominalTypeDecl *>, 4>
+swift::getDirectlyInheritedNominalTypeDecls(
+                        llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl) {
+  auto typeDecl = decl.dyn_cast<TypeDecl *>();
+  auto extDecl = decl.dyn_cast<ExtensionDecl *>();
+
+  // Gather results from all of the inherited types.
+  unsigned numInherited = typeDecl ? typeDecl->getInherited().size()
+                                   : extDecl->getInherited().size();
+  SmallVector<std::pair<SourceLoc, NominalTypeDecl *>, 4> result;
+  for (unsigned i : range(numInherited)) {
+    getDirectlyInheritedNominalTypeDecls(decl, i, result);
+  }
+
+  return result;
+}

test/decl/inherit/inherit.swift

@@ -46,7 +46,9 @@ struct S2 : struct { } // expected-error{{expected type}}
 struct S3 : P, P & Q { } // expected-error {{redundant conformance of 'S3' to protocol 'P'}}
                          // expected-error @-1 {{non-class type 'S3' cannot conform to class protocol 'Q'}}
                          // expected-note @-2 {{'S3' declares conformance to protocol 'P' here}}
-struct S4 : P, P { }     // expected-error {{duplicate inheritance from 'P'}}
+struct S4 : P, P { }     // FIXME: expected-error {{duplicate inheritance from 'P'}}
+// expected-error@-1{{redundant conformance of 'S4' to protocol 'P'}}
+// expected-note@-2{{'S4' declares conformance to protocol 'P' here}}
 struct S6 : P & { }      // expected-error {{expected identifier for type name}}
 struct S7 : protocol<P, Q> { }  // expected-error {{'protocol<...>' composition syntax has been removed; join the protocols using '&'}}
                                 // expected-error @-1 {{non-class type 'S7' cannot conform to class protocol 'Q'}}