handle libc++ v17-19

libc++ v17-19 was split into multiple top-level modules, while versions
earlier and later had one TLM with submodules.

Author: hnrklssn

include/swift/ClangImporter/ClangImporter.h

@@ -702,12 +702,6 @@ bool isCxxStdModule(const clang::Module *module);
 /// (std_vector, std_iosfwd, etc).
 bool isCxxStdModule(StringRef moduleName, bool IsSystem);
 
-/// Build the path corresponding to the Swift wrapper for a clang module.
-/// Returns ImportPath::Builder to leave control over if and where to clone the
-/// path to the caller.
-ImportPath::Builder getSwiftModulePath(ASTContext &SwiftContext,
-                                       const clang::Module *M);
-
 /// Returns the pointee type if the given type is a C++ `const`
 /// reference type, `None` otherwise.
 std::optional<clang::QualType>

lib/ClangImporter/ClangImporter.cpp

@@ -3805,7 +3805,23 @@ ImportDecl *swift::createImportDecl(ASTContext &Ctx,
   auto *ImportedMod = ClangN.getClangModule();
   assert(ImportedMod);
 
-  ImportPath::Builder importPath = getSwiftModulePath(Ctx, ImportedMod);
+  ImportPath::Builder importPath;
+  auto *TmpMod = ImportedMod;
+  while (TmpMod) {
+    // If this is a C++ stdlib module, print its name as `CxxStdlib` instead of
+    // `std`. `CxxStdlib` is the only accepted spelling of the C++ stdlib module
+    // name in Swift. In libc++ versions 17-19 there are multiple TLMs, named
+    // std_vector, std_array etc. We don't support importing those modules, but
+    // when printing the module interface it'd be weird to print "import
+    // CxxStdlib" over and over, so those are still printed as "import
+    // std_vector". This only affects the module interface for CxxStdlib.
+    Identifier moduleName = !TmpMod->isSubModule() && TmpMod->Name == "std"
+                                ? Ctx.Id_CxxStdlib
+                                : Ctx.getIdentifier(TmpMod->Name);
+    importPath.push_back(moduleName);
+    TmpMod = TmpMod->Parent;
+  }
+  std::reverse(importPath.begin(), importPath.end());
 
   bool IsExported = false;
   for (auto *ExportedMod : Exported) {
@@ -4653,8 +4669,8 @@ void ClangModuleUnit::getImportedModulesForLookup(
     if (owner.SwiftContext.LangOpts.EnableCXXInterop && topLevel &&
         isCxxStdModule(topLevel) && wrapper->clangModule &&
         isCxxStdModule(wrapper->clangModule)) {
-      // The CxxStdlib overlay re-exports the clang module std, which in recent
-      // libc++ versions re-exports top-level modules for different std headers
+      // The CxxStdlib overlay re-exports the clang module std, which in libc++
+      // versions 17-19 re-exports top-level modules for different std headers
       // (std_string, std_vector, etc). The overlay module for each of the std
       // modules is the CxxStdlib module itself. Make sure we return the actual
       // clang modules (std_xyz) as transitive dependencies instead of just
@@ -8759,7 +8775,7 @@ bool importer::isCxxStdModule(const clang::Module *module) {
 bool importer::isCxxStdModule(StringRef moduleName, bool IsSystem) {
   if (moduleName == "std")
     return true;
-  // In recent libc++ versions the module is split into multiple top-level
+  // In libc++ versions 17-19 the module is split into multiple top-level
   // modules (std_vector, std_utility, etc).
   if (IsSystem && moduleName.starts_with("std_")) {
     if (moduleName == "std_errno_h")
@@ -8769,7 +8785,7 @@ bool importer::isCxxStdModule(StringRef moduleName, bool IsSystem) {
   return false;
 }
 
-ImportPath::Builder importer::getSwiftModulePath(ASTContext &SwiftContext, const clang::Module *M) {
+ImportPath::Builder ClangImporter::Implementation::getSwiftModulePath(const clang::Module *M) {
   ImportPath::Builder builder;
   while (M) {
     if (!M->isSubModule() && isCxxStdModule(M))
@@ -8782,10 +8798,6 @@ ImportPath::Builder importer::getSwiftModulePath(ASTContext &SwiftContext, const
   return builder;
 }
 
-ImportPath::Builder ClangImporter::Implementation::getSwiftModulePath(const clang::Module *M) {
-  return ::getSwiftModulePath(SwiftContext, M);
-}
-
 std::optional<clang::QualType>
 importer::getCxxReferencePointeeTypeOrNone(const clang::Type *type) {
   if (type->isReferenceType())

test/Interop/Cxx/stdlib/Inputs/check-libcxx-version.cpp

@@ -6,7 +6,9 @@ int main() {
   return 1;
 #endif
 
-#if _LIBCPP_VERSION >= 170004
+  // the libc++ module was split into multiple top-level modules in Clang 17,
+  // and then re-merged into one module with submodules in Clang 20
+#if _LIBCPP_VERSION >= 170004 && _LIBCPP_VERSION < 200000
   return 0;
 #else
   return 1;

test/Interop/Cxx/stdlib/libcxx-module-interface.swift

@@ -1,4 +1,4 @@
-// Only run this test with older libc++, before the top-level std module got split into multiple top-level modules.
+// Don't run this test with libc++ versions 17-19, when the top-level std module was split into multiple top-level modules.
 // RUN: %empty-directory(%t)
 // RUN: %target-clangxx %S/Inputs/check-libcxx-version.cpp -o %t/check-libcxx-version
 // RUN: %target-codesign %t/check-libcxx-version

test/SourceKit/InterfaceGen/gen_clang_libcxx_sdk_module.swift

@@ -1,6 +1,19 @@
-// RUN: %sourcekitd-test -req=interface-gen -module CxxStdlib -- -Xfrontend -disable-implicit-concurrency-module-import -Xfrontend -disable-implicit-string-processing-module-import -cxx-interoperability-mode=default -target %target-triple -sdk %sdk | %FileCheck %s
+// RUN: %empty-directory(%t)
+// RUN: %target-clangxx %S/../../Interop/Cxx/stdlib/Inputs/check-libcxx-version.cpp -o %t/check-libcxx-version
+// RUN: %target-codesign %t/check-libcxx-version
+
+// Since this test runs check-libcxx-version, it requires execution.
+// REQUIRES: executable_test
+
+// RUN: %target-run %t/check-libcxx-version || %sourcekitd-test -req=interface-gen -module CxxStdlib -- -Xfrontend -disable-implicit-concurrency-module-import -Xfrontend -disable-implicit-string-processing-module-import -cxx-interoperability-mode=default -target %target-triple -sdk %sdk | %FileCheck %s --check-prefix CHECK-MONO
+// RUN: not %target-run %t/check-libcxx-version || %sourcekitd-test -req=interface-gen -module CxxStdlib -- -Xfrontend -disable-implicit-concurrency-module-import -Xfrontend -disable-implicit-string-processing-module-import -cxx-interoperability-mode=default -target %target-triple -sdk %sdk | %FileCheck %s --check-prefix CHECK-SPLIT
 
 // REQUIRES: OS=macosx
 
-// CHECK: import {{CxxStdlib.vector|std_vector}}
-// CHECK: extension std.basic_string<CChar, std.__1.char_traits<CChar>, std.__1.allocator<CChar>> {
+// CHECK-MONO-NOT: import CxxStdlib{{$}}
+// CHECK-MONO: import CxxStdlib.vector
+// CHECK-MONO: extension std.basic_string<CChar, std.__1.char_traits<CChar>, std.__1.allocator<CChar>> {
+
+// CHECK-SPLIT-NOT: import CxxStdlib{{$}}
+// CHECK-SPLIT: import std_vector
+// CHECK-SPLIT: extension std.basic_string<CChar, std.__1.char_traits<CChar>, std.__1.allocator<CChar>> {