Merge pull request #67750 from artemcm/SeparateClangScannerCachePath

swift-ci · web-flow · commit fbfeb4fbfc0d · 2023-08-10T16:41:15.000-07:00
[Dependency Scanning] Separate module output path from Clang scanner's module cache
diff --git a/include/swift/AST/ModuleDependencies.h b/include/swift/AST/ModuleDependencies.h
@@ -945,6 +945,8 @@ class ModuleDependenciesCache {
   std::string mainScanModuleName;
   /// The context hash of the current scanning invocation
   std::string scannerContextHash;
+  /// The location of where the built modules will be output to
+  std::string moduleOutputPath;
   /// The Clang dependency scanner tool
   clang::tooling::dependencies::DependencyScanningTool clangScanningTool;
 
@@ -958,6 +960,7 @@ class ModuleDependenciesCache {
 public:
   ModuleDependenciesCache(SwiftDependencyScanningService &globalScanningService,
                           std::string mainScanModuleName,
+                          std::string moduleOutputPath,
                           std::string scanningContextHash);
   ModuleDependenciesCache(const ModuleDependenciesCache &) = delete;
   ModuleDependenciesCache &operator=(const ModuleDependenciesCache &) = delete;
@@ -980,6 +983,9 @@ class ModuleDependenciesCache {
   void addSeenClangModule(clang::tooling::dependencies::ModuleID newModule) {
     alreadySeenClangModules.insert(newModule);
   }
+  std::string getModuleOutputPath() {
+    return moduleOutputPath;
+  }
 
   /// Look for module dependencies for a module with the given name
   ///
diff --git a/include/swift/Basic/LangOptions.h b/include/swift/Basic/LangOptions.h
@@ -811,6 +811,9 @@ namespace swift {
     /// The module cache path which the Clang importer should use.
     std::string ModuleCachePath;
 
+    /// The Scanning module cache path which the Clang Dependency Scanner should use.
+    std::string ClangScannerModuleCachePath;
+
     /// Extra arguments which should be passed to the Clang importer.
     std::vector<std::string> ExtraArgs;
 
diff --git a/include/swift/Frontend/Frontend.h b/include/swift/Frontend/Frontend.h
@@ -168,10 +168,18 @@ class CompilerInvocation {
     ClangImporterOpts.ModuleCachePath = Path.str();
   }
 
+  void setClangScannerModuleCachePath(StringRef Path) {
+    ClangImporterOpts.ClangScannerModuleCachePath = Path.str();
+  }
+
   StringRef getClangModuleCachePath() const {
     return ClangImporterOpts.ModuleCachePath;
   }
 
+  StringRef getClangScannerModuleCachePath() const {
+    return ClangImporterOpts.ClangScannerModuleCachePath;
+  }
+
   void setImportSearchPaths(const std::vector<std::string> &Paths) {
     SearchPathOpts.setImportSearchPaths(Paths);
   }
diff --git a/include/swift/Frontend/FrontendOptions.h b/include/swift/Frontend/FrontendOptions.h
@@ -91,6 +91,10 @@ class FrontendOptions {
   /// binary module has already been built for use by the compiler.
   std::string PrebuiltModuleCachePath;
 
+  /// The path to output explicit module dependencies. Only relevant during
+  /// dependency scanning.
+  std::string ExplicitModulesOutputPath;
+
   /// The path to look in to find backup .swiftinterface files if those found
   /// from SDKs are failing.
   std::string BackupModuleInterfaceDir;
diff --git a/include/swift/Option/Options.td b/include/swift/Option/Options.td
@@ -456,7 +456,7 @@ def localization_path : Separate<["-"], "localization-path">,
 def module_cache_path : Separate<["-"], "module-cache-path">,
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild, ArgumentIsPath, SwiftAPIExtractOption,
          SwiftSymbolGraphExtractOption, SwiftAPIDigesterOption]>,
-  HelpText<"Specifies the Clang module cache path">;
+  HelpText<"Specifies the module cache path">;
 
 def enable_library_evolution : Flag<["-"], "enable-library-evolution">,
   Flags<[FrontendOption, ModuleInterfaceOption]>,
@@ -1838,6 +1838,9 @@ def cas_plugin_option: Separate<["-"], "cas-plugin-option">,
   Flags<[FrontendOption, NewDriverOnlyOption]>,
   HelpText<"Option pass to CAS Plugin">, MetaVarName<"<name>=<option>">;
 
+def clang_scanner_module_cache_path : Separate<["-"], "clang-scanner-module-cache-path">,
+  Flags<[FrontendOption, DoesNotAffectIncrementalBuild, ArgumentIsPath]>,
+  HelpText<"Specifies the Clang dependency scanner module cache path">;
 
 // END ONLY SUPPORTED IN NEW DRIVER
 
diff --git a/include/swift/Serialization/ModuleDependencyScanner.h b/include/swift/Serialization/ModuleDependencyScanner.h
@@ -41,7 +41,7 @@ namespace swift {
       InterfaceSubContextDelegate &astDelegate;
 
       /// Location where pre-built moduels are to be built into.
-      std::string moduleCachePath;
+      std::string moduleOutputPath;
 
       llvm::Optional<SwiftDependencyTracker> dependencyTracker;
 
@@ -51,13 +51,13 @@ namespace swift {
       ModuleDependencyScanner(
           ASTContext &ctx, ModuleLoadingMode LoadMode, Identifier moduleName,
           InterfaceSubContextDelegate &astDelegate,
+          StringRef moduleOutputPath,
           ScannerKind kind = MDS_plain,
           llvm::Optional<SwiftDependencyTracker> tracker = llvm::None)
           : SerializedModuleLoaderBase(ctx, nullptr, LoadMode,
                                        /*IgnoreSwiftSourceInfoFile=*/true),
             kind(kind), moduleName(moduleName), astDelegate(astDelegate),
-            moduleCachePath(getModuleCachePathFromClang(
-                ctx.getClangModuleLoader()->getClangInstance())),
+            moduleOutputPath(moduleOutputPath),
             dependencyTracker(tracker) {}
 
       std::error_code findModuleFilesInDirectory(
@@ -123,9 +123,10 @@ namespace swift {
           ASTContext &ctx, ModuleLoadingMode LoadMode, Identifier moduleName,
           StringRef PlaceholderDependencyModuleMap,
           InterfaceSubContextDelegate &astDelegate,
+          StringRef moduleOutputPath,
           llvm::Optional<SwiftDependencyTracker> tracker = llvm::None)
           : ModuleDependencyScanner(ctx, LoadMode, moduleName, astDelegate,
-                                    MDS_placeholder, tracker) {
+                                    moduleOutputPath, MDS_placeholder, tracker) {
 
         // FIXME: Find a better place for this map to live, to avoid
         // doing the parsing on every module.
diff --git a/lib/AST/ModuleDependencies.cpp b/lib/AST/ModuleDependencies.cpp
@@ -618,9 +618,11 @@ ModuleDependenciesCache::getDependencyReferencesMap(
 
 ModuleDependenciesCache::ModuleDependenciesCache(
     SwiftDependencyScanningService &globalScanningService,
-    std::string mainScanModuleName, std::string scannerContextHash)
+    std::string mainScanModuleName, std::string moduleOutputPath,
+    std::string scannerContextHash)
     : globalScanningService(globalScanningService),
       mainScanModuleName(mainScanModuleName),
+      moduleOutputPath(moduleOutputPath),
       scannerContextHash(scannerContextHash),
       clangScanningTool(*globalScanningService.ClangScanningService,
                         globalScanningService.getClangScanningFS()) {
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
@@ -667,7 +667,13 @@ importer::getNormalInvocationArguments(
   }
 
   const std::string &moduleCachePath = importerOpts.ModuleCachePath;
-  if (!moduleCachePath.empty() && !importerOpts.DisableImplicitClangModules) {
+  const std::string &scannerCachePath = importerOpts.ClangScannerModuleCachePath;
+  // If a scanner cache is specified, this must be a scanning action. Prefer this
+  // path for the Clang scanner to cache its Scanning PCMs.
+  if (!scannerCachePath.empty()) {
+    invocationArgStrs.push_back("-fmodules-cache-path=");
+    invocationArgStrs.back().append(scannerCachePath);
+  } else if (!moduleCachePath.empty() && !importerOpts.DisableImplicitClangModules) {
     invocationArgStrs.push_back("-fmodules-cache-path=");
     invocationArgStrs.back().append(moduleCachePath);
   }
diff --git a/lib/ClangImporter/ClangModuleDependencyScanner.cpp b/lib/ClangImporter/ClangModuleDependencyScanner.cpp
@@ -174,7 +174,7 @@ void ClangImporter::recordModuleDependencies(
 
     auto pcmPath = moduleCacheRelativeLookupModuleOutput(
         clangModuleDep.ID, ModuleOutputKind::ModuleFile,
-        getModuleCachePathFromClang(getClangInstance()));
+        cache.getModuleOutputPath());
     swiftArgs.push_back("-o");
     swiftArgs.push_back(pcmPath);
 
@@ -421,7 +421,7 @@ ClangImporter::getModuleDependencies(StringRef moduleName,
   }
   std::string workingDir = *optionalWorkingDir;
 
-  auto moduleCachePath = getModuleCachePathFromClang(getClangInstance());
+  auto moduleCachePath = cache.getModuleOutputPath();
   auto lookupModuleOutput =
       [moduleCachePath](const ModuleID &MID,
                         ModuleOutputKind MOK) -> std::string {
diff --git a/lib/DependencyScan/DependencyScanningTool.cpp b/lib/DependencyScan/DependencyScanningTool.cpp
@@ -131,9 +131,10 @@ DependencyScanningTool::getDependencies(
   auto Instance = std::move(*InstanceOrErr);
 
   // Local scan cache instance, wrapping the shared global cache.
-  ModuleDependenciesCache cache(*ScanningService,
-                                Instance->getMainModule()->getNameStr().str(),
-                                Instance->getInvocation().getModuleScanningHash());
+  ModuleDependenciesCache cache(
+      *ScanningService, Instance->getMainModule()->getNameStr().str(),
+      Instance->getInvocation().getFrontendOptions().ExplicitModulesOutputPath,
+      Instance->getInvocation().getModuleScanningHash());
   // Execute the scanning action, retrieving the in-memory result
   auto DependenciesOrErr = performModuleScan(*Instance.get(), cache);
   if (DependenciesOrErr.getError())
@@ -173,9 +174,10 @@ DependencyScanningTool::getDependencies(
   auto Instance = std::move(*InstanceOrErr);
 
   // Local scan cache instance, wrapping the shared global cache.
-  ModuleDependenciesCache cache(*ScanningService,
-                                Instance->getMainModule()->getNameStr().str(),
-                                Instance->getInvocation().getModuleScanningHash());
+  ModuleDependenciesCache cache(
+      *ScanningService, Instance->getMainModule()->getNameStr().str(),
+      Instance->getInvocation().getFrontendOptions().ExplicitModulesOutputPath,
+      Instance->getInvocation().getModuleScanningHash());
   auto BatchScanResults = performBatchModuleScan(
       *Instance.get(), cache, VersionedPCMInstanceCacheCache.get(),
       Saver, BatchInput);
diff --git a/lib/DependencyScan/ScanDependencies.cpp b/lib/DependencyScan/ScanDependencies.cpp
@@ -1626,9 +1626,13 @@ forEachBatchEntry(CompilerInstance &invocationInstance,
         return true;
       }
       auto mainModuleName = newInstance->getMainModule()->getNameStr();
-      auto scanContextHash = newInstance->getInvocation().getModuleScanningHash();
+      auto scanContextHash =
+          newInstance->getInvocation().getModuleScanningHash();
+      auto moduleOutputPath = newInstance->getInvocation()
+                                  .getFrontendOptions()
+                                  .ExplicitModulesOutputPath;
       auto newLocalCache = std::make_unique<ModuleDependenciesCache>(
-          *newService, mainModuleName.str(), scanContextHash);
+          *newService, mainModuleName.str(), moduleOutputPath, scanContextHash);
       pInstance = newInstance.get();
       pCache = newLocalCache.get();
       subInstanceMap->insert(
@@ -1800,11 +1804,10 @@ bool swift::dependencies::scanDependencies(CompilerInstance &instance) {
   if (service.setupCachingDependencyScanningService(instance))
     return true;
 
-  ModuleDependenciesCache cache(service,
-                                instance.getMainModule()->getNameStr().str(),
-                                instance.getInvocation().getModuleScanningHash());
-  auto ModuleCachePath = getModuleCachePathFromClang(
-               Context.getClangModuleLoader()->getClangInstance());
+  ModuleDependenciesCache cache(
+      service, instance.getMainModule()->getNameStr().str(),
+      instance.getInvocation().getFrontendOptions().ExplicitModulesOutputPath,
+      instance.getInvocation().getModuleScanningHash());
 
   // Execute scan
   auto dependenciesOrErr = performModuleScan(instance, cache);
@@ -1837,9 +1840,10 @@ bool swift::dependencies::prescanDependencies(CompilerInstance &instance) {
   // `-scan-dependencies` invocations use a single new instance
   // of a module cache
   SwiftDependencyScanningService singleUseService;
-  ModuleDependenciesCache cache(singleUseService,
-                                instance.getMainModule()->getNameStr().str(),
-                                instance.getInvocation().getModuleScanningHash());
+  ModuleDependenciesCache cache(
+      singleUseService, instance.getMainModule()->getNameStr().str(),
+      instance.getInvocation().getFrontendOptions().ExplicitModulesOutputPath,
+      instance.getInvocation().getModuleScanningHash());
 
   // Execute import prescan, and write JSON output to the output stream
   auto importSetOrErr = performModulePrescan(instance);
@@ -1870,9 +1874,10 @@ bool swift::dependencies::batchScanDependencies(
   if (singleUseService.setupCachingDependencyScanningService(instance))
     return true;
 
-  ModuleDependenciesCache cache(singleUseService,
-                                instance.getMainModule()->getNameStr().str(),
-                                instance.getInvocation().getModuleScanningHash());
+  ModuleDependenciesCache cache(
+      singleUseService, instance.getMainModule()->getNameStr().str(),
+      instance.getInvocation().getFrontendOptions().ExplicitModulesOutputPath,
+      instance.getInvocation().getModuleScanningHash());
   (void)instance.getMainModule();
   llvm::BumpPtrAllocator alloc;
   llvm::StringSaver saver(alloc);
@@ -1906,9 +1911,10 @@ bool swift::dependencies::batchPrescanDependencies(
   // The primary cache used for scans carried out with the compiler instance
   // we have created
   SwiftDependencyScanningService singleUseService;
-  ModuleDependenciesCache cache(singleUseService,
-                                instance.getMainModule()->getNameStr().str(),
-                                instance.getInvocation().getModuleScanningHash());
+  ModuleDependenciesCache cache(
+      singleUseService, instance.getMainModule()->getNameStr().str(),
+      instance.getInvocation().getFrontendOptions().ExplicitModulesOutputPath,
+      instance.getInvocation().getModuleScanningHash());
   (void)instance.getMainModule();
   llvm::BumpPtrAllocator alloc;
   llvm::StringSaver saver(alloc);
@@ -1984,14 +1990,14 @@ swift::dependencies::performModuleScan(CompilerInstance &instance,
     cache.recordDependency(mainModuleName, std::move(*mainDependencies));
   }
 
-  auto ModuleCachePath = getModuleCachePathFromClang(
+  auto ClangModuleCachePath = getModuleCachePathFromClang(
       ctx.getClangModuleLoader()->getClangInstance());
   auto &FEOpts = instance.getInvocation().getFrontendOptions();
   ModuleInterfaceLoaderOptions LoaderOpts(FEOpts);
   InterfaceSubContextDelegateImpl ASTDelegate(
       ctx.SourceMgr, &ctx.Diags, ctx.SearchPathOpts, ctx.LangOpts,
       ctx.ClangImporterOpts, LoaderOpts,
-      /*buildModuleCacheDirIfAbsent*/ false, ModuleCachePath,
+      /*buildModuleCacheDirIfAbsent*/ false, ClangModuleCachePath,
       FEOpts.PrebuiltModuleCachePath,
       FEOpts.BackupModuleInterfaceDir,
       FEOpts.SerializeModuleInterfaceDependencyHashes,
@@ -2114,14 +2120,14 @@ swift::dependencies::performBatchModuleScan(
         ASTContext &ctx = instance.getASTContext();
         auto &FEOpts = instance.getInvocation().getFrontendOptions();
         ModuleInterfaceLoaderOptions LoaderOpts(FEOpts);
-        auto ModuleCachePath = getModuleCachePathFromClang(
+        auto ClangModuleCachePath = getModuleCachePathFromClang(
             ctx.getClangModuleLoader()->getClangInstance());
 
         ModuleDependencyIDSetVector allModules;
         InterfaceSubContextDelegateImpl ASTDelegate(
             ctx.SourceMgr, &ctx.Diags, ctx.SearchPathOpts, ctx.LangOpts,
             ctx.ClangImporterOpts, LoaderOpts,
-            /*buildModuleCacheDirIfAbsent*/ false, ModuleCachePath,
+            /*buildModuleCacheDirIfAbsent*/ false, ClangModuleCachePath,
             FEOpts.PrebuiltModuleCachePath,
             FEOpts.BackupModuleInterfaceDir,
             FEOpts.SerializeModuleInterfaceDependencyHashes,
@@ -2183,13 +2189,13 @@ swift::dependencies::performBatchModulePrescan(
         ASTContext &ctx = instance.getASTContext();
         auto &FEOpts = instance.getInvocation().getFrontendOptions();
         ModuleInterfaceLoaderOptions LoaderOpts(FEOpts);
-        auto ModuleCachePath = getModuleCachePathFromClang(
+        auto ClangModuleCachePath = getModuleCachePathFromClang(
             ctx.getClangModuleLoader()->getClangInstance());
         ModuleDependencyIDSetVector allModules;
         InterfaceSubContextDelegateImpl ASTDelegate(
             ctx.SourceMgr, &ctx.Diags, ctx.SearchPathOpts, ctx.LangOpts,
             ctx.ClangImporterOpts, LoaderOpts,
-            /*buildModuleCacheDirIfAbsent*/ false, ModuleCachePath,
+            /*buildModuleCacheDirIfAbsent*/ false, ClangModuleCachePath,
             FEOpts.PrebuiltModuleCachePath,
             FEOpts.BackupModuleInterfaceDir,
             FEOpts.SerializeModuleInterfaceDependencyHashes,
diff --git a/lib/Frontend/ArgsToFrontendOptionsConverter.cpp b/lib/Frontend/ArgsToFrontendOptionsConverter.cpp
@@ -64,6 +64,9 @@ bool ArgsToFrontendOptionsConverter::convert(
   if (const Arg *A = Args.getLastArg(OPT_prebuilt_module_cache_path)) {
     Opts.PrebuiltModuleCachePath = A->getValue();
   }
+  if (const Arg *A = Args.getLastArg(OPT_module_cache_path)) {
+    Opts.ExplicitModulesOutputPath = A->getValue();
+  }
   if (const Arg *A = Args.getLastArg(OPT_backup_module_interface_path)) {
     Opts.BackupModuleInterfaceDir = A->getValue();
   }
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
@@ -1461,6 +1461,9 @@ static bool ParseClangImporterArgs(ClangImporterOptions &Opts,
   if (const Arg *A = Args.getLastArg(OPT_module_cache_path)) {
     Opts.ModuleCachePath = A->getValue();
   }
+  if (const Arg *A = Args.getLastArg(OPT_clang_scanner_module_cache_path)) {
+    Opts.ClangScannerModuleCachePath = A->getValue();
+  }
 
   if (const Arg *A = Args.getLastArg(OPT_target_cpu))
     Opts.TargetCPU = A->getValue();
diff --git a/lib/Frontend/Frontend.cpp b/lib/Frontend/Frontend.cpp
@@ -751,30 +751,28 @@ bool CompilerInstance::setUpModuleLoaders() {
 
   Context->addModuleLoader(std::move(clangImporter), /*isClang*/ true);
 
-  // When scanning for dependencies, we must add the scanner loaders in order to handle
-  // ASTContext operations such as canImportModule
+  // When scanning for dependencies, we must add the scanner loaders in order to
+  // handle ASTContext operations such as canImportModule
   if (Invocation.getFrontendOptions().RequestedAction ==
       FrontendOptions::ActionType::ScanDependencies) {
-    auto ModuleCachePath = getModuleCachePathFromClang(Context
-                                                       ->getClangModuleLoader()->getClangInstance());
+    auto ClangModuleCachePath = getModuleCachePathFromClang(
+        Context->getClangModuleLoader()->getClangInstance());
     auto &FEOpts = Invocation.getFrontendOptions();
     ModuleInterfaceLoaderOptions LoaderOpts(FEOpts);
     InterfaceSubContextDelegateImpl ASTDelegate(
         Context->SourceMgr, &Context->Diags, Context->SearchPathOpts,
         Context->LangOpts, Context->ClangImporterOpts, LoaderOpts,
-        /*buildModuleCacheDirIfAbsent*/ false, ModuleCachePath,
-        FEOpts.PrebuiltModuleCachePath,
-        FEOpts.BackupModuleInterfaceDir,
+        /*buildModuleCacheDirIfAbsent*/ false, ClangModuleCachePath,
+        FEOpts.PrebuiltModuleCachePath, FEOpts.BackupModuleInterfaceDir,
         FEOpts.SerializeModuleInterfaceDependencyHashes,
         FEOpts.shouldTrackSystemDependencies(),
         RequireOSSAModules_t(Invocation.getSILOptions()));
     auto mainModuleName = Context->getIdentifier(FEOpts.ModuleName);
     std::unique_ptr<PlaceholderSwiftModuleScanner> PSMS =
-      std::make_unique<PlaceholderSwiftModuleScanner>(*Context,
-                                                      MLM,
-                                                      mainModuleName,
-                                                      Context->SearchPathOpts.PlaceholderDependencyModuleMap,
-                                                      ASTDelegate);
+        std::make_unique<PlaceholderSwiftModuleScanner>(
+            *Context, MLM, mainModuleName,
+            Context->SearchPathOpts.PlaceholderDependencyModuleMap, ASTDelegate,
+            getInvocation().getFrontendOptions().ExplicitModulesOutputPath);
     Context->addModuleLoader(std::move(PSMS));
   }
 
diff --git a/lib/Serialization/ModuleDependencyScanner.cpp b/lib/Serialization/ModuleDependencyScanner.cpp
diff --git a/test/ScanDependencies/separate_clang_scan_cache.swift b/test/ScanDependencies/separate_clang_scan_cache.swift

Original file line number	Diff line number	Diff line change
`@@ -168,10 +168,18 @@ class CompilerInvocation {`
`168`	`168`	`ClangImporterOpts.ModuleCachePath = Path.str();`
`169`	`169`	`}`
`170`	`170`
	`171`	`+ void setClangScannerModuleCachePath(StringRef Path) {`
	`172`	`+ ClangImporterOpts.ClangScannerModuleCachePath = Path.str();`
	`173`	`+ }`
	`174`	`+`
`171`	`175`	`StringRef getClangModuleCachePath() const {`
`172`	`176`	`return ClangImporterOpts.ModuleCachePath;`
`173`	`177`	`}`
`174`	`178`
	`179`	`+ StringRef getClangScannerModuleCachePath() const {`
	`180`	`+ return ClangImporterOpts.ClangScannerModuleCachePath;`
	`181`	`+ }`
	`182`	`+`
`175`	`183`	`void setImportSearchPaths(const std::vector<std::string> &Paths) {`
`176`	`184`	`SearchPathOpts.setImportSearchPaths(Paths);`
`177`	`185`	`}`
Original file line number	Diff line number	Diff line change
`@@ -667,7 +667,13 @@ importer::getNormalInvocationArguments(`
`667`	`667`	`}`
`668`	`668`
`669`	`669`	`const std::string &moduleCachePath = importerOpts.ModuleCachePath;`
`670`		`- if (!moduleCachePath.empty() && !importerOpts.DisableImplicitClangModules) {`
	`670`	`+ const std::string &scannerCachePath = importerOpts.ClangScannerModuleCachePath;`
	`671`	`+ // If a scanner cache is specified, this must be a scanning action. Prefer this`
	`672`	`+ // path for the Clang scanner to cache its Scanning PCMs.`
	`673`	`+ if (!scannerCachePath.empty()) {`
	`674`	`+ invocationArgStrs.push_back("-fmodules-cache-path=");`
	`675`	`+ invocationArgStrs.back().append(scannerCachePath);`
	`676`	`+ } else if (!moduleCachePath.empty() && !importerOpts.DisableImplicitClangModules) {`
`671`	`677`	`invocationArgStrs.push_back("-fmodules-cache-path=");`
`672`	`678`	`invocationArgStrs.back().append(moduleCachePath);`
`673`	`679`	`}`