AST: Optimize construction of the AnyObject dispatch table

Instead of visiting all members of all types and extensions, bail out
early if the type is not a class or protocol, or the extension is not
extending a class. This means we don't visit structs, enums or
protocol extensions at all, which will avoid delayed parsing.

Also, we were evaluating isObjC() on each member, which is an expensive
operation; if the member does not have an explicit @objc we would still
have to check if it overrides an @objc method or witnesses an @objc
protocol requirement.

Since most members are not ever found by dynamic lookup, this is wasted
work. Instead, let's rely on AnyObject lookup filtering non-@objc
members at the call site, which it was already doing anyway.

Author: slavapestov

include/swift/AST/DeclContext.h

@@ -459,6 +459,10 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// are used.
   ResilienceExpansion getResilienceExpansion() const;
 
+  /// Returns true if this context may possibly contain members visible to
+  /// AnyObject dynamic lookup.
+  bool mayContainMembersAccessedByDynamicLookup() const;
+
   /// Returns true if lookups within this context could affect downstream files.
   ///
   /// \param functionsAreNonCascading If true, functions are considered non-
@@ -724,6 +728,7 @@ class IterableDeclContext {
     MemberCount = 0;
     HasOperatorDeclarations = 0;
     HasUnparsedMembers = 0;
+    HasNestedClassDeclarations = 0;
   }
 
   /// Determine the kind of iterable context we have.

lib/AST/Decl.cpp

@@ -2672,26 +2672,14 @@ bool ValueDecl::canBeAccessedByDynamicLookup() const {
   if (!hasName())
     return false;
 
-  // Dynamic lookup can only find class and protocol members, or extensions of
-  // classes.
-  auto nominalDC = getDeclContext()->getSelfNominalTypeDecl();
-  if (!nominalDC ||
-      (!isa<ClassDecl>(nominalDC) && !isa<ProtocolDecl>(nominalDC)))
-    return false;
-
-  // Dynamic lookup cannot find results within a non-protocol generic context,
-  // because there is no sensible way to infer the generic arguments.
-  if (getDeclContext()->isGenericContext() && !isa<ProtocolDecl>(nominalDC))
+  auto *dc = getDeclContext();
+  if (!dc->mayContainMembersAccessedByDynamicLookup())
     return false;
 
   // Dynamic lookup can find functions, variables, and subscripts.
   if (!isa<FuncDecl>(this) && !isa<VarDecl>(this) && !isa<SubscriptDecl>(this))
     return false;
 
-  // Dynamic lookup can only find @objc members.
-  if (!isObjC())
-    return false;
-
   return true;
 }
 

lib/AST/DeclContext.cpp

@@ -475,6 +475,25 @@ unsigned DeclContext::getSemanticDepth() const {
   return 1 + getParent()->getSemanticDepth();
 }
 
+bool DeclContext::mayContainMembersAccessedByDynamicLookup() const {
+  // Dynamic lookup can only find class and protocol members, or extensions of
+  // classes.
+  if (auto *NTD = dyn_cast<NominalTypeDecl>(this)) {
+    if (isa<ClassDecl>(NTD))
+      if (!isGenericContext())
+        return true;
+    if (auto *PD = dyn_cast<ProtocolDecl>(NTD))
+      if (PD->getAttrs().hasAttribute<ObjCAttr>())
+        return true;
+  } else if (auto *ED = dyn_cast<ExtensionDecl>(this)) {
+    if (auto *CD = dyn_cast<ClassDecl>(ED->getExtendedNominal()))
+      if (!CD->isGenericContext())
+        return true;
+  }
+
+  return false;
+}
+
 bool DeclContext::walkContext(ASTWalker &Walker) {
   switch (getContextKind()) {
   case DeclContextKind::Module:

lib/AST/Module.cpp

@@ -214,9 +214,15 @@ void SourceLookupCache::doPopulateCache(Range decls,
 void SourceLookupCache::populateMemberCache(const SourceFile &SF) {
   for (const Decl *D : SF.Decls) {
     if (const auto *NTD = dyn_cast<NominalTypeDecl>(D)) {
-      addToMemberCache(NTD->getMembers());
+      if (!NTD->hasUnparsedMembers() ||
+          NTD->maybeHasNestedClassDeclarations() ||
+          NTD->mayContainMembersAccessedByDynamicLookup())
+        addToMemberCache(NTD->getMembers());
     } else if (const auto *ED = dyn_cast<ExtensionDecl>(D)) {
-      addToMemberCache(ED->getMembers());
+      if (!ED->hasUnparsedMembers() ||
+          ED->maybeHasNestedClassDeclarations() ||
+          ED->mayContainMembersAccessedByDynamicLookup())
+        addToMemberCache(ED->getMembers());
     }
   }
 
@@ -232,7 +238,10 @@ void SourceLookupCache::addToMemberCache(DeclRange decls) {
     if (auto NTD = dyn_cast<NominalTypeDecl>(VD)) {
       assert(!VD->canBeAccessedByDynamicLookup() &&
              "inner types cannot be accessed by dynamic lookup");
-      addToMemberCache(NTD->getMembers());
+      if (!NTD->hasUnparsedMembers() ||
+          NTD->maybeHasNestedClassDeclarations() ||
+          NTD->mayContainMembersAccessedByDynamicLookup())
+        addToMemberCache(NTD->getMembers());
     } else if (VD->canBeAccessedByDynamicLookup()) {
       ClassMembers.add(VD);
     }

validation-test/compiler_crashers_2_fixed/0177-rdar-33093935.swift

@@ -10,5 +10,5 @@ extension A {
 }
 
 class B: A {
-  @objc var foo = superclass()?.name // expected-error{{property 'foo' references itself}}
+  @objc var foo = superclass()?.name
 }

validation-test/compiler_scale/dynamic_lookup.gyb

@@ -0,0 +1,20 @@
+// RUN: %scale-test --sum-multi --begin 5 --end 16 --step 5 --select Sema.IsObjCRequest -Xfrontend=-disable-objc-attr-requires-foundation-module %s
+// REQUIRES: OS=macosx
+// REQUIRES: asserts
+
+class C${N} {
+  // This is the member we actually have to validate; we only want there
+  // to be one definition:
+% if int(N) == 1:
+  @objc func isObjCMember() {}
+% end
+
+  // Other random @objc and non-@objc members; the test ensures that we're
+  // not touching these:
+  func isAnotherObjCMember() {}
+  func isNonObjCMember() {}
+}
+
+func f${N}(a: AnyObject) {
+  a.isObjCMember!()
+}

validation-test/compiler_scale/dynamic_lookup_2.swift

@@ -0,0 +1,19 @@
+// RUN: %scale-test --sum-multi --begin 5 --end 16 --step 5 --select NumIterableDeclContextParsed -Xfrontend=-disable-objc-attr-requires-foundation-module %s
+// REQUIRES: OS=macosx
+// REQUIRES: asserts
+
+// Dynamic member lookup should not force delayed parsing of structs, enums or protocol
+// extensions.
+struct S${N} {}
+enum E${N} {}
+extension Sequence {}
+
+% if int(N) == 1:
+class C {
+    @objc func isObjCMember() {}
+}
+% end
+
+func f${N}(a: AnyObject) {
+  a.isObjCMember!()
+}