[ClangImporter] Swift Implemented ObjC Forward Declarations

include/swift/AST/Module.h

@@ -640,6 +640,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 context from which the lookup is made.
+  void lookupValueWithContext(DeclName Name, NLKind LookupKind,
+                              SmallVectorImpl<ValueDecl *> &Result,
+                              const DeclContext *Context) const;
+
   /// Look up a local type declaration by its mangled name.
   ///
   /// This does a simple local lookup, not recursively looking through imports.

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 *context) const;
+
   virtual TypeDecl *
   lookupNestedType(Identifier name,
                    const NominalTypeDecl *baseType) const override;

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;
 
@@ -736,6 +737,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 *Context) 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,
+                                              Context);
+    } 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);

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 *callingContext) {
     // 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,
+                                   callingContext);
   }
 };
 
@@ -112,7 +114,8 @@ class LookupVisibleDecls : public ModuleNameLookup<LookupVisibleDecls> {
   }
 
   void doLocalLookup(ModuleDecl *module, ImportPath::Access path,
-                     SmallVectorImpl<ValueDecl *> &localDecls) {
+                     SmallVectorImpl<ValueDecl *> &localDecls,
+                     const DeclContext *callingContext) {
     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() &&
@@ -196,7 +199,7 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
         return;
 
       getDerived()->doLocalLookup(import.importedModule, import.accessPath,
-                                  decls);
+                                  decls, moduleOrFile);
       updateNewDecls(moduleScopeContext);
     };
 

lib/ClangImporter/ClangImporter.cpp

@@ -3286,6 +3286,12 @@ void ClangModuleUnit::getDisplayDecls(SmallVectorImpl<Decl*> &results, bool recu
 
 void ClangModuleUnit::lookupValue(DeclName name, NLKind lookupKind,
                                   SmallVectorImpl<ValueDecl*> &results) const {
+  lookupValueWithContext(name, lookupKind, results, nullptr);
+}
+
+void ClangModuleUnit::lookupValueWithContext(
+    DeclName name, NLKind lookupKind, SmallVectorImpl<ValueDecl *> &results,
+    const DeclContext *context) const {
   // FIXME: Ignore submodules, which are empty for now.
   if (clangModule && clangModule->isSubModule())
     return;
@@ -3305,7 +3311,13 @@ void ClangModuleUnit::lookupValue(DeclName name, NLKind lookupKind,
   // Find the corresponding lookup table.
   if (auto lookupTable = owner.findLookupTable(clangModule)) {
     // Search it.
-    owner.lookupValue(*lookupTable, name, *consumer);
+    if (context) {
+      owner.setImportingContext(*context);
+      owner.lookupValue(*lookupTable, name, *consumer);
+      owner.resetImportingContext();
+    } else {
+      owner.lookupValue(*lookupTable, name, *consumer);
+    }
   }
 }
 

lib/ClangImporter/ImportDecl.cpp

@@ -4298,19 +4298,21 @@ namespace {
         }
       }
 
-      if (!found) {
-        // Go back to the first list and find classes with matching Swift names
-        // *even if the ObjC name doesn't match.*
-        // This shouldn't be allowed but we need it for source compatibility;
-        // people used `@class SwiftNameOfClass` as a workaround for not
-        // having the previous loop, and it "worked".
-        for (auto result : swiftDeclsByName) {
-          if (auto singleResult = dyn_cast<T>(result)) {
-            if (isMatch(singleResult, /*baseNameMatches=*/true,
-                        /*allowObjCMismatch=*/true)) {
-              if (found)
-                return nullptr;
-              found = singleResult;
+      if (!languageVersion.isVersionAtLeast(6)) {
+        if (!found) {
+          // Go back to the first list and find classes with matching Swift
+          // names *even if the ObjC name doesn't match.* This shouldn't be
+          // allowed but we need it for source compatibility; people used
+          // `@class SwiftNameOfClass` as a workaround for not having the
+          // previous loop, and it "worked".
+          for (auto result : swiftDeclsByName) {
+            if (auto singleResult = dyn_cast<T>(result)) {
+              if (isMatch(singleResult, /*baseNameMatches=*/true,
+                          /*allowObjCMismatch=*/true)) {
+                if (found)
+                  return nullptr;
+                found = singleResult;
+              }
             }
           }
         }
@@ -4338,6 +4340,35 @@ namespace {
             return result;
         }
       }
+      if (auto importingContext = Impl.getImportingContext()) {
+        llvm::SmallVector<ValueDecl *> results;
+        llvm::SmallVector<ImportedModule> importedModules;
+
+        const ModuleDecl *importingSwiftModule =
+            importingContext.getValue()->getParentModule();
+
+        if (importingSwiftModule->isNonSwiftModule())
+          return nullptr;
+
+        const SourceFile *importingSwiftSourceFile =
+            importingContext.getValue()->getParentSourceFile();
+
+        // TODO: Make sure we aren't bailing early in legitimate cases
+        if (!importingSwiftSourceFile)
+          return nullptr;
+
+        importingSwiftSourceFile->getImportedModules(
+            importedModules, ModuleDecl::ImportFilterKind::Default);
+
+        for (auto &import : importedModules) {
+          if (import.importedModule->isNonSwiftModule())
+            continue;
+
+          if (T *result = resolveSwiftDeclImpl<T>(decl, name, hasKnownSwiftName,
+                                                  import.importedModule))
+            return result;
+        }
+      }
       return nullptr;
     }
 

lib/ClangImporter/ImporterImpl.h

@@ -528,6 +528,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// used when parsing the attribute text.
   llvm::SmallDenseMap<ModuleDecl *, SourceFile *> ClangSwiftAttrSourceFiles;
 
+  /// If set, the Swift DeclContext from which the current
+  /// import request was triggered.
+  llvm::Optional<const swift::DeclContext *> ImportingContext;
+
 public:
   /// The Swift lookup table for the bridging header.
   std::unique_ptr<SwiftLookupTable> BridgingHeaderLookupTable;
@@ -587,6 +591,16 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     return Instance.get();
   }
 
+  void setImportingContext(const DeclContext &importingContext) {
+    ImportingContext = &importingContext;
+  }
+
+  void resetImportingContext() { ImportingContext = None; }
+
+  llvm::Optional<const DeclContext *> getImportingContext() {
+    return ImportingContext;
+  }
+
 private:
   /// Generation number that is used for crude versioning.
   ///

test/ClangImporter/Inputs/custom-modules/IncompleteTypes/complete-swift-types.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+@objc public class Foo : NSObject {
+    @objc public func sayHello() {
+        print("Hello from Foo.sayHello!")
+    }
+}
+
+@objc(Baz) public class Bar : NSObject {
+    @objc public func sayHello() {
+        print("Hello from Bar.sayHello!")
+    }
+}

test/ClangImporter/Inputs/custom-modules/IncompleteTypes/module.modulemap

@@ -0,0 +1,3 @@
+module ObjCLibraryForwardDeclaringCompleteSwiftTypes {
+    header "objc-library-forward-declaring-complete-swift-types.h"
+}

test/ClangImporter/Inputs/custom-modules/IncompleteTypes/objc-library-forward-declaring-complete-swift-types.h

@@ -0,0 +1,8 @@
+@class Foo;
+@class Baz;
+
+void takeAFoo(Foo *foo);
+Foo *returnAFoo();
+
+void takeABaz(Baz *baz);
+Baz *returnABaz();

test/ClangImporter/Inputs/custom-modules/IncompleteTypes/objc-library-forward-declaring-complete-swift-types.m

@@ -0,0 +1,18 @@
+#import "objc-library-forward-declaring-complete-swift-types.h"
+#import "CompleteSwiftTypes-Swift.h"
+
+void takeAFoo(Foo *foo) { [foo sayHello]; }
+
+Foo *returnAFoo() {
+  Foo *result = [[Foo alloc] init];
+  [result sayHello];
+  return result;
+}
+
+void takeABaz(Baz *baz) { [baz sayHello]; }
+
+Baz *returnABaz() {
+  Baz *result = [[Baz alloc] init];
+  [result sayHello];
+  return result;
+}

test/ClangImporter/incomplete_objc_types_swift_definition_imported.swift

@@ -0,0 +1,26 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -parse-as-library %S/Inputs/custom-modules/IncompleteTypes/complete-swift-types.swift -emit-module -emit-module-path %t/CompleteSwiftTypes.swiftmodule -emit-objc-header -emit-objc-header-path %t/CompleteSwiftTypes-Swift.h -emit-library -o %t/libCompleteSwiftTypes.dylib
+// RUN: %target-clang -framework Foundation -dynamiclib %S/Inputs/custom-modules/IncompleteTypes/objc-library-forward-declaring-complete-swift-types.m -I %t -L %t -lCompleteSwiftTypes -o %t/libObjCLibraryForwardDeclaringCompleteSwiftTypes.dylib
+// RUN: %target-build-swift -Xfrontend -enable-objc-interop %s -I %S/Inputs/custom-modules/IncompleteTypes -I %t -L %t -lCompleteSwiftTypes -lObjCLibraryForwardDeclaringCompleteSwiftTypes -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import CompleteSwiftTypes
+import ObjCLibraryForwardDeclaringCompleteSwiftTypes
+
+// Swift initializers
+let foo = Foo()
+let bar = Bar()
+
+// Imported from Objective-C
+// CHECK: Hello from Foo.sayHello!
+takeAFoo(foo)
+// CHECK: Hello from Foo.sayHello!
+let foo2 = returnAFoo()
+
+// CHECK: Hello from Bar.sayHello!
+takeABaz(bar)
+// CHECK: Hello from Bar.sayHello!
+let bar2 = returnABaz()
+