Narrow a few LazyResolver::resolveDeclSignature() calls to what they really need.

Specifically, introduce entrypoints for "resolve overridden decl" and "is @objc". These can
be computed cheaply in many more cases.

Author: DougGregor

include/swift/AST/LazyResolver.h

@@ -65,6 +65,12 @@ class LazyResolver {
   /// consistency and provides the value a type.
   virtual void resolveDeclSignature(ValueDecl *VD) = 0;
 
+  /// Resolve the "overridden" declaration of the given declaration.
+  virtual void resolveOverriddenDecl(ValueDecl *VD) = 0;
+
+  /// Resolve the "is Objective-C" bit for the given declaration.
+  virtual void resolveIsObjC(ValueDecl *VD) = 0;
+
   /// Resolve the types in the inheritance clause of the given
   /// declaration context, which will be a type declaration or
   /// extension declaration.

lib/AST/GenericSignatureBuilder.cpp

@@ -7459,6 +7459,12 @@ GenericSignature *GenericSignatureBuilder::computeRequirementSignature(
                                                      ProtocolDecl *proto) {
   GenericSignatureBuilder builder(proto->getASTContext());
 
+  if (!proto->hasInterfaceType()) {
+    // FIXME: Overkill.
+    if (auto lazyResolver = proto->getASTContext().getLazyResolver())
+      lazyResolver->resolveDeclSignature(proto);
+  }
+
   // Add the 'self' parameter.
   auto selfType =
     proto->getSelfInterfaceType()->castTo<GenericTypeParamType>();

lib/AST/NameLookup.cpp

@@ -80,31 +80,16 @@ static void forAllVisibleModules(const DeclContext *DC, const Fn &fn) {
     cast<ModuleDecl>(moduleScope)->forAllVisibleModules(ModuleDecl::AccessPathTy(), fn);
 }
 
-/// Determine whether the given declaration can be an override.
-static bool canBeAnOverride(ValueDecl *decl) {
-  // Only declarations within classes can have an overridden declaration.
-  if (!decl->getDeclContext()->getAsClassOrClassExtensionContext())
-    return false;
-
-  // FIXME: We could rely on the presence of the 'override' keyword to
-  // narrow this check.
-  return true;
-}
-
 bool swift::removeOverriddenDecls(SmallVectorImpl<ValueDecl*> &decls) {
   if (decls.size() < 2)
     return false;
 
   auto lazyResolver = decls.front()->getASTContext().getLazyResolver();
   llvm::SmallPtrSet<ValueDecl*, 8> overridden;
   for (auto decl : decls) {
-    // Skip anything that can't be an override.
-    if (!canBeAnOverride(decl)) continue;
-
     // Compute enough information to make the overridden-declaration available.
-    // FIXME: Narrow this check!
     if (lazyResolver)
-      lazyResolver->resolveDeclSignature(decl);
+      lazyResolver->resolveOverriddenDecl(decl);
 
     while (auto overrides = decl->getOverriddenDecl()) {
       overridden.insert(overrides);
@@ -120,6 +105,10 @@ bool swift::removeOverriddenDecls(SmallVectorImpl<ValueDecl*> &decls) {
         ///        cause instead (incomplete circularity detection).
         assert(decl != overrides && "Circular class inheritance?");
         decl = overrides;
+
+        if (lazyResolver)
+          lazyResolver->resolveOverriddenDecl(decl);
+
         continue;
       }
 
@@ -1909,17 +1898,20 @@ bool DeclContext::lookupQualified(Type type,
       if ((options & NL_OnlyTypes) && !isa<TypeDecl>(decl))
         continue;
 
+      // If the declaration is not @objc, it cannot be called dynamically.
       if (typeResolver)
-        typeResolver->resolveDeclSignature(decl);
+        typeResolver->resolveIsObjC(decl);
+
+      if (!decl->isObjC())
+        continue;
 
       // If the declaration has an override, name lookup will also have
       // found the overridden method. Skip this declaration, because we
       // prefer the overridden method.
-      if (decl->getOverriddenDecl())
-        continue;
+      if (typeResolver)
+        typeResolver->resolveOverriddenDecl(decl);
 
-      // If the declaration is not @objc, it cannot be called dynamically.
-      if (!decl->isObjC())
+      if (decl->getOverriddenDecl())
         continue;
 
       auto dc = decl->getDeclContext();

lib/AST/Type.cpp

@@ -1835,7 +1835,7 @@ getObjCObjectRepresentable(Type type, const DeclContext *dc) {
   if (auto classDecl = type->getClassOrBoundGenericClass()) {
     auto &ctx = classDecl->getASTContext();
     if (auto resolver = ctx.getLazyResolver())
-      resolver->resolveDeclSignature(classDecl);
+      resolver->resolveIsObjC(classDecl);
 
     if (classDecl->isObjC())
       return ForeignRepresentableKind::Object;

lib/ClangImporter/ClangImporter.cpp

@@ -3539,7 +3539,7 @@ EffectiveClangContext ClangImporter::Implementation::getEffectiveClangContext(
 
   // Resolve the type.
   if (auto typeResolver = getTypeResolver())
-    typeResolver->resolveDeclSignature(const_cast<NominalTypeDecl *>(nominal));
+    typeResolver->resolveIsObjC(const_cast<NominalTypeDecl *>(nominal));
 
   // If it's an @objc entity, go look for it.
   if (nominal->isObjC()) {

lib/ClangImporter/ImportDecl.cpp

@@ -4395,9 +4395,6 @@ namespace {
       T *found = nullptr;
       for (auto result : results) {
         if (auto singleResult = dyn_cast<T>(result)) {
-          if (auto typeResolver = Impl.getTypeResolver())
-            typeResolver->resolveDeclSignature(singleResult);
-
           // Skip versioned variants.
           const DeclAttributes &attrs = singleResult->getAttrs();
           if (attrs.isUnavailableInSwiftVersion(languageVersion))

lib/ClangImporter/ImportType.cpp

@@ -2364,8 +2364,6 @@ getNamedSwiftTypeSpecialization(ModuleDecl *module, StringRef name,
                       NLKind::UnqualifiedLookup, results);
   if (results.size() == 1) {
     if (auto nominalDecl = dyn_cast<NominalTypeDecl>(results.front())) {
-      if (auto *typeResolver = getTypeResolver())
-        typeResolver->resolveDeclSignature(nominalDecl);
       if (auto params = nominalDecl->getGenericParams()) {
         if (params->size() == args.size()) {
           // When we form the bound generic type, make sure we get the

lib/Sema/TypeCheckDecl.cpp

@@ -3792,6 +3792,51 @@ void TypeChecker::validateDecl(PrecedenceGroupDecl *PGD) {
   if (isInvalid) PGD->setInvalid();
 }
 
+void TypeChecker::resolveOverriddenDecl(ValueDecl *VD) {
+  // Only members of classes can override other declarations.
+  if (!VD->getDeclContext()->getAsClassOrClassExtensionContext())
+    return;
+
+  // Types that aren't associated types cannot be overridden.
+  if (isa<TypeDecl>(VD) && !isa<AssociatedTypeDecl>(VD))
+    return;
+
+  // FIXME: We should check for the 'override' or 'required' keywords
+  // here, to short-circuit checking in the common case.
+
+  // FIXME: We should perform more minimal validation.
+  validateDeclForNameLookup(VD);
+}
+
+void TypeChecker::resolveIsObjC(ValueDecl *VD) {
+  // Short-circuit this operation if we already know that the entity is @objc.
+  if (VD->isObjC()) return;
+
+  auto dc = VD->getDeclContext();
+  if (dc->getAsClassOrClassExtensionContext()) {
+    // Members of classes can be @objc.
+
+    // FIXME: We
+    validateDeclForNameLookup(VD);
+  }
+  else if (isa<ClassDecl>(VD)) {
+    // Classes can be @objc.
+
+    // Protocols and enums can also be @objc, but this is covered by the
+    // isObjC() check at the beginning.
+  }
+  else if (isa<ProtocolDecl>(dc) && cast<ProtocolDecl>(dc)->isObjC()) {
+    // Members of @objc protocols are @objc.
+  }
+  else {
+    // Cannot be @objc; do nothing.
+    return;
+  }
+
+  // FIXME: Narrow this computation to just the @objc bits.
+  validateDeclForNameLookup(VD);
+}
+
 PrecedenceGroupDecl *TypeChecker::lookupPrecedenceGroup(DeclContext *dc,
                                                         Identifier name,
                                                         SourceLoc nameLoc) {

lib/Sema/TypeChecker.h

@@ -1378,6 +1378,12 @@ class TypeChecker final : public LazyResolver {
     validateDeclForNameLookup(VD);
   }
 
+  /// Resolve the "overridden" declaration of the given declaration.
+  virtual void resolveOverriddenDecl(ValueDecl *VD) override;
+
+  /// Resolve the "is Objective-C" bit for the given declaration.
+  virtual void resolveIsObjC(ValueDecl *VD) override;
+
   virtual void bindExtension(ExtensionDecl *ext) override;
 
   virtual void resolveExtension(ExtensionDecl *ext) override {