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/ASTContext.h

@@ -353,6 +353,8 @@ class ASTContext final {
       llvm::SmallPtrSet<DerivativeAttr *, 1>>
       DerivativeAttrs;
 
+  ModuleDecl *MainModule = nullptr;
+
 private:
   /// The current generation number, which reflects the number of
   /// times that external modules have been loaded.

include/swift/AST/Decl.h

@@ -633,7 +633,7 @@ 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,
+  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,
 
@@ -679,7 +679,11 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 
     /// Whether this module has been compiled with comprehensive checking for
     /// concurrency, e.g., Sendable checking.
-    IsConcurrencyChecked : 1
+    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,

include/swift/AST/DiagnosticsClangImporter.def

@@ -215,8 +215,27 @@ 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(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*))
+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*))
+
+NOTE(forward_declared_interface_clashes_with_imported_objc_Swift_interface, none,
+     "interface %0 is incomplete and cannot be imported as a stub; "
+     "its name conflicts with a %1 in module %2",
+     (const clang::NamedDecl*, StringRef, StringRef))
+NOTE(forward_declared_protocol_clashes_with_imported_objc_Swift_protocol, none,
+     "protocol %0 is incomplete and cannot be imported as a stub; "
+     "its name conflicts with a %1 in module %2",
+     (const clang::NamedDecl*, StringRef, StringRef))
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/Module.h

@@ -246,6 +246,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;
@@ -629,6 +631,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;
@@ -666,6 +676,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 results 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/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

@@ -491,6 +491,7 @@ ModuleDecl::ModuleDecl(Identifier name, ASTContext &ctx,
   Bits.ModuleDecl.HasIncrementalInfo = 0;
   Bits.ModuleDecl.HasHermeticSealAtLink = 0;
   Bits.ModuleDecl.IsConcurrencyChecked = 0;
+  Bits.ModuleDecl.ObjCNameLookupCachePopulated = 0;
 }
 
 ImplicitImportList ModuleDecl::getImplicitImports() const {
@@ -1055,6 +1056,62 @@ void ModuleDecl::getTopLevelDeclsWhereAttributesMatch(
   FORWARD(getTopLevelDeclsWhereAttributesMatch, (Results, matchAttributes));
 }
 
+void ModuleDecl::lookupTopLevelDeclsByObjCName(SmallVectorImpl<Decl *> &Results,
+                                               DeclName name) {
+  if (!isObjCNameLookupCachePopulated())
+    populateObjCNameLookupCache();
+
+  // A top level decl can't be special anyways
+  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>();
+        // No top level decl (class, protocol, extension etc.) is allowed to have a
+        // compound name, @objc provided or otherwise. Global functions are allowed to
+        // have compound names, but not allowed to have @objc attributes. Thus we
+        // are sure to not hit asserts getting the simple name.
+        //
+        // Similarly, init, dealloc and subscript (the special names) can't be top 
+        // level decls, so we won't hit asserts getting the base identifier out of the
+        // value decl.
+        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());
@@ -3188,6 +3245,9 @@ bool SourceFile::shouldCrossImport() const {
 void ModuleDecl::clearLookupCache() {
   getASTContext().getImportCache().clear();
 
+  setIsObjCNameLookupCachePopulated(false);
+  ObjCNameLookupCache.clear();
+
   if (!Cache)
     return;
 

lib/ClangImporter/ClangImporter.cpp

@@ -6200,7 +6200,15 @@ void ClangImporter::diagnoseTopLevelValue(const DeclName &name) {
 
 void ClangImporter::diagnoseMemberValue(const DeclName &name,
                                         const Type &baseType) {
-  if (!baseType->getAnyNominal())
+
+  // Return early for any type that namelookup::extractDirectlyReferencedNominalTypes
+  // does not know how to handle.
+  if (!(baseType->getAnyNominal() ||
+        baseType->is<ExistentialType>() ||
+        baseType->is<UnboundGenericType>() ||
+        baseType->is<ArchetypeType>() ||
+        baseType->is<ProtocolCompositionType>() ||
+        baseType->is<TupleType>()))
     return;
 
   SmallVector<NominalTypeDecl *, 4> nominalTypesToLookInto;
@@ -6212,6 +6220,45 @@ void ClangImporter::diagnoseMemberValue(const DeclName &name,
       Impl.diagnoseMemberValue(name,
                                cast<clang::DeclContext>(clangContainerDecl));
     }
+
+    if (Impl.ImportForwardDeclarations) {
+      const clang::Decl *clangContainerDecl = containerDecl->getClangDecl();
+      if (const clang::ObjCInterfaceDecl *objCInterfaceDecl =
+              llvm::dyn_cast_or_null<clang::ObjCInterfaceDecl>(
+                  clangContainerDecl)) {
+        if (!objCInterfaceDecl->hasDefinition()) {
+          // Emit a diagnostic about how the base type represents a forward
+          // declared ObjC interface and is in all likelihood missing members.
+          // We only attach this diagnostic in diagnoseMemberValue rather than
+          // in SwiftDeclConverter because it is only relevant when the user
+          // tries to access an unavailable member.
+          Impl.addImportDiagnostic(
+              objCInterfaceDecl,
+              Diagnostic(
+                  diag::
+                      placeholder_for_forward_declared_interface_member_access_failure,
+                  objCInterfaceDecl->getName()),
+              objCInterfaceDecl->getSourceRange().getBegin());
+          // Emit any diagnostics attached to the source Clang node (ie. forward
+          // declaration here note)
+          Impl.diagnoseTargetDirectly(clangContainerDecl);
+        }
+      } else if (const clang::ObjCProtocolDecl *objCProtocolDecl =
+                     llvm::dyn_cast_or_null<clang::ObjCProtocolDecl>(
+                         clangContainerDecl)) {
+        if (!objCProtocolDecl->hasDefinition()) {
+          // Same as above but for protocols
+          Impl.addImportDiagnostic(
+              objCProtocolDecl,
+              Diagnostic(
+                  diag::
+                      placeholder_for_forward_declared_protocol_member_access_failure,
+                  objCProtocolDecl->getName()),
+              objCProtocolDecl->getSourceRange().getBegin());
+          Impl.diagnoseTargetDirectly(clangContainerDecl);
+        }
+      }
+    }
   }
 }