[clang][deps] NFC: Remove dead code

[jansvoboda11]

Summary

This patch removes some dead code in the dependency scanner.

The ModuleDeps::ImplicitModulePCMPath member stopped being used in D131934.

The strict context hash was replaced in D129884 by hash of the canonical command line.

[benlangmuir]

Removing ImplicitModulePCMPath LGTM; not sure about the other change.

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

178

I see we're enabling strict hashing in the scaner itself: ScanInstance.getHeaderSearchOpts().ModulesStrictContextHash = true;, which makes me think this code was never used to influence the scanner's implicit build. If that's true, was this code *already* dead before my change in D129884? It's not clear to me what it was doing.

[jansvoboda11]

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

178

The line you found enables strict context hashing for the CompilerInstance that performs the scanning build. That's still important so that we don't squash multiple module configurations into one minimized PCM.

The line this patch removes used to control generation of the module context hash we report to the client. This used to be done by taking the original TU command line, tweaking it, and calling CompilerInvocation::getModuleHash(). Since we now hash the whole command line that's generated from said CompilerInvocation, controlling the behavior of getModuleHash() by enabling strict context hash is no longer necessary.

[benlangmuir]

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

178

Got it, thanks for explaining!

clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h

struct ModuleDeps {
   bool IsSystem;
 
   /// The path to the modulemap file which defines this module.
   ///
   /// This can be used to explicitly build this module. This file will
   /// additionally appear in \c FileDeps as a dependency.
   std::string ClangModuleMapFile;
 
-  /// The path to where an implicit build would put the PCM for this module.
-  std::string ImplicitModulePCMPath;
-
   /// A collection of absolute paths to files that this module directly depends
   /// on, not including transitive dependencies.
   llvm::StringSet<> FileDeps;
 
   /// A collection of absolute paths to module map files that this module needs
   /// to know about. The ordering is significant.
   std::vector<std::string> ModuleMapFileDeps;
 

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

llvm::erase_if(
               llvm::CachedHashString(MacroDef.split('=').first));
         });
     // Remove the now unused option.
     CI.getHeaderSearchOpts().ModulesIgnoreMacros.clear();
   }
 
   Optimize(CI);
 
-  // The original invocation probably didn't have strict context hash enabled.
-  // We will use the context hash of this invocation to distinguish between
-  // multiple incompatible versions of the same module and will use it when
-  // reporting dependencies to the clients. Let's make sure we're using
-  // **strict** context hash in order to prevent accidental sharing of
-  // incompatible modules (e.g. with differences in search paths).
-  CI.getHeaderSearchOpts().ModulesStrictContextHash = true;
-
   return CI;
 }
 
 llvm::DenseSet<const FileEntry *> ModuleDepCollector::collectModuleMapFiles(
     ArrayRef<ModuleID> ClangModuleDeps) const {
   llvm::DenseSet<const FileEntry *> ModuleMapFiles;
   for (const ModuleID &MID : ClangModuleDeps) {
     ModuleDeps *MD = ModuleDepsByID.lookup(MID);
ModuleDepCollectorPP::handleTopLevelModule(const Module *M) {
   if (!ModI.second)
     return ModI.first->second->ID;
 
   ModI.first->second = std::make_unique<ModuleDeps>();
   ModuleDeps &MD = *ModI.first->second;
 
   MD.ID.ModuleName = M->getFullModuleName();
   MD.ImportedByMainFile = DirectModularDeps.contains(M);
-  MD.ImplicitModulePCMPath = std::string(M->getASTFile()->getName());
   MD.IsSystem = M->IsSystem;
 
   ModuleMap &ModMapInfo =
       MDC.ScanInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
 
   OptionalFileEntryRef ModuleMap = ModMapInfo.getModuleMapFileForUniquing(M);
 
   if (ModuleMap) {