[clang][DepScan] Pass references to ModuleDeps instead of ModuleID in lookupModuleOutput callbacks, NFCI (llvm#131688)

cyndyishida · cyndyishida · commit 30e22b0ac75d · 2025-03-18T22:29:27.000-07:00
This allows clients to reference more read-only attributes, like IsInStableDirectories. (cherry picked from commit ad8f0e2)
diff --git a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningTool.h b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningTool.h
@@ -37,7 +37,7 @@ namespace dependencies {
 
 /// A callback to lookup module outputs for "-fmodule-file=", "-o" etc.
 using LookupModuleOutputCallback =
-    llvm::function_ref<std::string(const ModuleID &, ModuleOutputKind)>;
+    llvm::function_ref<std::string(const ModuleDeps &, ModuleOutputKind)>;
 
 /// Graph of modular dependencies.
 using ModuleDepsGraph = std::vector<ModuleDeps>;
@@ -292,16 +292,16 @@ class CallbackActionController : public DependencyActionController {
   CallbackActionController(LookupModuleOutputCallback LMO)
       : LookupModuleOutput(std::move(LMO)) {
     if (!LookupModuleOutput) {
-      LookupModuleOutput = [](const ModuleID &,
+      LookupModuleOutput = [](const ModuleDeps &,
                               ModuleOutputKind) -> std::string {
         llvm::report_fatal_error("unexpected call to lookupModuleOutput");
       };
     }
   }
 
-  std::string lookupModuleOutput(const ModuleID &ID,
+  std::string lookupModuleOutput(const ModuleDeps &MD,
                                  ModuleOutputKind Kind) override {
-    return LookupModuleOutput(ID, Kind);
+    return LookupModuleOutput(MD, Kind);
   }
 
 private:
diff --git a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningWorker.h b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningWorker.h
@@ -79,7 +79,7 @@ class DependencyActionController {
 public:
   virtual ~DependencyActionController();
 
-  virtual std::string lookupModuleOutput(const ModuleID &ID,
+  virtual std::string lookupModuleOutput(const ModuleDeps &MD,
                                          ModuleOutputKind Kind) = 0;
 
   virtual llvm::Error initialize(CompilerInstance &ScanInstance,
diff --git a/clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp b/clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp
@@ -244,7 +244,7 @@ llvm::Expected<P1689Rule> DependencyScanningTool::getP1689ModuleDependencyFile(
   class P1689ActionController : public DependencyActionController {
   public:
     // The lookupModuleOutput is for clang modules. P1689 format don't need it.
-    std::string lookupModuleOutput(const ModuleID &,
+    std::string lookupModuleOutput(const ModuleDeps &,
                                    ModuleOutputKind Kind) override {
       return "";
     }
diff --git a/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp b/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
@@ -201,17 +201,17 @@ static std::vector<std::string> splitString(std::string S, char Separator) {
 void ModuleDepCollector::addOutputPaths(CowCompilerInvocation &CI,
                                         ModuleDeps &Deps) {
   CI.getMutFrontendOpts().OutputFile =
-      Controller.lookupModuleOutput(Deps.ID, ModuleOutputKind::ModuleFile);
+      Controller.lookupModuleOutput(Deps, ModuleOutputKind::ModuleFile);
   if (!CI.getDiagnosticOpts().DiagnosticSerializationFile.empty())
     CI.getMutDiagnosticOpts().DiagnosticSerializationFile =
         Controller.lookupModuleOutput(
-            Deps.ID, ModuleOutputKind::DiagnosticSerializationFile);
+            Deps, ModuleOutputKind::DiagnosticSerializationFile);
   if (!CI.getDependencyOutputOpts().OutputFile.empty()) {
-    CI.getMutDependencyOutputOpts().OutputFile = Controller.lookupModuleOutput(
-        Deps.ID, ModuleOutputKind::DependencyFile);
+    CI.getMutDependencyOutputOpts().OutputFile =
+        Controller.lookupModuleOutput(Deps, ModuleOutputKind::DependencyFile);
     CI.getMutDependencyOutputOpts().Targets =
         splitString(Controller.lookupModuleOutput(
-                        Deps.ID, ModuleOutputKind::DependencyTargets),
+                        Deps, ModuleOutputKind::DependencyTargets),
                     '\0');
     if (!CI.getDependencyOutputOpts().OutputFile.empty() &&
         CI.getDependencyOutputOpts().Targets.empty()) {
@@ -419,10 +419,10 @@ void ModuleDepCollector::addModuleMapFiles(
 void ModuleDepCollector::addModuleFiles(
     CompilerInvocation &CI, ArrayRef<ModuleID> ClangModuleDeps) const {
   for (const ModuleID &MID : ClangModuleDeps) {
+    ModuleDeps *MD = ModuleDepsByID.lookup(MID);
     std::string PCMPath =
-        Controller.lookupModuleOutput(MID, ModuleOutputKind::ModuleFile);
+        Controller.lookupModuleOutput(*MD, ModuleOutputKind::ModuleFile);
 
-    ModuleDeps *MD = ModuleDepsByID.lookup(MID);
     assert(MD && "Inconsistent dependency info");
     if (MD->ModuleCacheKey)
       CI.getFrontendOpts().ModuleCacheKeys.emplace_back(PCMPath,
@@ -439,10 +439,10 @@ void ModuleDepCollector::addModuleFiles(
 void ModuleDepCollector::addModuleFiles(
     CowCompilerInvocation &CI, ArrayRef<ModuleID> ClangModuleDeps) const {
   for (const ModuleID &MID : ClangModuleDeps) {
+    ModuleDeps *MD = ModuleDepsByID.lookup(MID);
     std::string PCMPath =
-        Controller.lookupModuleOutput(MID, ModuleOutputKind::ModuleFile);
+        Controller.lookupModuleOutput(*MD, ModuleOutputKind::ModuleFile);
 
-    ModuleDeps *MD = ModuleDepsByID.lookup(MID);
     assert(MD && "Inconsistent dependency info");
     if (MD->ModuleCacheKey)
       CI.getMutFrontendOpts().ModuleCacheKeys.emplace_back(PCMPath,
diff --git a/clang/tools/clang-scan-deps/ClangScanDeps.cpp b/clang/tools/clang-scan-deps/ClangScanDeps.cpp
@@ -988,9 +988,10 @@ static std::string constructPCMPath(ModuleID MID, StringRef OutputDir) {
   return std::string(ExplicitPCMPath);
 }
 
-static std::string lookupModuleOutput(const ModuleID &MID, ModuleOutputKind MOK,
+static std::string lookupModuleOutput(const ModuleDeps &MD,
+                                      ModuleOutputKind MOK,
                                       StringRef OutputDir) {
-  std::string PCMPath = constructPCMPath(MID, OutputDir);
+  std::string PCMPath = constructPCMPath(MD.ID, OutputDir);
   switch (MOK) {
   case ModuleOutputKind::ModuleFile:
     return PCMPath;
@@ -1326,8 +1327,8 @@ int clang_scan_deps_main(int argc, char **argv, const llvm::ToolContext &) {
       std::string OutputDir(ModuleFilesDir);
       if (OutputDir.empty())
         OutputDir = getModuleCachePath(Input->CommandLine);
-      auto LookupOutput = [&](const ModuleID &MID, ModuleOutputKind MOK) {
-        return ::lookupModuleOutput(MID, MOK, OutputDir);
+      auto LookupOutput = [&](const ModuleDeps &MD, ModuleOutputKind MOK) {
+        return ::lookupModuleOutput(MD, MOK, OutputDir);
       };
 
       // Run the tool on it.
diff --git a/clang/tools/libclang/CDependencies.cpp b/clang/tools/libclang/CDependencies.cpp
@@ -334,7 +334,7 @@ class OutputLookup {
 public:
   OutputLookup(void *MLOContext, CXModuleLookupOutputCallback *MLO)
       : MLOContext(MLOContext), MLO(MLO) {}
-  std::string lookupModuleOutput(const ModuleID &ID, ModuleOutputKind MOK);
+  std::string lookupModuleOutput(const ModuleDeps &MD, ModuleOutputKind MOK);
 
 private:
   llvm::DenseMap<ModuleID, std::string> PCMPaths;
@@ -350,8 +350,8 @@ clang_experimental_DependencyScannerWorker_getFileDependencies_v3(
     CXModuleDiscoveredCallback *MDC, void *MLOContext,
     CXModuleLookupOutputCallback *MLO, unsigned, CXString *Error) {
   OutputLookup OL(MLOContext, MLO);
-  auto LookupOutputs = [&](const ModuleID &ID, ModuleOutputKind MOK) {
-    return OL.lookupModuleOutput(ID, MOK);
+  auto LookupOutputs = [&](const ModuleDeps &MD, ModuleOutputKind MOK) {
+    return OL.lookupModuleOutput(MD, MOK);
   };
   CXFileDependencies *FDeps = nullptr;
   CXErrorCode Result = getFileDependencies(
@@ -381,8 +381,8 @@ CXErrorCode clang_experimental_DependencyScannerWorker_getFileDependencies_v4(
     CXModuleLookupOutputCallback *MLO, unsigned, CXFileDependenciesList **Out,
     CXString *Error) {
   OutputLookup OL(MLOContext, MLO);
-  auto LookupOutputs = [&](const ModuleID &ID, ModuleOutputKind MOK) {
-    return OL.lookupModuleOutput(ID, MOK);
+  auto LookupOutputs = [&](const ModuleDeps &MD, ModuleOutputKind MOK) {
+    return OL.lookupModuleOutput(MD, MOK);
   };
 
   if (!Out)
@@ -526,8 +526,8 @@ enum CXErrorCode clang_experimental_DependencyScannerWorker_getDepGraph(
   CXModuleLookupOutputCallback *MLO = Settings.MLO;
 
   OutputLookup OL(MLOContext, MLO);
-  auto LookupOutputs = [&](const ModuleID &ID, ModuleOutputKind MOK) {
-    return OL.lookupModuleOutput(ID, MOK);
+  auto LookupOutputs = [&](const ModuleDeps &MD, ModuleOutputKind MOK) {
+    return OL.lookupModuleOutput(MD, MOK);
   };
 
   if (!Out)
@@ -710,27 +710,28 @@ CXDiagnosticSet clang_experimental_DepGraph_getDiagnostics(CXDepGraph Graph) {
   return unwrap(Graph)->getDiagnosticSet();
 }
 
-static std::string lookupModuleOutput(const ModuleID &ID, ModuleOutputKind MOK,
-                                      void *MLOContext,
+static std::string lookupModuleOutput(const ModuleDeps &MD,
+                                      ModuleOutputKind MOK, void *MLOContext,
                                       CXModuleLookupOutputCallback *MLO) {
   SmallVector<char, 256> Buffer(256);
-  size_t Len = MLO(MLOContext, ID.ModuleName.c_str(), ID.ContextHash.c_str(),
-                   wrap(MOK), Buffer.data(), Buffer.size());
+  size_t Len =
+      MLO(MLOContext, MD.ID.ModuleName.c_str(), MD.ID.ContextHash.c_str(),
+          wrap(MOK), Buffer.data(), Buffer.size());
   if (Len > Buffer.size()) {
     Buffer.resize(Len);
-    Len = MLO(MLOContext, ID.ModuleName.c_str(), ID.ContextHash.c_str(),
+    Len = MLO(MLOContext, MD.ID.ModuleName.c_str(), MD.ID.ContextHash.c_str(),
               wrap(MOK), Buffer.data(), Buffer.size());
   }
   return std::string(Buffer.begin(), Len);
 }
 
-std::string OutputLookup::lookupModuleOutput(const ModuleID &ID,
+std::string OutputLookup::lookupModuleOutput(const ModuleDeps &MD,
                                              ModuleOutputKind MOK) {
   if (MOK != ModuleOutputKind::ModuleFile)
-    return ::lookupModuleOutput(ID, MOK, MLOContext, MLO);
+    return ::lookupModuleOutput(MD, MOK, MLOContext, MLO);
   // PCM paths are looked up repeatedly, so cache them.
-  auto PCMPath = PCMPaths.insert({ID, ""});
+  auto PCMPath = PCMPaths.insert({MD.ID, ""});
   if (PCMPath.second)
-    PCMPath.first->second = ::lookupModuleOutput(ID, MOK, MLOContext, MLO);
+    PCMPath.first->second = ::lookupModuleOutput(MD, MOK, MLOContext, MLO);
   return PCMPath.first->second;
 }

Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ llvm::Expected<P1689Rule> DependencyScanningTool::getP1689ModuleDependencyFile(`
`244`	`244`	`class P1689ActionController : public DependencyActionController {`
`245`	`245`	`public:`
`246`	`246`	`// The lookupModuleOutput is for clang modules. P1689 format don't need it.`
`247`		`- std::string lookupModuleOutput(const ModuleID &,`
	`247`	`+ std::string lookupModuleOutput(const ModuleDeps &,`
`248`	`248`	`ModuleOutputKind Kind) override {`
`249`	`249`	`return "";`
`250`	`250`	`}`