[ScanDependency] Handle -Xcc options that affects module generation

Make sure the `-Xcc` options to the scanner are correctly considered
when creating ClangImporterCC1 arguments for constructed swift interface
compilation job.

Also cached the computed swift explicit module cc1 arguments so it
doesn't need to be computed every time for each swift interface job.

rdar://128873665

Author: cachemeifyoucan

include/swift/ClangImporter/ClangImporter.h

@@ -194,7 +194,7 @@ class ClangImporter final : public ClangModuleLoader {
   createClangInvocation(ClangImporter *importer,
                         const ClangImporterOptions &importerOpts,
                         llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
-                        std::vector<std::string> &CC1Args);
+                        const std::vector<std::string> &CC1Args);
 
   ClangImporter(const ClangImporter &) = delete;
   ClangImporter(ClangImporter &&) = delete;
@@ -517,7 +517,7 @@ class ClangImporter final : public ClangModuleLoader {
   std::string getClangModuleHash() const;
 
   /// Get clang import creation cc1 args for swift explicit module build.
-  std::vector<std::string> getSwiftExplicitModuleDirectCC1Args() const;
+  ArrayRef<std::string> getSwiftExplicitModuleDirectCC1Args() const;
 
   /// If we already imported a given decl successfully, return the corresponding
   /// Swift decl as an Optional<Decl *>, but if we previously tried and failed

lib/ClangImporter/ClangImporter.cpp

@@ -1216,7 +1216,7 @@ std::optional<std::vector<std::string>> ClangImporter::getClangCC1Arguments(
 std::unique_ptr<clang::CompilerInvocation> ClangImporter::createClangInvocation(
     ClangImporter *importer, const ClangImporterOptions &importerOpts,
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
-    std::vector<std::string> &CC1Args) {
+    const std::vector<std::string> &CC1Args) {
   std::vector<const char *> invocationArgs;
   invocationArgs.reserve(CC1Args.size());
   llvm::for_each(CC1Args, [&](const std::string &Arg) {
@@ -4064,8 +4064,11 @@ std::string ClangImporter::getClangModuleHash() const {
   return Impl.Invocation->getModuleHash(Impl.Instance->getDiagnostics());
 }
 
-std::vector<std::string>
+ArrayRef<std::string>
 ClangImporter::getSwiftExplicitModuleDirectCC1Args() const {
+  if (!Impl.SwiftExplicitModuleCC1Args.empty())
+    return Impl.SwiftExplicitModuleCC1Args;
+
   llvm::SmallVector<const char*> clangArgs;
   clangArgs.reserve(Impl.ClangArgs.size());
   llvm::for_each(Impl.ClangArgs, [&](const std::string &Arg) {
@@ -4081,8 +4084,10 @@ ClangImporter::getSwiftExplicitModuleDirectCC1Args() const {
   (void)success;
   assert(success && "clang options from clangImporter failed to parse");
 
-  if (!Impl.SwiftContext.CASOpts.EnableCaching)
-    return instance.getCC1CommandLine();
+  if (!Impl.SwiftContext.CASOpts.EnableCaching) {
+    Impl.SwiftExplicitModuleCC1Args = instance.getCC1CommandLine();
+    return Impl.SwiftExplicitModuleCC1Args;
+  }
 
   // Clear some options that are not needed.
   instance.clearImplicitModuleBuildOptions();
@@ -4121,7 +4126,8 @@ ClangImporter::getSwiftExplicitModuleDirectCC1Args() const {
     FSOpts.WorkingDir.clear();
   }
 
-  return instance.getCC1CommandLine();
+  Impl.SwiftExplicitModuleCC1Args = instance.getCC1CommandLine();
+  return Impl.SwiftExplicitModuleCC1Args;
 }
 
 std::optional<Decl *>

lib/ClangImporter/ImporterImpl.h

@@ -536,6 +536,9 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// Clang arguments used to create the Clang invocation.
   std::vector<std::string> ClangArgs;
 
+  /// Clang arguments used to create the ClangImporter for swift-frontend jobs.
+  std::vector<std::string> SwiftExplicitModuleCC1Args;
+
   /// Mapping from Clang swift_attr attribute text to the Swift source buffer
   /// IDs that contain that attribute text. These are re-used when parsing the
   /// Swift attributes on import.

lib/DependencyScan/ModuleDependencyScanner.cpp

@@ -378,7 +378,7 @@ ModuleDependencyScanner::getMainModuleDependencyInfo(ModuleDecl *mainModule) {
   std::vector<std::string> buildArgs;
   if (ScanASTContext.ClangImporterOpts.ClangImporterDirectCC1Scan) {
     buildArgs.push_back("-direct-clang-cc1-module-build");
-    for (auto &arg : clangImporter->getSwiftExplicitModuleDirectCC1Args()) {
+    for (auto arg : clangImporter->getSwiftExplicitModuleDirectCC1Args()) {
       buildArgs.push_back("-Xcc");
       buildArgs.push_back(arg);
     }

lib/Frontend/ModuleInterfaceLoader.cpp

@@ -1908,16 +1908,11 @@ InterfaceSubContextDelegateImpl::InterfaceSubContextDelegateImpl(
     // explicit Swift module build tasks will not rely on them and they may be
     // source-target-context-specific and hinder module sharing across
     // compilation source targets.
-    // If using DirectCC1Scan, the command-line reduction is handled inside
-    // `getSwiftExplicitModuleDirectCC1Args()`, there is no need to inherit
-    // anything here as the ExtraArgs from the invocation are clang driver
-    // options, not cc1 options.
     // Clang module dependecies of this Swift dependency will be distinguished
     // by their context hash for different variants, so would still cause a
     // difference in the Swift compile commands, when different.
-    if (!clangImporterOpts.ClangImporterDirectCC1Scan)
-      inheritedParentContextClangArgs =
-          clangImporterOpts.getReducedExtraArgsForSwiftModuleDependency();
+    inheritedParentContextClangArgs =
+        clangImporterOpts.getReducedExtraArgsForSwiftModuleDependency();
     genericSubInvocation.getFrontendOptions()
         .DependencyScanningSubInvocation = true;
   } else if (LoaderOpts.strictImplicitModuleContext ||

lib/Serialization/ScanningLoaders.cpp

@@ -185,7 +185,7 @@ SwiftModuleScanner::scanInterfaceFile(Twine moduleInterfacePath,
           Args.push_back("-direct-clang-cc1-module-build");
           auto *importer =
               static_cast<ClangImporter *>(Ctx.getClangModuleLoader());
-          for (auto &Arg : importer->getSwiftExplicitModuleDirectCC1Args()) {
+          for (auto Arg : importer->getSwiftExplicitModuleDirectCC1Args()) {
             Args.push_back("-Xcc");
             Args.push_back(Arg);
           }

test/CAS/Xcc_objc_direct.swift

@@ -0,0 +1,46 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend -scan-dependencies -module-name Test -module-cache-path %t/clang-module-cache -O \
+// RUN:   -disable-implicit-string-processing-module-import -disable-implicit-concurrency-module-import \
+// RUN:   %t/test.swift -o %t/deps.json -swift-version 5 -cache-compile-job -cas-path %t/cas -Xcc -fobjc-disable-direct-methods-for-testing \
+// RUN:   -I %t/include -module-load-mode prefer-serialized
+
+// RUN: %{python} %S/Inputs/BuildCommandExtractor.py %t/deps.json clang:SwiftShims > %t/shims.cmd
+// RUN: %swift_frontend_plain @%t/shims.cmd
+
+// RUN: %{python} %S/Inputs/BuildCommandExtractor.py %t/deps.json clang:B > %t/B.cmd
+// RUN: %swift_frontend_plain @%t/B.cmd
+
+// RUN: %{python} %S/Inputs/BuildCommandExtractor.py %t/deps.json A > %t/A.cmd
+// RUN: %swift_frontend_plain @%t/A.cmd
+
+// RUN: %{python} %S/Inputs/GenerateExplicitModuleMap.py %t/deps.json > %t/map.json
+// RUN: llvm-cas --cas %t/cas --make-blob --data %t/map.json > %t/map.casid
+
+// RUN: %{python} %S/Inputs/BuildCommandExtractor.py %t/deps.json Test > %t/MyApp.cmd
+
+// RUN: %target-swift-frontend \
+// RUN:   -typecheck -cache-compile-job -cas-path %t/cas \
+// RUN:   -swift-version 5 -disable-implicit-swift-modules \
+// RUN:   -disable-implicit-string-processing-module-import -disable-implicit-concurrency-module-import \
+// RUN:   -module-name Test -explicit-swift-module-map-file @%t/map.casid \
+// RUN:   %t/test.swift @%t/MyApp.cmd
+
+//--- test.swift
+private import A
+
+//--- include/A.swiftinterface
+// swift-interface-format-version: 1.0
+// swift-module-flags: -module-name A -O -disable-implicit-string-processing-module-import -disable-implicit-concurrency-module-import -parse-stdlib -user-module-version 1.0
+import B
+public func a() {}
+
+//--- include/module.modulemap
+module B {
+  header "B.h"
+  export *
+}
+
+//--- include/B.h
+void b(void);