Rename and document factory function, expand ModuleCache documentation

Author: jansvoboda11

clang-tools-extra/clangd/ModulesBuilder.cpp

@@ -206,7 +206,7 @@ bool IsModuleFileUpToDate(PathRef ModuleFilePath,
   Preprocessor PP(std::make_shared<PreprocessorOptions>(), *Diags, LangOpts,
                   SourceMgr, HeaderInfo, ModuleLoader);
 
-  IntrusiveRefCntPtr<ModuleCache> ModCache = getCrossProcessModuleCache();
+  IntrusiveRefCntPtr<ModuleCache> ModCache = createCrossProcessModuleCache();
   PCHContainerOperations PCHOperations;
   ASTReader Reader(PP, *ModCache, /*ASTContext=*/nullptr,
                    PCHOperations.getRawReader(), {});

clang/include/clang/Serialization/ModuleCache.h

@@ -19,7 +19,8 @@ class AdvisoryLock;
 namespace clang {
 class InMemoryModuleCache;
 
-/// The module cache used by implicitly-built modules.
+/// The module cache used for compiling modules implicitly. This centralizes the
+/// operations the compiler might want to perform on the cache.
 class ModuleCache : public RefCountedBase<ModuleCache> {
 public:
   /// May perform any work that only needs to be performed once for multiple
@@ -34,12 +35,16 @@ class ModuleCache : public RefCountedBase<ModuleCache> {
   virtual InMemoryModuleCache &getInMemoryModuleCache() = 0;
   virtual const InMemoryModuleCache &getInMemoryModuleCache() const = 0;
 
-  // TODO: Virtualize writing/reading PCM files, timestamp files, etc.
+  // TODO: Virtualize writing/reading PCM files, timestamping, pruning, etc.
 
   virtual ~ModuleCache() = default;
 };
 
-IntrusiveRefCntPtr<ModuleCache> getCrossProcessModuleCache();
+/// Creates new \c ModuleCache backed by a file system directory that may be
+/// operated on by multiple processes. This instance must be used across all
+/// \c CompilerInstance instances participating in building modules for single
+/// translation unit in order to share the same \c InMemoryModuleCache.
+IntrusiveRefCntPtr<ModuleCache> createCrossProcessModuleCache();
 } // namespace clang
 
 #endif

clang/lib/Frontend/ASTUnit.cpp

@@ -829,7 +829,7 @@ std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile(
   AST->SourceMgr = new SourceManager(AST->getDiagnostics(),
                                      AST->getFileManager(),
                                      UserFilesAreVolatile);
-  AST->ModCache = getCrossProcessModuleCache();
+  AST->ModCache = createCrossProcessModuleCache();
   AST->HSOpts = HSOpts ? HSOpts : std::make_shared<HeaderSearchOptions>();
   AST->HSOpts->ModuleFormat = std::string(PCHContainerRdr.getFormats().front());
   AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts,
@@ -1545,7 +1545,7 @@ ASTUnit::create(std::shared_ptr<CompilerInvocation> CI,
   AST->UserFilesAreVolatile = UserFilesAreVolatile;
   AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr,
                                      UserFilesAreVolatile);
-  AST->ModCache = getCrossProcessModuleCache();
+  AST->ModCache = createCrossProcessModuleCache();
 
   return AST;
 }
@@ -1832,7 +1832,7 @@ std::unique_ptr<ASTUnit> ASTUnit::LoadFromCommandLine(
   AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
   AST->StorePreamblesInMemory = StorePreamblesInMemory;
   AST->PreambleStoragePath = PreambleStoragePath;
-  AST->ModCache = getCrossProcessModuleCache();
+  AST->ModCache = createCrossProcessModuleCache();
   AST->OnlyLocalDecls = OnlyLocalDecls;
   AST->CaptureDiagnostics = CaptureDiagnostics;
   AST->TUKind = TUKind;
@@ -2378,7 +2378,7 @@ bool ASTUnit::serialize(raw_ostream &OS) {
 
   SmallString<128> Buffer;
   llvm::BitstreamWriter Stream(Buffer);
-  IntrusiveRefCntPtr<ModuleCache> ModCache = getCrossProcessModuleCache();
+  IntrusiveRefCntPtr<ModuleCache> ModCache = createCrossProcessModuleCache();
   ASTWriter Writer(Stream, Buffer, *ModCache, {});
   return serializeUnit(Writer, Buffer, getSema(), OS);
 }

clang/lib/Frontend/CompilerInstance.cpp

@@ -70,7 +70,7 @@ CompilerInstance::CompilerInstance(
     ModuleCache *ModCache)
     : ModuleLoader(/*BuildingModule=*/ModCache),
       Invocation(new CompilerInvocation()),
-      ModCache(ModCache ? ModCache : getCrossProcessModuleCache()),
+      ModCache(ModCache ? ModCache : createCrossProcessModuleCache()),
       ThePCHContainerOperations(std::move(PCHContainerOps)) {}
 
 CompilerInstance::~CompilerInstance() {

clang/lib/Serialization/ModuleCache.cpp

@@ -39,6 +39,6 @@ class CrossProcessModuleCache : public ModuleCache {
 };
 } // namespace
 
-IntrusiveRefCntPtr<ModuleCache> clang::getCrossProcessModuleCache() {
+IntrusiveRefCntPtr<ModuleCache> clang::createCrossProcessModuleCache() {
   return llvm::makeIntrusiveRefCnt<CrossProcessModuleCache>();
 }