[cxx-interop] Modularize __msvc_bit_utils on Windows

`__msvc_bit_utils.hpp` was added in a recent version of MSVC, and it is causing build errors for SwiftCompilerSources:
```
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.39.33519\include\numeric:598:12: error: function '_Select_countr_zero_impl<unsigned long long, (lambda at C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.39.33519\include\numeric:598:55)>' with deduced return type cannot be used before it is defined
    return _Select_countr_zero_impl<_Common_unsigned>([=](auto _Countr_zero_impl) {
```

This change references the `__msvc_bit_utils.hpp` header from the modulemap. Since we still need to support older versions of Visual Studio that do not provide `__msvc_bit_utils.hpp`, this also teaches ClangImporter to inject an empty header file named `__msvc_bit_utils.hpp` into the system include directory, unless it already exists.

rdar://137066642

(cherry picked from commit 16e7cbe)

Author: egorzhdan

lib/ClangImporter/ClangIncludePaths.cpp

@@ -414,17 +414,16 @@ GetWindowsAuxiliaryFile(StringRef modulemap, const SearchPathOptions &Options) {
   return "";
 }
 
-SmallVector<std::pair<std::string, std::string>, 2> GetWindowsFileMappings(
-    ASTContext &Context,
+void GetWindowsFileMappings(
+    ClangInvocationFileMapping &fileMapping, ASTContext &Context,
     const llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &driverVFS,
     bool &requiresBuiltinHeadersInSystemModules) {
   const llvm::Triple &Triple = Context.LangOpts.Target;
   const SearchPathOptions &SearchPathOpts = Context.SearchPathOpts;
-  SmallVector<std::pair<std::string, std::string>, 2> Mappings;
   std::string AuxiliaryFile;
 
   if (!Triple.isWindowsMSVCEnvironment())
-    return Mappings;
+    return;
 
   clang::driver::Driver Driver = createClangDriver(Context, driverVFS);
   const llvm::opt::InputArgList Args = createClangArgs(Context, Driver);
@@ -450,7 +449,8 @@ SmallVector<std::pair<std::string, std::string>, 2> GetWindowsFileMappings(
 
     AuxiliaryFile = GetWindowsAuxiliaryFile("winsdk.modulemap", SearchPathOpts);
     if (!AuxiliaryFile.empty())
-      Mappings.emplace_back(std::string(WinSDKInjection), AuxiliaryFile);
+      fileMapping.redirectedFiles.emplace_back(std::string(WinSDKInjection),
+                                               AuxiliaryFile);
   }
 
   struct {
@@ -477,7 +477,8 @@ SmallVector<std::pair<std::string, std::string>, 2> GetWindowsFileMappings(
       // cycle goes away. Note that -fbuiltin-headers-in-system-modules does
       // nothing to fix the same problem with C++ headers, and is generally
       // fragile.
-      Mappings.emplace_back(std::string(UCRTInjection), AuxiliaryFile);
+      fileMapping.redirectedFiles.emplace_back(std::string(UCRTInjection),
+                                               AuxiliaryFile);
       requiresBuiltinHeadersInSystemModules = true;
     }
   }
@@ -503,17 +504,27 @@ SmallVector<std::pair<std::string, std::string>, 2> GetWindowsFileMappings(
     AuxiliaryFile =
         GetWindowsAuxiliaryFile("vcruntime.modulemap", SearchPathOpts);
     if (!AuxiliaryFile.empty())
-      Mappings.emplace_back(std::string(VCToolsInjection), AuxiliaryFile);
+      fileMapping.redirectedFiles.emplace_back(std::string(VCToolsInjection),
+                                               AuxiliaryFile);
 
     llvm::sys::path::remove_filename(VCToolsInjection);
     llvm::sys::path::append(VCToolsInjection, "vcruntime.apinotes");
     AuxiliaryFile =
         GetWindowsAuxiliaryFile("vcruntime.apinotes", SearchPathOpts);
     if (!AuxiliaryFile.empty())
-      Mappings.emplace_back(std::string(VCToolsInjection), AuxiliaryFile);
-  }
+      fileMapping.redirectedFiles.emplace_back(std::string(VCToolsInjection),
+                                               AuxiliaryFile);
 
-  return Mappings;
+    // __msvc_bit_utils.hpp was added in a recent VS 2022 version. It has to be
+    // referenced from the modulemap directly to avoid modularization errors.
+    // Older VS versions might not have it. Let's inject an empty header file if
+    // it isn't available.
+    llvm::sys::path::remove_filename(VCToolsInjection);
+    llvm::sys::path::append(VCToolsInjection, "__msvc_bit_utils.hpp");
+    if (!llvm::sys::fs::exists(VCToolsInjection))
+      fileMapping.overridenFiles.emplace_back(std::string(VCToolsInjection),
+                                              "");
+  }
 }
 } // namespace
 
@@ -573,8 +584,7 @@ ClangInvocationFileMapping swift::getClangInvocationFileMapping(
   if (ctx.LangOpts.EnableCXXInterop)
     getLibStdCxxFileMapping(result, ctx, vfs);
 
-  result.redirectedFiles.append(GetWindowsFileMappings(
-      ctx, vfs, result.requiresBuiltinHeadersInSystemModules));
-
+  GetWindowsFileMappings(result, ctx, vfs,
+                         result.requiresBuiltinHeadersInSystemModules);
   return result;
 }

stdlib/public/Platform/vcruntime.modulemap

@@ -702,6 +702,11 @@ module std [system] {
   module _Private [system] {
     requires cplusplus
 
+    explicit module __msvc_bit_utils {
+      header "__msvc_bit_utils.hpp"
+      export *
+    }
+
     explicit module xhash {
       header "xhash"
       export *

test/Interop/Cxx/stdlib/Inputs/module.modulemap

@@ -1,3 +1,9 @@
+module StdNumeric {
+  header "std-numeric.h"
+  requires cplusplus
+  export *
+}
+
 module StdVector {
   header "std-vector.h"
   requires cplusplus

test/Interop/Cxx/stdlib/Inputs/std-numeric.h

@@ -0,0 +1,5 @@
+#include <numeric>
+
+inline int64_t getGCD(int64_t a, int64_t b) {
+  return std::gcd(a, b);
+}

test/Interop/Cxx/stdlib/use-std-numeric-typechecker.swift

@@ -0,0 +1,6 @@
+// RUN: %target-typecheck-verify-swift -I %S/Inputs -cxx-interoperability-mode=upcoming-swift -Xcc -std=c++17
+// RUN: %target-typecheck-verify-swift -I %S/Inputs -cxx-interoperability-mode=upcoming-swift -Xcc -std=c++20
+
+import StdNumeric
+
+let _ = getGCD(12, 15)