[ClangImporter] Add submodules as implicit imports of wrapper module

Decls in Swift wrapper module may not originate in the top-level clang
module with the same name, since decls in clang submodules are dumped
into the top-level module. This is because Swift has no concept of
submodules. To make sure that any imported decl has access to the same
symbols as the original clang decl had, all transitive submodules, and
their imports, are added as implicit imports of the wrapper module. This
is necessary in the case where a submodule is marked `explicit`.

The content in explicit submodules isn't normally made visible when
importing the parent module. Decls from explicit submodules still
end up in the top-level wrapper module however, so in Swift they do
still need to be visible from the top-level module. This is relevant
for macro expansions, so that they can refer to the same types as the
original decl.

Author: hnrklssn

lib/ClangImporter/ClangImporter.cpp

@@ -2834,16 +2834,29 @@ 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
-    std::string swiftModuleName = isCxxStdModule(I) ?
-      static_cast<std::string>(SwiftContext.Id_CxxStdlib) :
-      I->getFullModuleName();
-    ImportPath::Builder importPath(SwiftContext, swiftModuleName, '.');
-    UnloadedImportedModule importedModule(importPath.copyTo(SwiftContext), ImportKind::Module);
-    implicitImportInfo.AdditionalUnloadedImports.push_back(importedModule);
+
+  // Decls in this Swift module may originate in the top-level clang module with the
+  // same name, since decls in clang submodules are dumped into the top-level module.
+  // Add all transitive submodules as implicit imports in case any of them are marked
+  // `explicit`. The content in explicit modules isn't normally made visible when
+  // importing the parent module, but in this case the parent module is all we have.
+  llvm::SmallVector<const clang::Module *, 32> SubmoduleWorklist;
+  SubmoduleWorklist.push_back(underlying);
+  while (!SubmoduleWorklist.empty()) {
+    const clang::Module *CurrModule = SubmoduleWorklist.pop_back_val();
+    for (auto *I : CurrModule->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, by copying the imports.
+      std::string swiftModuleName = isCxxStdModule(I) ?
+        static_cast<std::string>(SwiftContext.Id_CxxStdlib) :
+        I->getFullModuleName();
+      ImportPath::Builder importPath(SwiftContext, swiftModuleName, '.');
+      UnloadedImportedModule importedModule(importPath.copyTo(SwiftContext), ImportKind::Module);
+      implicitImportInfo.AdditionalUnloadedImports.push_back(importedModule);
+    }
+    for (auto *Submodule : CurrModule->submodules())
+      SubmoduleWorklist.push_back(Submodule);
   }
   ClangModuleUnit *file = nullptr;
   auto wrapper = ModuleDecl::create(name, SwiftContext, implicitImportInfo,

test/Interop/C/swiftify-import/clang-includes-explicit.swift

@@ -0,0 +1,57 @@
+// REQUIRES: swift_feature_SafeInteropWrappers
+
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend -emit-module -plugin-path %swift-plugin-dir -o %t/ClangIncludesExplicit.swiftmodule -I %t/Inputs -enable-experimental-feature SafeInteropWrappers %t/test.swift
+
+//--- test.swift
+import A1.B1.C1.D1
+
+public func callUnsafe(_ p: UnsafeMutableRawPointer) {
+  let _ = foo(p, 13)
+}
+
+public func callSafe(_ p: UnsafeMutableRawBufferPointer) {
+  let _ = foo(p)
+}
+
+//--- Inputs/module.modulemap
+module A1 {
+  explicit module B1 {
+    explicit module C1 {
+      explicit module D1 {
+        header "D1.h"
+      }
+    }
+  }
+}
+
+module A2 {
+ explicit module B2 {
+    header "B2.h"
+    export C2
+
+    explicit module C2 {
+      header "C2.h"
+    }
+  }
+}
+
+//--- Inputs/D1.h
+#pragma once
+
+#include "B2.h"
+#define __sized_by(s) __attribute__((__sized_by__(s)))
+
+c2_t foo(void * _Nonnull __sized_by(size), int size);
+
+//--- Inputs/B2.h
+#pragma once
+
+#include "C2.h"
+
+//--- Inputs/C2.h
+#pragma once
+
+typedef int c2_t;