Initial commit of InterfaceModuleNameExpander implmentation. All tests pass, and the unused vfs overlay is optimized.

Author: qiongsiwu

include/swift/AST/ModuleDependencies.h

@@ -320,6 +320,14 @@ class SwiftInterfaceModuleDependenciesStorage
   void updateCommandLine(const std::vector<std::string> &newCommandLine) {
     textualModuleDetails.buildCommandLine = newCommandLine;
   }
+
+  void updateModuleOutputPath(const std::string &newPath) {
+    const_cast<std::string &>(moduleOutputPath) = newPath;
+  }
+
+  void updateContextHash(const std::string &newContextHash) {
+    const_cast<std::string &>(contextHash) = newContextHash;
+  }
 };
 
 /// Describes the dependencies of a Swift module
@@ -876,6 +884,20 @@ class ModuleDependencyInfo {
       llvm_unreachable("Unexpected type");
   }
 
+  void updateModuleOutputPath(const std::string &newPath) {
+    if (isSwiftInterfaceModule())
+      return cast<SwiftInterfaceModuleDependenciesStorage>(storage.get())
+          ->updateModuleOutputPath(newPath);
+    llvm_unreachable("Unexpected type");
+  }
+
+  void updateContextHash(const std::string &newContextHash) {
+    if (isSwiftInterfaceModule())
+      return cast<SwiftInterfaceModuleDependenciesStorage>(storage.get())
+          ->updateContextHash(newContextHash);
+    llvm_unreachable("Unexpected type");
+  }
+
   /// Whether explicit input paths of all the module dependencies
   /// have been specified on the command-line recipe for this module.
   bool isFinalized() const { return storage->finalized; }

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -710,6 +710,41 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
                                     StringRef &CacheHash);
   std::string getCacheHash(StringRef useInterfacePath, StringRef sdkPath);
 };
+
+class InterfaceModuleNameExpander {
+public:
+  using ArgListTy = std::vector<std::string>;
+  struct ResultTy {
+    llvm::SmallString<256> outputPath;
+
+    // Hash points to a segment of outputPath.
+    StringRef hash;
+  };
+
+private:
+  const StringRef moduleName;
+  const StringRef interfacePath;
+  const StringRef sdkPath;
+  const CompilerInvocation &CI;
+  ArgListTy extraArgs;
+
+  ResultTy expandedName;
+
+  bool expanded = false;
+
+  std::string getHash();
+
+public:
+  InterfaceModuleNameExpander(const StringRef moduleName,
+                              const StringRef interfacePath,
+                              const StringRef sdkPath,
+                              const CompilerInvocation &CI)
+      : moduleName(moduleName), interfacePath(interfacePath), sdkPath(sdkPath),
+        CI(CI), extraArgs(CI.getClangImporterOptions()
+                              .getReducedExtraArgsForSwiftModuleDependency()) {}
+  ResultTy getExpandedName();
+  void pruneExtraArgs(std::function<void(ArgListTy &)> filter);
+};
 }
 
 #endif

lib/DependencyScan/ScanDependencies.cpp

@@ -81,13 +81,22 @@ namespace {
 class ExplicitModuleDependencyResolver {
 public:
   ExplicitModuleDependencyResolver(
-      ModuleDependencyID moduleID, ModuleDependenciesCache &cache,
+      const ModuleDependencyID &moduleID, ModuleDependenciesCache &cache,
       CompilerInstance &instance, std::optional<SwiftDependencyTracker> tracker)
       : moduleID(moduleID), cache(cache), instance(instance),
         resolvingDepInfo(cache.findKnownDependency(moduleID)),
         tracker(std::move(tracker)) {
     // Copy commandline.
     commandline = resolvingDepInfo.getCommandline();
+
+    if (resolvingDepInfo.isSwiftInterfaceModule()) {
+      auto swiftTextualDeps = resolvingDepInfo.getAsSwiftInterfaceModule();
+      auto &interfacePath = swiftTextualDeps->swiftInterfaceFile;
+      auto SDKPath = instance.getASTContext().SearchPathOpts.getSDKPath();
+      nameExpander = std::make_unique<InterfaceModuleNameExpander>(
+          moduleID.ModuleName, interfacePath, SDKPath,
+          instance.getInvocation());
+    }
   }
 
   llvm::Error
@@ -171,6 +180,9 @@ class ExplicitModuleDependencyResolver {
 
     pruneUnusedVFSOverlay();
 
+    if (resolvingDepInfo.isSwiftInterfaceModule())
+      updateSwiftInterfaceCommandLine();
+
     // Update the dependency in the cache with the modified command-line.
     if (resolvingDepInfo.isSwiftInterfaceModule() ||
         resolvingDepInfo.isClangModule()) {
@@ -221,6 +233,12 @@ class ExplicitModuleDependencyResolver {
         return err;
     }
 
+    if (nameExpander) {
+      auto expandedName = nameExpander->getExpandedName();
+      depInfo.updateModuleOutputPath(expandedName.outputPath.c_str());
+      depInfo.updateContextHash(expandedName.hash.str());
+    }
+
     return llvm::Error::success();
   }
 
@@ -402,9 +420,62 @@ class ExplicitModuleDependencyResolver {
       }
       resolvedCommandLine.push_back(*it);
     }
+
+    // Filter the extra args that we use to calculate the hash of the module.
+    // The key assumption is that these args are clang importer args, so we
+    // do not need to check for -Xcc.
+    auto extraArgsFilter = [&](InterfaceModuleNameExpander::ArgListTy &args) {
+      bool skip = false;
+      InterfaceModuleNameExpander::ArgListTy newArgs;
+      for (auto it = args.begin(), end = args.end(); it != end; it++) {
+        if (skip) {
+          skip = false;
+          continue;
+        }
+
+        if ((it + 1) != end && isVFSOverlayFlag(*it)) {
+          if (!usedVFSOverlayPaths.contains(*(it + 1))) {
+            skip = true;
+            continue;
+          }
+        }
+
+        newArgs.push_back(*it);
+      }
+      args = newArgs;
+      return;
+    };
+
+    if (nameExpander)
+      nameExpander->pruneExtraArgs(extraArgsFilter);
+
     commandline = std::move(resolvedCommandLine);
   }
 
+  void updateSwiftInterfaceCommandLine() {
+    // The command line needs upadte once we prune the unused VFS overlays.
+    // The update consists of two steps.
+    // 1. Recompute the output path, which includes the module hash.
+    // 2. Update `-o `'s value on the command line with the new output path.
+
+    assert(nameExpander && "Can only update if we hae a nameExpander.");
+    auto expandedName = nameExpander->getExpandedName();
+
+    StringRef outputName = expandedName.outputPath.str();
+
+    bool isOutputPath = false;
+    for (auto &A : commandline) {
+      if (isOutputPath) {
+        A = outputName.str();
+        break;
+      } else if (A == "-o") {
+        isOutputPath = true;
+      }
+    }
+
+    return;
+  }
+
   llvm::Error collectCASDependencies(ModuleDependencyInfo &dependencyInfoCopy) {
     if (!instance.getInvocation().getCASOptions().EnableCaching)
       return llvm::Error::success();
@@ -524,10 +595,11 @@ class ExplicitModuleDependencyResolver {
   }
 
 private:
-  ModuleDependencyID moduleID;
+  const ModuleDependencyID &moduleID;
   ModuleDependenciesCache &cache;
   CompilerInstance &instance;
   const ModuleDependencyInfo &resolvingDepInfo;
+  std::unique_ptr<InterfaceModuleNameExpander> nameExpander;
 
   std::optional<SwiftDependencyTracker> tracker;
   std::vector<std::string> rootIDs;
@@ -540,7 +612,7 @@ class ExplicitModuleDependencyResolver {
 };
 
 static llvm::Error resolveExplicitModuleInputs(
-    ModuleDependencyID moduleID,
+    const ModuleDependencyID &moduleID,
     const std::set<ModuleDependencyID> &dependencies,
     ModuleDependenciesCache &cache, CompilerInstance &instance,
     std::optional<std::set<ModuleDependencyID>> bridgingHeaderDeps,

lib/Frontend/ModuleInterfaceLoader.cpp

@@ -2843,3 +2843,49 @@ std::unique_ptr<ExplicitCASModuleLoader> ExplicitCASModuleLoader::create(
 
   return result;
 }
+
+InterfaceModuleNameExpander::ResultTy
+InterfaceModuleNameExpander::getExpandedName() {
+  // Expand the name once, and reuse later.
+  if (!expanded) {
+    auto &outputPath = expandedName.outputPath;
+    outputPath = CI.getClangModuleCachePath();
+    llvm::sys::path::append(outputPath, moduleName);
+    outputPath.append("-");
+    auto hashStart = outputPath.size();
+    outputPath.append(getHash());
+    expandedName.hash = outputPath.str().substr(hashStart);
+    outputPath.append(".");
+    auto outExt = file_types::getExtension(file_types::TY_SwiftModuleFile);
+    outputPath.append(outExt);
+    expanded = true;
+  }
+  return expandedName;
+}
+
+std::string InterfaceModuleNameExpander::getHash() {
+  bool useStrictCacheHash = CI.getFrontendOptions().RequestedAction ==
+                            FrontendOptions::ActionType::ScanDependencies;
+  auto targetToHash =
+      useStrictCacheHash
+          ? CI.getLangOptions().Target
+          : getTargetSpecificModuleTriple(CI.getLangOptions().Target);
+
+  std::string sdkBuildVersion = getSDKBuildVersion(sdkPath);
+
+  llvm::hash_code H = llvm::hash_combine(
+      swift::version::getSwiftFullVersion(), interfacePath, targetToHash.str(),
+      CI.getSDKPath(), sdkBuildVersion, version::getCurrentCompilerChannel(),
+      CI.getFrontendOptions().shouldTrackSystemDependencies(),
+      CI.getCASOptions().getModuleScanningHashComponents(),
+      llvm::hash_combine_range(extraArgs.begin(), extraArgs.end()),
+      unsigned(CI.getLangOptions().EnableAppExtensionRestrictions),
+      unsigned(CI.getSILOptions().EnableOSSAModules));
+
+  return llvm::toString(llvm::APInt(64, H), 36, /*Signed=*/false);
+}
+
+void InterfaceModuleNameExpander::pruneExtraArgs(
+    std::function<void(ArgListTy &)> filter) {
+  filter(extraArgs);
+}