Implement importing of forward declared objc protocols and interfaces

This modifies the ClangImporter to introduce an opaque placeholder
representation for forward declared Objective-C interfaces and
protocols when imported into Swift.

In the compiler, the new functionality is hidden behind a frontend
flag -enable-import-objc-forward-declarations, and is on by default
for language mode >6.

The feature is disabled entirely in LLDB expression evaluation / Swift
REPL, regardless of language version.

Author: NuriAmari

include/swift/AST/Decl.h

@@ -629,54 +629,61 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     HasAnyUnavailableValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1,
-    /// If the module is compiled as static library.
-    StaticLibrary : 1,
+  SWIFT_INLINE_BITFIELD(
+      ModuleDecl, TypeDecl,
+      1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1,
+      /// If the module is compiled as static library.
+      StaticLibrary : 1,
 
-    /// If the module was or is being compiled with `-enable-testing`.
-    TestingEnabled : 1,
+      /// If the module was or is being compiled with `-enable-testing`.
+      TestingEnabled : 1,
 
-    /// If the module failed to load
-    FailedToLoad : 1,
+      /// If the module failed to load
+      FailedToLoad : 1,
 
-    /// Whether the module is resilient.
-    ///
-    /// \sa ResilienceStrategy
-    RawResilienceStrategy : 1,
+      /// Whether the module is resilient.
+      ///
+      /// \sa ResilienceStrategy
+      RawResilienceStrategy : 1,
 
-    /// Whether the module was rebuilt from a module interface instead of being
-    /// build from the full source.
-    IsBuiltFromInterface : 1,
+      /// Whether the module was rebuilt from a module interface instead of
+      /// being build from the full source.
+      IsBuiltFromInterface : 1,
 
-    /// Whether all imports have been resolved. Used to detect circular imports.
-    HasResolvedImports : 1,
+      /// Whether all imports have been resolved. Used to detect circular
+      /// imports.
+      HasResolvedImports : 1,
 
-    /// If the module was or is being compiled with `-enable-private-imports`.
-    PrivateImportsEnabled : 1,
+      /// If the module was or is being compiled with `-enable-private-imports`.
+      PrivateImportsEnabled : 1,
 
-    /// If the module is compiled with `-enable-implicit-dynamic`.
-    ImplicitDynamicEnabled : 1,
+      /// If the module is compiled with `-enable-implicit-dynamic`.
+      ImplicitDynamicEnabled : 1,
 
-    /// Whether the module is a system module.
-    IsSystemModule : 1,
+      /// Whether the module is a system module.
+      IsSystemModule : 1,
 
-    /// Whether the module was imported from Clang (or, someday, maybe another
-    /// language).
-    IsNonSwiftModule : 1,
+      /// Whether the module was imported from Clang (or, someday, maybe another
+      /// language).
+      IsNonSwiftModule : 1,
 
-    /// Whether this module is the main module.
-    IsMainModule : 1,
+      /// Whether this module is the main module.
+      IsMainModule : 1,
 
-    /// Whether this module has incremental dependency information available.
-    HasIncrementalInfo : 1,
+      /// Whether this module has incremental dependency information available.
+      HasIncrementalInfo : 1,
 
-    /// Whether this module was built with -experimental-hermetic-seal-at-link.
-    HasHermeticSealAtLink : 1,
+      /// Whether this module was built with
+      /// -experimental-hermetic-seal-at-link.
+      HasHermeticSealAtLink : 1,
 
-    /// Whether this module has been compiled with comprehensive checking for
-    /// concurrency, e.g., Sendable checking.
-    IsConcurrencyChecked : 1
-  );
+      /// Whether this module has been compiled with comprehensive checking for
+      /// concurrency, e.g., Sendable checking.
+      IsConcurrencyChecked : 1,
+
+      // If the map from @objc provided name to top level swift::Decl in this
+      // module is populated
+      ObjCNameLookupCachePopulated : 1);
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,
     /// Is this an assignment operator?

include/swift/AST/DiagnosticsClangImporter.def

@@ -215,6 +215,8 @@ NOTE(invoked_func_not_imported, none, "function %0 not imported", (const clang::
 NOTE(record_method_not_imported, none, "method %0 not imported", (const clang::NamedDecl*))
 NOTE(objc_property_not_imported, none, "property %0 not imported", (const clang::NamedDecl*))
 
+NOTE(placeholder_for_forward_declared_interface_member_access_failure, none, "class '%0' will be imported as an opaque placeholder class and may be missing members; import the definition to access the complete interface", (StringRef))
+NOTE(placeholder_for_forward_declared_protocol_member_access_failure, none, "protocol '%0' will be imported as an opaque placeholder protocol and may be missing members; import the definition to access the complete protocol", (StringRef))
 NOTE(forward_declared_interface_label, none, "interface %0 forward declared here", (const clang::NamedDecl*))
 NOTE(forward_declared_protocol_label, none, "protocol %0 forward declared here", (const clang::NamedDecl*))
 

include/swift/AST/Module.h

@@ -242,6 +242,8 @@ class ModuleDecl
   llvm::SmallDenseMap<Identifier, SmallVector<OverlayFile *, 1>>
     declaredCrossImports;
 
+  llvm::DenseMap<Identifier, SmallVector<Decl *, 2>> ObjCNameLookupCache;
+
   /// A description of what should be implicitly imported by each file of this
   /// module.
   const ImplicitImportInfo ImportInfo;
@@ -619,6 +621,14 @@ class ModuleDecl
     Bits.ModuleDecl.IsConcurrencyChecked = value;
   }
 
+  bool isObjCNameLookupCachePopulated() const {
+    return Bits.ModuleDecl.ObjCNameLookupCachePopulated;
+  }
+
+  void setIsObjCNameLookupCachePopulated(bool value) {
+    Bits.ModuleDecl.ObjCNameLookupCachePopulated = value;
+  }
+
   /// For the main module, retrieves the list of primary source files being
   /// compiled, that is, the files we're generating code for.
   ArrayRef<SourceFile *> getPrimarySourceFiles() const;
@@ -640,6 +650,12 @@ class ModuleDecl
   void lookupValue(DeclName Name, NLKind LookupKind,
                    SmallVectorImpl<ValueDecl*> &Result) const;
 
+  /// Look up a value just as ModuleDecl::lookupValue does, but provide the
+  /// Swift Module or SourceFile context from which the lookup is made.
+  void lookupValueWithContext(DeclName Name, NLKind LookupKind,
+                              SmallVectorImpl<ValueDecl *> &Result,
+                              const DeclContext *ImportingModuleOrFile) const;
+
   /// Look up a local type declaration by its mangled name.
   ///
   /// This does a simple local lookup, not recursively looking through imports.
@@ -656,6 +672,24 @@ class ModuleDecl
                           VisibleDeclConsumer &Consumer,
                           NLKind LookupKind) const;
 
+private:
+  void populateObjCNameLookupCache();
+
+public:
+  /// Finds top-levels decls of this module by @objc provided name.
+  /// Decls that have no @objc attribute are not considered.
+  ///
+  /// This does a simple local lookup, not recursively looking through imports.
+  /// The order of the resutls is not guaranteed to be meaningful.
+  ///
+  /// \param Results Vector collecting the decls.
+  ///
+  /// \param name The @objc simple name to look for. Declarations with matching
+  /// name and "anonymous" @objc attribute, as well a matching named @objc
+  /// attribute will be added to Results.
+  void lookupTopLevelDeclsByObjCName(SmallVectorImpl<Decl *> &Results,
+                                     DeclName name);
+
   /// This is a hack for 'main' file parsing and the integrated REPL.
   ///
   /// FIXME: Refactor main file parsing to not pump the parser incrementally.

include/swift/ClangImporter/ClangModule.h

@@ -68,6 +68,10 @@ class ClangModuleUnit final : public LoadedFile {
   virtual void lookupValue(DeclName name, NLKind lookupKind,
                            SmallVectorImpl<ValueDecl*> &results) const override;
 
+  void lookupValueWithContext(DeclName name, NLKind lookupKind,
+                              SmallVectorImpl<ValueDecl *> &results,
+                              const DeclContext *importingModuleOrFile) const;
+
   virtual TypeDecl *
   lookupNestedType(Identifier name,
                    const NominalTypeDecl *baseType) const override;

include/swift/Option/FrontendOptions.td

@@ -304,6 +304,10 @@ def enable_experimental_eager_clang_module_diagnostics :
   Flag<["-"], "enable-experimental-eager-clang-module-diagnostics">,
   HelpText<"Enable experimental eager diagnostics reporting on the importability of all referenced C, C++, and Objective-C libraries">;
 
+def enable_import_objc_forward_declarations :
+  Flag<["-"], "enable-import-objc-forward-declarations">,
+  HelpText<"Attempt to import Objective-C forward declarations">;
+
 def enable_experimental_pairwise_build_block :
   Flag<["-"], "enable-experimental-pairwise-build-block">,
   HelpText<"Enable experimental pairwise 'buildBlock' for result builders">;

lib/AST/Module.cpp

@@ -43,6 +43,7 @@
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Demangling/ManglingMacros.h"
 #include "swift/Parse/Token.h"
 #include "swift/Strings.h"
@@ -57,8 +58,8 @@
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SaveAndRestore.h"
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/YAMLTraits.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
 
@@ -737,6 +738,30 @@ void ModuleDecl::lookupValue(DeclName Name, NLKind LookupKind,
   FORWARD(lookupValue, (Name, LookupKind, Result));
 }
 
+void ModuleDecl::lookupValueWithContext(
+    DeclName Name, NLKind LookupKind, SmallVectorImpl<ValueDecl *> &Result,
+    const DeclContext *ImportingModuleOrFile) const {
+  if (isParsedModule(this)) {
+    getSourceLookupCache().lookupValue(Name, LookupKind, Result);
+    return;
+  }
+
+  for (const FileUnit *file : getFiles()) {
+    // At the time of writing, Clang module units are the only FileUnits
+    // that make use of the Context. If this changes, add appropriate calls
+    // below.
+    if (auto clangModuleUnit = dyn_cast<ClangModuleUnit>(file)) {
+      clangModuleUnit->lookupValueWithContext(Name, LookupKind, Result,
+                                              ImportingModuleOrFile);
+    } else {
+      file->lookupValue(Name, LookupKind, Result);
+    }
+    if (auto *synth = file->getSynthesizedFile()) {
+      synth->lookupValue(Name, LookupKind, Result);
+    }
+  }
+}
+
 TypeDecl * ModuleDecl::lookupLocalType(StringRef MangledName) const {
   for (auto file : getFiles()) {
     auto TD = file->lookupLocalType(MangledName);
@@ -1024,6 +1049,53 @@ void ModuleDecl::getTopLevelDeclsWhereAttributesMatch(
   FORWARD(getTopLevelDeclsWhereAttributesMatch, (Results, matchAttributes));
 }
 
+void ModuleDecl::lookupTopLevelDeclsByObjCName(SmallVectorImpl<Decl *> &Results,
+                                               DeclName name) {
+  if (!isObjCNameLookupCachePopulated())
+    populateObjCNameLookupCache();
+
+  if (name.isSpecial())
+    return;
+
+  auto resultsForFileUnit = ObjCNameLookupCache.find(name.getBaseIdentifier());
+  if (resultsForFileUnit == ObjCNameLookupCache.end())
+    return;
+
+  Results.append(resultsForFileUnit->second.begin(),
+                 resultsForFileUnit->second.end());
+}
+
+void ModuleDecl::populateObjCNameLookupCache() {
+  SmallVector<Decl *> topLevelObjCExposedDeclsInFileUnit;
+  auto hasObjCAttrNamePredicate = [](const DeclAttributes &attrs) -> bool {
+    return attrs.hasAttribute<ObjCAttr>();
+  };
+
+  for (FileUnit *file : getFiles()) {
+    file->getTopLevelDeclsWhereAttributesMatch(
+        topLevelObjCExposedDeclsInFileUnit, hasObjCAttrNamePredicate);
+    if (auto *synth = file->getSynthesizedFile()) {
+      synth->getTopLevelDeclsWhereAttributesMatch(
+          topLevelObjCExposedDeclsInFileUnit, hasObjCAttrNamePredicate);
+    }
+  }
+
+  for (Decl *decl : topLevelObjCExposedDeclsInFileUnit) {
+    if (ValueDecl *VD = dyn_cast<ValueDecl>(decl)) {
+      if (VD->hasName()) {
+        const auto &declObjCAttribute = VD->getAttrs().getAttribute<ObjCAttr>();
+        const Identifier &declObjCName =
+            declObjCAttribute->hasName()
+                ? declObjCAttribute->getName()->getSimpleName()
+                : VD->getName().getBaseIdentifier();
+        ObjCNameLookupCache[declObjCName].push_back(decl);
+      }
+    }
+  }
+
+  setIsObjCNameLookupCachePopulated(true);
+}
+
 void SourceFile::getTopLevelDecls(SmallVectorImpl<Decl*> &Results) const {
   auto decls = getTopLevelDecls();
   Results.append(decls.begin(), decls.end());

lib/AST/ModuleNameLookup.cpp

@@ -81,12 +81,14 @@ class LookupByName : public ModuleNameLookup<LookupByName> {
   }
 
   void doLocalLookup(ModuleDecl *module, ImportPath::Access path,
-                     SmallVectorImpl<ValueDecl *> &localDecls) {
+                     SmallVectorImpl<ValueDecl *> &localDecls,
+                     const DeclContext *importingModuleOrFile) {
     // If this import is specific to some named decl ("import Swift.Int")
     // then filter out any lookups that don't match.
     if (!path.matches(name))
       return;
-    module->lookupValue(name, lookupKind, localDecls);
+    module->lookupValueWithContext(name, lookupKind, localDecls,
+                                   importingModuleOrFile);
   }
 };
 
@@ -112,7 +114,8 @@ class LookupVisibleDecls : public ModuleNameLookup<LookupVisibleDecls> {
   }
 
   void doLocalLookup(ModuleDecl *module, ImportPath::Access path,
-                     SmallVectorImpl<ValueDecl *> &localDecls) {
+                     SmallVectorImpl<ValueDecl *> &localDecls,
+                     const DeclContext *importingModuleOrFile) {
     VectorDeclConsumer consumer(localDecls);
     module->lookupVisibleDecls(path, consumer, lookupKind);
   }
@@ -169,7 +172,7 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
 
   // Do the lookup into the current module.
   auto *module = moduleOrFile->getParentModule();
-  getDerived()->doLocalLookup(module, accessPath, decls);
+  getDerived()->doLocalLookup(module, accessPath, decls, moduleOrFile);
   updateNewDecls(moduleScopeContext);
 
   bool canReturnEarly = (initialCount != decls.size() &&
@@ -198,7 +201,7 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
         return;
 
       getDerived()->doLocalLookup(import.importedModule, import.accessPath,
-                                  decls);
+                                  decls, moduleOrFile);
       updateNewDecls(moduleScopeContext);
     };