[ClangImporter] Add clang module imports to Swift wrapper module

When macros like _SwiftifyImport are added to a wrapper module for a
clang module, they may need to refer to symbols declared in another
clang module that the wrapped module imports (e.g. because they are used
in the original signature). This adds all the imported clang modules as
implicit imports to the wrapper module.

rdar://151611573

Author: hnrklssn

include/swift/Subsystems.h

@@ -125,9 +125,7 @@ namespace swift {
 
   /// Resolve imports for a source file generated to adapt a given
   /// Clang module.
-  void performImportResolutionForClangMacroBuffer(
-    SourceFile &SF, ModuleDecl *clangModule
-  );
+  void performImportResolutionForClangMacroBuffer(SourceFile &SF);
 
   /// Once type-checking is complete, this instruments code with calls to an
   /// intrinsic that record the expected values of local variables so they can

lib/ClangImporter/ClangImporter.cpp

@@ -2829,6 +2829,14 @@ ClangModuleUnit *ClangImporter::Implementation::getWrapperForModule(
   if (auto mainModule = SwiftContext.MainModule) {
     implicitImportInfo = mainModule->getImplicitImportInfo();
   }
+  for (auto *I : underlying->Imports) {
+    // Make sure that synthesized Swift code in the clang module wrapper
+    // (e.g. _SwiftifyImport macro expansions) can access the same symbols as
+    // if it were actually in the clang module
+    ImportPath::Builder importPath(SwiftContext, I->getFullModuleName(), '.');
+    UnloadedImportedModule importedModule(importPath.copyTo(SwiftContext), ImportKind::Module);
+    implicitImportInfo.AdditionalUnloadedImports.push_back(importedModule);
+  }
   ClangModuleUnit *file = nullptr;
   auto wrapper = ModuleDecl::create(name, SwiftContext, implicitImportInfo,
                                     [&](ModuleDecl *wrapper, auto addFile) {

lib/Sema/ImportResolution.cpp

@@ -319,15 +319,14 @@ void swift::performImportResolution(SourceFile &SF) {
   verify(SF);
 }
 
-void swift::performImportResolutionForClangMacroBuffer(
-    SourceFile &SF, ModuleDecl *clangModule
-) {
+void swift::performImportResolutionForClangMacroBuffer(SourceFile &SF) {
   // If we've already performed import resolution, bail.
   if (SF.ASTStage == SourceFile::ImportsResolved)
     return;
 
+  // `getWrapperForModule` has already declared all the implicit clang module
+  // imports we need
   ImportResolver resolver(SF);
-  resolver.addImplicitImport(clangModule);
 
   // FIXME: This is a hack that we shouldn't need, but be sure that we can
   // see the Swift standard library.

lib/Sema/TypeCheckMacros.cpp

@@ -1059,10 +1059,8 @@ createMacroSourceFile(std::unique_ptr<llvm::MemoryBuffer> buffer,
       /*parsingOpts=*/{}, /*isPrimary=*/false);
   if (auto parentSourceFile = dc->getParentSourceFile())
     macroSourceFile->setImports(parentSourceFile->getImports());
-  else if (auto clangModuleUnit =
-               dyn_cast<ClangModuleUnit>(dc->getModuleScopeContext())) {
-    auto clangModule = clangModuleUnit->getParentModule();
-    performImportResolutionForClangMacroBuffer(*macroSourceFile, clangModule);
+  else if (isa<ClangModuleUnit>(dc->getModuleScopeContext())) {
+    performImportResolutionForClangMacroBuffer(*macroSourceFile);
   }
   return macroSourceFile;
 }

test/Interop/C/swiftify-import/Inputs/TransitiveModules/module-a.h

@@ -0,0 +1,3 @@
+#pragma once
+
+typedef int a_t;

test/Interop/C/swiftify-import/Inputs/TransitiveModules/module-b.h

@@ -0,0 +1,3 @@
+#pragma once
+
+typedef int b_t;

test/Interop/C/swiftify-import/Inputs/TransitiveModules/module-c.h

@@ -0,0 +1,2 @@
+#pragma once
+typedef int c_t;

test/Interop/C/swiftify-import/Inputs/TransitiveModules/module-d.h

@@ -0,0 +1,2 @@
+#pragma once
+typedef int d_t;

test/Interop/C/swiftify-import/Inputs/TransitiveModules/module-e.h

@@ -0,0 +1,2 @@
+#pragma once
+typedef int e_t;

test/Interop/C/swiftify-import/Inputs/TransitiveModules/module.modulemap

@@ -0,0 +1,24 @@
+module ModuleA {
+    header "module-a.h"
+    export *
+}
+module ModuleB {
+    header "module-b.h"
+}
+module ModuleOuter {
+    module ModuleC {
+        header "module-c.h"
+        export *
+    }
+    explicit module ModuleD {
+         header "module-d.h"
+         export *
+    }
+}
+module ModuleDeep {
+    module ModuleDeepNested {
+        module ModuleDeepNestedNested {
+            header "module-e.h"
+        }
+    }
+}