ClangImporter: Lazily load constructor members of classes

This just requires a small refactoring so that we can build inherited
constructors from the lazy loader path.

Author: slavapestov

lib/AST/NameLookup.cpp

@@ -1168,13 +1168,6 @@ TinyPtrVector<ValueDecl *> NominalTypeDecl::lookupDirect(
   bool includeAttrImplements =
       flags.contains(LookupDirectFlags::IncludeAttrImplements);
 
-  // FIXME: At present, lazy member is not able to find inherited constructors
-  // in imported classes, because SwiftDeclConverter::importInheritedConstructors()
-  // is only called via ClangImporter::Implementation::loadAllMembers().
-  if (hasClangNode() &&
-      name.getBaseName() == DeclBaseName::createConstructor())
-    useNamedLazyMemberLoading = false;
-
   LLVM_DEBUG(llvm::dbgs() << getNameStr() << ".lookupDirect("
              << name << ", " << ignoreNewExtensions << ")"
         << ", isLookupTablePopulated()=" << isLookupTablePopulated()

lib/ClangImporter/ClangImporter.cpp

@@ -3655,16 +3655,13 @@ ClangImporter::Implementation::loadNamedMembers(
   auto table = findLookupTable(*CMO);
   assert(table && "clang module without lookup table");
 
-  clang::ASTContext &clangCtx = getClangASTContext();
-
   assert(isa<clang::ObjCContainerDecl>(CD) || isa<clang::NamespaceDecl>(CD));
 
   TinyPtrVector<ValueDecl *> Members;
   for (auto entry : table->lookup(SerializedSwiftName(N),
                                   effectiveClangContext)) {
     if (!entry.is<clang::NamedDecl *>()) continue;
     auto member = entry.get<clang::NamedDecl *>();
-    if (!isVisibleClangEntry(clangCtx, member)) continue;
 
     // Skip Decls from different clang::DeclContexts
     if (member->getDeclContext() != CDC) continue;
@@ -3680,6 +3677,16 @@ ClangImporter::Implementation::loadNamedMembers(
       }
     }
   }
+
+  if (N == DeclBaseName::createConstructor()) {
+    if (auto *classDecl = dyn_cast<ClassDecl>(D)) {
+      SmallVector<Decl *, 4> ctors;
+      importInheritedConstructors(const_cast<ClassDecl *>(classDecl), ctors);
+      for (auto ctor : ctors)
+        Members.push_back(cast<ValueDecl>(ctor));
+    }
+  }
+
   return Members;
 }
 

lib/ClangImporter/ImportDecl.cpp

@@ -7197,6 +7197,17 @@ void SwiftDeclConverter::importNonOverriddenMirroredMethods(DeclContext *dc,
   }
 }
 
+void ClangImporter::Implementation::importInheritedConstructors(
+    ClassDecl *classDecl, SmallVectorImpl<Decl *> &newMembers) {
+  auto curObjCClass = cast<clang::ObjCInterfaceDecl>(classDecl->getClangDecl());
+
+  // Imported inherited initializers.
+  if (curObjCClass->getName() != "Protocol") {
+    SwiftDeclConverter converter(*this, CurrentVersion);
+    converter.importInheritedConstructors(classDecl, newMembers);
+  }
+}
+
 void SwiftDeclConverter::importInheritedConstructors(
     ClassDecl *classDecl, SmallVectorImpl<Decl *> &newMembers) {
   if (!classDecl->hasSuperclass())
@@ -8685,26 +8696,20 @@ void ClangImporter::Implementation::collectMembersToAdd(
       insertMembersAndAlternates(nd, members);
   }
 
-  SwiftDeclConverter converter(*this, CurrentVersion);
-
   SmallVector<ProtocolDecl *, 4> protos = takeImportedProtocols(D);
   if (auto clangClass = dyn_cast<clang::ObjCInterfaceDecl>(objcContainer)) {
-    auto swiftClass = cast<ClassDecl>(D);
-    objcContainer = clangClass = clangClass->getDefinition();
-
-    // Imported inherited initializers.
-    if (clangClass->getName() != "Protocol") {
-      converter.importInheritedConstructors(const_cast<ClassDecl *>(swiftClass),
-                                            members);
-    }
+    importInheritedConstructors(cast<ClassDecl>(D), members);
 
+    objcContainer = clangClass->getDefinition();
   } else if (auto clangProto
                = dyn_cast<clang::ObjCProtocolDecl>(objcContainer)) {
     objcContainer = clangProto->getDefinition();
   }
+
   // Import mirrored declarations for protocols to which this category
   // or extension conforms.
   // FIXME: This is supposed to be a short-term hack.
+  SwiftDeclConverter converter(*this, CurrentVersion);
   converter.importMirroredProtocolMembers(objcContainer, DC,
                                           protos, members, SwiftContext);
 }

lib/ClangImporter/ImporterImpl.h

@@ -802,6 +802,9 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   Decl *importMirroredDecl(const clang::NamedDecl *decl, DeclContext *dc,
                            Version version, ProtocolDecl *proto);
 
+  void importInheritedConstructors(ClassDecl *classDecl,
+                                   SmallVectorImpl<Decl *> &newMembers);
+
   /// Utility function for building simple generic signatures.
   GenericSignature *buildGenericSignature(GenericParamList *genericParams,
                                           DeclContext *dc);

test/ClangImporter/attr-swift_name.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -I %S/Inputs/custom-modules -Xcc -w -typecheck %s 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -I %S/Inputs/custom-modules -Xcc -w -typecheck %s -disable-named-lazy-member-loading 2>&1 | %FileCheck %s
 
 // REQUIRES: objc_interop
 

test/NameBinding/Inputs/NamedLazyMembers/NamedLazyMembers.h

@@ -26,6 +26,8 @@
 // Don't conform to the protocol; that loads all protocol members.
 @interface SimpleDoer
 
+- (instancetype)initWithValue: (int)value;
+
 // These are names we're hoping don't interfere with Doer, above.
 + (SimpleDoer*)Doer;
 + (SimpleDoer*)DoerOfNoWork;
@@ -107,4 +109,14 @@
 @interface SimpleDoerSubclass : SimpleDoer
 - (void)simplyDoSomeWorkWithSpeed:(int)s thoroughness:(int)t
   NS_SWIFT_NAME(simplyDoVeryImportantWork(speed:thoroughness:));
+
+- (void)exuberantlyGoForWalk;
+- (void)exuberantlyTakeNap;
+- (void)exuberantlyEatMeal;
+- (void)exuberantlyTidyHome;
+- (void)exuberantlyCallFamily;
+- (void)exuberantlySingSong;
+- (void)exuberantlyReadBook;
+- (void)exuberantlyAttendLecture;
+- (void)exuberantlyWriteLetter;
 @end

test/NameBinding/named_lazy_member_loading_objc_interface.swift

@@ -12,13 +12,19 @@
 
 import NamedLazyMembers
 
-public func bar(d: SimpleDoerSubclass) {
-    let _ = d.simplyDoVeryImportantWork(speed: 10, motivation: 42)
+public func bar() {
+  let d = SimpleDoerSubclass(value: 123)!
+  let _ = d.simplyDoVeryImportantWork(speed: 10, motivation: 42)
 }
 
-public func foo(d: SimpleDoer) {
+public func foo() {
+  let d = SimpleDoer(value: 123)!
   let _ = d.simplyDoSomeWork()
   let _ = d.simplyDoSomeWork(withSpeed:10)
   let _ = d.simplyDoVeryImportantWork(speed:10, thoroughness:12)
   let _ = d.simplyDoSomeWorkWithSpeed(speed:10, levelOfAlacrity:12)
 }
+
+// Make sure that simply subclassing an imported subclass doesn't page in all
+// members.
+class MostDoerSubclass : SimpleDoerSubclass {}