[ClangImporter] Just turn off the warning, not the actual overlays.

We should still try adding the overlays, even if we're asked not to
generate a diagnostic while doing so.  That's slightly safer because
it means that we're less likely to find ourselves in a situation
where `swift-modulewrap` wants to use types from the C/C++ library
and can't.

rdar://115918181

Author: al45tair

include/swift/ClangImporter/ClangImporter.h

@@ -727,9 +727,13 @@ struct ClangInvocationFileMapping {
 /// On Linux, some platform libraries (glibc, libstdc++) are not modularized.
 /// We inject modulemaps for those libraries into their include directories
 /// to allow using them from Swift.
+///
+/// `suppressDiagnostic` prevents us from emitting warning messages when we
+/// are unable to find headers.
 ClangInvocationFileMapping getClangInvocationFileMapping(
     ASTContext &ctx,
-    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> vfs = nullptr);
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> vfs = nullptr,
+    bool suppressDiagnostic = false);
 
 } // end namespace swift
 

lib/ClangImporter/ClangImporter.cpp

@@ -1297,10 +1297,8 @@ ClangImporter::create(ASTContext &ctx,
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS =
       ctx.SourceMgr.getFileSystem();
 
-  ClangInvocationFileMapping fileMapping;
-
-  if (!ignoreFileMapping)
-    fileMapping = getClangInvocationFileMapping(ctx);
+  ClangInvocationFileMapping fileMapping =
+    getClangInvocationFileMapping(ctx, nullptr, ignoreFileMapping);
 
   // Avoid creating indirect file system when using include tree.
   if (!ctx.ClangImporterOpts.HasClangIncludeTreeRoot) {

lib/ClangImporter/ClangIncludePaths.cpp

@@ -189,7 +189,8 @@ ClangImporter::createClangArgs(const ClangImporterOptions &ClangImporterOpts,
 static SmallVector<std::pair<std::string, std::string>, 2>
 getLibcFileMapping(ASTContext &ctx, StringRef modulemapFileName,
                    std::optional<ArrayRef<StringRef>> maybeHeaderFileNames,
-                   const llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &vfs) {
+                   const llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &vfs,
+                   bool suppressDiagnostic) {
   const llvm::Triple &triple = ctx.LangOpts.Target;
 
   // Extract the libc path from Clang driver.
@@ -213,7 +214,8 @@ getLibcFileMapping(ASTContext &ctx, StringRef modulemapFileName,
           parsedIncludeArgs, {"inttypes.h", "unistd.h", "stdint.h"}, vfs)) {
     libcDir = dir.value();
   } else {
-    ctx.Diags.diagnose(SourceLoc(), diag::libc_not_found, triple.str());
+    if (!suppressDiagnostic)
+      ctx.Diags.diagnose(SourceLoc(), diag::libc_not_found, triple.str());
     return {};
   }
 
@@ -251,7 +253,8 @@ getLibcFileMapping(ASTContext &ctx, StringRef modulemapFileName,
 
 static void getLibStdCxxFileMapping(
     ClangInvocationFileMapping &fileMapping, ASTContext &ctx,
-    const llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &vfs) {
+    const llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &vfs,
+    bool suppressDiagnostic) {
   assert(ctx.LangOpts.EnableCXXInterop &&
          "libstdc++ is only injected if C++ interop is enabled");
 
@@ -286,7 +289,8 @@ static void getLibStdCxxFileMapping(
                                      {"cstdlib", "string", "vector"}, vfs)) {
     cxxStdlibDir = dir.value();
   } else {
-    ctx.Diags.diagnose(SourceLoc(), diag::libstdcxx_not_found, triple.str());
+    if (!suppressDiagnostic)
+      ctx.Diags.diagnose(SourceLoc(), diag::libstdcxx_not_found, triple.str());
     return;
   }
 
@@ -541,7 +545,8 @@ SmallVector<std::pair<std::string, std::string>, 2> GetWindowsFileMappings(
 } // namespace
 
 ClangInvocationFileMapping swift::getClangInvocationFileMapping(
-    ASTContext &ctx, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> vfs) {
+  ASTContext &ctx, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> vfs,
+  bool suppressDiagnostic) {
   ClangInvocationFileMapping result;
   if (!vfs)
     vfs = llvm::vfs::getRealFileSystem();
@@ -571,18 +576,21 @@ ClangInvocationFileMapping swift::getClangInvocationFileMapping(
   if (triple.isOSWASI()) {
     // WASI Mappings
     libcFileMapping =
-        getLibcFileMapping(ctx, "wasi-libc.modulemap", std::nullopt, vfs);
+      getLibcFileMapping(ctx, "wasi-libc.modulemap", std::nullopt, vfs,
+                         suppressDiagnostic);
 
     // WASI's module map needs fixing
     result.requiresBuiltinHeadersInSystemModules = true;
   } else if (triple.isMusl()) {
     libcFileMapping =
-        getLibcFileMapping(ctx, "musl.modulemap", StringRef("SwiftMusl.h"), vfs);
+      getLibcFileMapping(ctx, "musl.modulemap", StringRef("SwiftMusl.h"), vfs,
+                         suppressDiagnostic);
   } else if (triple.isAndroid()) {
     // Android uses the android-specific module map that overlays the NDK.
     StringRef headerFiles[] = {"SwiftAndroidNDK.h", "SwiftBionic.h"};
     libcFileMapping =
-        getLibcFileMapping(ctx, "android.modulemap", headerFiles, vfs);
+      getLibcFileMapping(ctx, "android.modulemap", headerFiles, vfs,
+                         suppressDiagnostic);
 
     if (!libcFileMapping.empty()) {
       sysroot = libcFileMapping[0].first;
@@ -592,15 +600,16 @@ ClangInvocationFileMapping swift::getClangInvocationFileMapping(
              triple.isOSFreeBSD()) {
     // BSD/Linux Mappings
     libcFileMapping = getLibcFileMapping(ctx, "glibc.modulemap",
-                                         StringRef("SwiftGlibc.h"), vfs);
+                                         StringRef("SwiftGlibc.h"), vfs,
+                                         suppressDiagnostic);
 
     // glibc.modulemap needs fixing
     result.requiresBuiltinHeadersInSystemModules = true;
   }
   result.redirectedFiles.append(libcFileMapping);
 
   if (ctx.LangOpts.EnableCXXInterop)
-    getLibStdCxxFileMapping(result, ctx, vfs);
+    getLibStdCxxFileMapping(result, ctx, vfs, suppressDiagnostic);
 
   result.redirectedFiles.append(GetWindowsFileMappings(
       ctx, vfs, result.requiresBuiltinHeadersInSystemModules));