Centralize module cache normalization

Author: jansvoboda11

clang/include/clang/Frontend/CompilerInstance.h

@@ -699,6 +699,8 @@ class CompilerInstance : public ModuleLoader {
     GetDependencyDirectives = std::move(Getter);
   }
 
+  static SmallString<256> normalizeModuleCachePath(FileManager &FileMgr,
+                                                   StringRef ModuleCachePath);
   std::string getSpecificModuleCachePath(StringRef ModuleHash);
   std::string getSpecificModuleCachePath() {
     return getSpecificModuleCachePath(getInvocation().getModuleHash());

clang/lib/Frontend/CompilerInstance.cpp

@@ -547,14 +547,24 @@ void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
     PP->setDependencyDirectivesGetter(*GetDependencyDirectives);
 }
 
+SmallString<256>
+CompilerInstance::normalizeModuleCachePath(FileManager &FileMgr,
+                                           StringRef ModuleCachePath) {
+  SmallString<256> NormalizedModuleCachePath(ModuleCachePath);
+  FileMgr.makeAbsolutePath(NormalizedModuleCachePath);
+  llvm::sys::path::remove_dots(NormalizedModuleCachePath);
+  return NormalizedModuleCachePath;
+}
+
 std::string CompilerInstance::getSpecificModuleCachePath(StringRef ModuleHash) {
+  assert(FileMgr && "Specific module cache path requires a FileManager");
+
   if (getHeaderSearchOpts().ModuleCachePath.empty())
     return "";
 
   // Set up the module path, including the hash for the module-creation options.
-  SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
-  FileMgr->makeAbsolutePath(SpecificModuleCache);
-  llvm::sys::path::remove_dots(SpecificModuleCache);
+  SmallString<256> SpecificModuleCache =
+      normalizeModuleCachePath(*FileMgr, getHeaderSearchOpts().ModuleCachePath);
   if (!getHeaderSearchOpts().DisableModuleHash)
     llvm::sys::path::append(SpecificModuleCache, ModuleHash);
   return std::string(SpecificModuleCache);

clang/lib/Serialization/ASTWriter.cpp

@@ -57,6 +57,7 @@
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
 #include "clang/Basic/Version.h"
+#include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/MacroInfo.h"
@@ -1710,13 +1711,12 @@ void ASTWriter::WriteControlBlock(Preprocessor &PP, StringRef isysroot) {
   const HeaderSearchOptions &HSOpts =
       PP.getHeaderSearchInfo().getHeaderSearchOpts();
 
+  auto HSOpts_ModuleCachePath = CompilerInstance::normalizeModuleCachePath(
+      PP.getFileManager(), HSOpts.ModuleCachePath);
+
   AddString(HSOpts.Sysroot, Record);
   AddString(HSOpts.ResourceDir, Record);
-
-  SmallString<256> ModuleCachePath(HSOpts.ModuleCachePath);
-  (void)cleanPathForOutput(PP.getFileManager(), ModuleCachePath);
-  AddString(ModuleCachePath, Record);
-
+  AddString(HSOpts_ModuleCachePath, Record);
   AddString(HSOpts.ModuleUserBuildPath, Record);
   Record.push_back(HSOpts.DisableModuleHash);
   Record.push_back(HSOpts.ImplicitModuleMaps);

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

@@ -448,10 +448,8 @@ class DependencyScanningAction {
 
     // Use the dependency scanning optimized file system if requested to do so.
     if (DepFS) {
-      SmallString<256> ModulesCachePath(
-          ScanInstance.getHeaderSearchOpts().ModuleCachePath);
-      FileMgr->makeAbsolutePath(ModulesCachePath);
-      llvm::sys::path::remove_dots(ModulesCachePath);
+      auto ModulesCachePath = CompilerInstance::normalizeModuleCachePath(
+          *FileMgr, ScanInstance.getHeaderSearchOpts().ModuleCachePath);
       DepFS->resetBypassedPathPrefix();
       if (!ModulesCachePath.empty())
         DepFS->setBypassedPathPrefix(ModulesCachePath);