[clang][deps] Call llvm::cas::createCASProvidingFileSystem()

automatically

Author: jansvoboda11

clang-tools-extra/clangd/ScanningProjectModules.cpp

@@ -38,7 +38,7 @@ class ModuleDependencyScanner {
       : CDB(CDB), TFS(TFS),
         Service(tooling::dependencies::ScanningMode::CanonicalPreprocessing,
                 tooling::dependencies::ScanningOutputFormat::P1689,
-                CASOptions(), nullptr, nullptr, nullptr) {}
+                CASOptions(), nullptr, nullptr) {}
 
   /// The scanned modules dependency information for a specific source file.
   struct ModuleDependencyInfo {

clang/include/clang/Tooling/DependencyScanning/DependencyScanningTool.h

@@ -144,7 +144,7 @@ class DependencyScanningTool {
   }
 
   Expected<cas::IncludeTreeRoot>
-  getIncludeTree(cas::ObjectStore &DB,
+  getIncludeTree(std::shared_ptr<cas::ObjectStore> DB,
                  const std::vector<std::string> &CommandLine, StringRef CWD,
                  LookupModuleOutputCallback LookupModuleOutput);
 
@@ -153,7 +153,7 @@ class DependencyScanningTool {
   /// message and the serialized diagnostics file emitted if the
   /// \p DiagOpts.DiagnosticSerializationFile setting is set for the invocation.
   Expected<cas::IncludeTreeRoot> getIncludeTreeFromCompilerInvocation(
-      cas::ObjectStore &DB, std::shared_ptr<CompilerInvocation> Invocation,
+      std::shared_ptr<cas::ObjectStore> DB, std::shared_ptr<CompilerInvocation> Invocation,
       StringRef CWD, LookupModuleOutputCallback LookupModuleOutput,
       DiagnosticConsumer &DiagsConsumer, raw_ostream *VerboseOS,
       bool DiagGenerationAsCompilation);

clang/include/clang/Tooling/DependencyScanning/ScanAndUpdateArgs.h

@@ -62,7 +62,7 @@ Expected<llvm::cas::CASID> scanAndUpdateCC1InlineWithTool(
     tooling::dependencies::DependencyScanningTool &Tool,
     DiagnosticConsumer &DiagsConsumer, raw_ostream *VerboseOS,
     CompilerInvocation &Invocation, StringRef WorkingDirectory,
-    llvm::cas::ObjectStore &DB);
+    std::shared_ptr<llvm::cas::ObjectStore> DB);
 
 } // end namespace clang
 

clang/lib/Tooling/DependencyScanning/CachingActions.h

@@ -10,19 +10,12 @@
 #define LLVM_CLANG_TOOLING_DEPENDENCYSCANNING_CACHINGACTIONS_H
 
 #include "clang/Tooling/DependencyScanning/DependencyScanningTool.h"
-#include "clang/Tooling/DependencyScanning/ScanAndUpdateArgs.h"
 
 namespace clang::tooling::dependencies {
 
 std::unique_ptr<DependencyActionController>
 createIncludeTreeActionController(LookupModuleOutputCallback LookupModuleOutput,
-                                  cas::ObjectStore &DB);
-
-/// The PCH recorded file paths with canonical paths, create a VFS that
-/// allows remapping back to the non-canonical source paths so that they are
-/// found during dep-scanning.
-void addReversePrefixMappingFileSystem(const llvm::PrefixMapper &PrefixMapper,
-                                       CompilerInstance &ScanInstance);
+                                  std::shared_ptr<cas::ObjectStore> DB);
 
 } // namespace clang::tooling::dependencies
 #endif // LLVM_CLANG_TOOLING_DEPENDENCYSCANNING_CACHINGACTIONS_H

clang/lib/Tooling/DependencyScanning/DependencyScannerImpl.cpp

@@ -564,15 +564,7 @@ initVFSForTUBuferScanning(IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS,
   auto InputPath = TUBuffer.getBufferIdentifier();
   InMemoryFS->addFile(
       InputPath, 0, llvm::MemoryBuffer::getMemBufferCopy(TUBuffer.getBuffer()));
-  IntrusiveRefCntPtr<llvm::vfs::FileSystem> InMemoryOverlay = InMemoryFS;
-
-  // If we are using a CAS, we need to provide the fake input file in a
-  // CASProvidingFS for include-tree.
-  if (CAS)
-    InMemoryOverlay =
-        llvm::cas::createCASProvidingFileSystem(CAS, std::move(InMemoryFS));
-
-  OverlayFS->pushOverlay(InMemoryOverlay);
+  OverlayFS->pushOverlay(std::move(InMemoryFS));
   ModifiedFS = OverlayFS;
   std::vector<std::string> ModifiedCommandLine(CommandLine);
   ModifiedCommandLine.emplace_back(InputPath);
@@ -601,15 +593,7 @@ initVFSForByNameScanning(IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS,
   llvm::sys::fs::createUniquePath(ModuleName + "-%%%%%%%%.input", FakeInputPath,
                                   /*MakeAbsolute=*/false);
   InMemoryFS->addFile(FakeInputPath, 0, llvm::MemoryBuffer::getMemBuffer(""));
-  IntrusiveRefCntPtr<llvm::vfs::FileSystem> InMemoryOverlay = InMemoryFS;
-
-  // If we are using a CAS, we need to provide the fake input file in a
-  // CASProvidingFS for include-tree.
-  if (CAS)
-    InMemoryOverlay =
-        llvm::cas::createCASProvidingFileSystem(CAS, std::move(InMemoryFS));
-
-  OverlayFS->pushOverlay(InMemoryOverlay);
+  OverlayFS->pushOverlay(std::move(InMemoryFS));
 
   std::vector<std::string> ModifiedCommandLine(CommandLine);
   ModifiedCommandLine.emplace_back(FakeInputPath);

clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp

@@ -137,9 +137,9 @@ class GetIncludeTree : public EmptyDependencyConsumer {
 }
 
 Expected<cas::IncludeTreeRoot> DependencyScanningTool::getIncludeTree(
-    cas::ObjectStore &DB, const std::vector<std::string> &CommandLine,
+    std::shared_ptr<cas::ObjectStore> DB, const std::vector<std::string> &CommandLine,
     StringRef CWD, LookupModuleOutputCallback LookupModuleOutput) {
-  GetIncludeTree Consumer(DB);
+  GetIncludeTree Consumer(*DB);
   auto Controller = createIncludeTreeActionController(LookupModuleOutput, DB);
   llvm::Error Result =
       Worker.computeDependencies(CWD, CommandLine, Consumer, *Controller);
@@ -150,11 +150,11 @@ Expected<cas::IncludeTreeRoot> DependencyScanningTool::getIncludeTree(
 
 Expected<cas::IncludeTreeRoot>
 DependencyScanningTool::getIncludeTreeFromCompilerInvocation(
-    cas::ObjectStore &DB, std::shared_ptr<CompilerInvocation> Invocation,
+    std::shared_ptr<cas::ObjectStore> DB, std::shared_ptr<CompilerInvocation> Invocation,
     StringRef CWD, LookupModuleOutputCallback LookupModuleOutput,
     DiagnosticConsumer &DiagsConsumer, raw_ostream *VerboseOS,
     bool DiagGenerationAsCompilation) {
-  GetIncludeTree Consumer(DB);
+  GetIncludeTree Consumer(*DB);
   auto Controller = createIncludeTreeActionController(LookupModuleOutput, DB);
   Worker.computeDependenciesFromCompilerInvocation(
       std::move(Invocation), CWD, Consumer, *Controller, DiagsConsumer,
@@ -311,7 +311,7 @@ DependencyScanningTool::createActionController(
     LookupModuleOutputCallback LookupModuleOutput) {
   if (Worker.getScanningFormat() == ScanningOutputFormat::FullIncludeTree)
     return createIncludeTreeActionController(LookupModuleOutput,
-                                             *Worker.getCAS());
+                                             Worker.getCAS());
   return std::make_unique<CallbackActionController>(LookupModuleOutput);
 }
 

clang/lib/Tooling/DependencyScanning/IncludeTreeActionController.cpp

@@ -12,6 +12,7 @@
 #include "clang/CAS/IncludeTree.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Preprocessor.h"
+#include "llvm/CAS/CASProvidingFileSystem.h"
 #include "llvm/CAS/ObjectStore.h"
 #include "llvm/Support/PrefixMapper.h"
 #include "llvm/Support/PrefixMappingFileSystem.h"
@@ -26,9 +27,9 @@ class IncludeTreeBuilder;
 
 class IncludeTreeActionController : public CallbackActionController {
 public:
-  IncludeTreeActionController(cas::ObjectStore &DB,
+  IncludeTreeActionController(std::shared_ptr<cas::ObjectStore> DB,
                               LookupModuleOutputCallback LookupOutput)
-      : CallbackActionController(LookupOutput), DB(DB) {}
+      : CallbackActionController(LookupOutput), DB(std::move(DB)) {}
 
   Expected<cas::IncludeTreeRoot> getIncludeTree();
 
@@ -52,7 +53,7 @@ class IncludeTreeActionController : public CallbackActionController {
   }
 
 private:
-  cas::ObjectStore &DB;
+  std::shared_ptr<cas::ObjectStore> DB;
   CASOptions CASOpts;
   llvm::PrefixMapper PrefixMapper;
   // IncludeTreePPCallbacks keeps a pointer to the current builder, so use a
@@ -274,22 +275,6 @@ class LookupPCHModulesListener : public ASTReaderListener {
 };
 } // namespace
 
-/// The PCH recorded file paths with canonical paths, create a VFS that
-/// allows remapping back to the non-canonical source paths so that they are
-/// found during dep-scanning.
-void dependencies::addReversePrefixMappingFileSystem(
-    const llvm::PrefixMapper &PrefixMapper, CompilerInstance &ScanInstance) {
-  llvm::PrefixMapper ReverseMapper;
-  ReverseMapper.addInverseRange(PrefixMapper.getMappings());
-  ReverseMapper.sort();
-  IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS =
-      llvm::vfs::createPrefixMappingFileSystem(
-          std::move(ReverseMapper), &ScanInstance.getVirtualFileSystem());
-
-  ScanInstance.setVirtualFileSystem(FS);
-  ScanInstance.getFileManager().setVirtualFileSystem(std::move(FS));
-}
-
 Expected<cas::IncludeTreeRoot> IncludeTreeActionController::getIncludeTree() {
   if (IncludeTreeResult)
     return *IncludeTreeResult;
@@ -301,25 +286,35 @@ Error IncludeTreeActionController::initialize(
     CompilerInstance &ScanInstance, CompilerInvocation &NewInvocation) {
   DepscanPrefixMapping::configurePrefixMapper(NewInvocation, PrefixMapper);
 
-  auto ensurePathRemapping = [&]() {
-    if (PrefixMapper.empty())
-      return;
-
+  IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS =
+      ScanInstance.getVirtualFileSystemPtr();
+  FS = llvm::cas::createCASProvidingFileSystem(DB, std::move(FS));
+  if (!PrefixMapper.empty()) {
     PreprocessorOptions &PPOpts = ScanInstance.getPreprocessorOpts();
-    if (PPOpts.Includes.empty() && PPOpts.ImplicitPCHInclude.empty() &&
-        !ScanInstance.getLangOpts().Modules)
-      return;
-
-    addReversePrefixMappingFileSystem(PrefixMapper, ScanInstance);
+    if (!PPOpts.Includes.empty() || !PPOpts.ImplicitPCHInclude.empty() ||
+        ScanInstance.getLangOpts().Modules) {
+
+      /// The PCH recorded file paths with canonical paths, create a VFS that
+      /// allows remapping back to the non-canonical source paths so that they
+      /// are found during dep-scanning.
+      llvm::PrefixMapper ReverseMapper;
+      ReverseMapper.addInverseRange(PrefixMapper.getMappings());
+      ReverseMapper.sort();
+
+      FS = llvm::vfs::createPrefixMappingFileSystem(std::move(ReverseMapper),
+                                                    std::move(FS));
+    }
 
     // These are written in the predefines buffer, so we need to remap them.
     for (std::string &Include : PPOpts.Includes)
       PrefixMapper.mapInPlace(Include);
-  };
-  ensurePathRemapping();
+  }
+
+  ScanInstance.setVirtualFileSystem(FS);
+  ScanInstance.getFileManager().setVirtualFileSystem(std::move(FS));
 
   BuilderStack.push_back(
-      std::make_unique<IncludeTreeBuilder>(DB, PrefixMapper));
+      std::make_unique<IncludeTreeBuilder>(*DB, PrefixMapper));
 
   // Attach callbacks for the IncludeTree of the TU. The preprocessor
   // does not exist yet, so we need to indirect this via DependencyCollector.
@@ -400,7 +395,7 @@ std::optional<std::string> IncludeTreeActionController::getCacheKey(
 Error IncludeTreeActionController::initializeModuleBuild(
     CompilerInstance &ModuleScanInstance) {
   BuilderStack.push_back(
-      std::make_unique<IncludeTreeBuilder>(DB, PrefixMapper));
+      std::make_unique<IncludeTreeBuilder>(*DB, PrefixMapper));
 
   // Attach callbacks for the IncludeTree of the module. The preprocessor
   // does not exist yet, so we need to indirect this via DependencyCollector.
@@ -942,6 +937,6 @@ IncludeTreeBuilder::createIncludeFile(StringRef Filename,
 
 std::unique_ptr<DependencyActionController>
 dependencies::createIncludeTreeActionController(
-    LookupModuleOutputCallback LookupModuleOutput, cas::ObjectStore &DB) {
-  return std::make_unique<IncludeTreeActionController>(DB, LookupModuleOutput);
+    LookupModuleOutputCallback LookupModuleOutput, std::shared_ptr<cas::ObjectStore> DB) {
+  return std::make_unique<IncludeTreeActionController>(std::move(DB), LookupModuleOutput);
 }

clang/lib/Tooling/DependencyScanning/ScanAndUpdateArgs.cpp

@@ -249,7 +249,7 @@ void DepscanPrefixMapping::configurePrefixMapper(
 Expected<llvm::cas::CASID> clang::scanAndUpdateCC1InlineWithTool(
     DependencyScanningTool &Tool, DiagnosticConsumer &DiagsConsumer,
     raw_ostream *VerboseOS, CompilerInvocation &Invocation,
-    StringRef WorkingDirectory, llvm::cas::ObjectStore &DB) {
+    StringRef WorkingDirectory, std::shared_ptr<llvm::cas::ObjectStore> DB) {
   // Override the CASOptions. They may match (the caller having sniffed them
   // out of InputArgs) but if they have been overridden we want the new ones.
   Invocation.getCASOpts() = Tool.getCASOpts();

clang/tools/clang-scan-deps/ClangScanDeps.cpp

@@ -1177,10 +1177,7 @@ int clang_scan_deps_main(int argc, char **argv, const llvm::ToolContext &) {
   std::atomic<size_t> NumIsLocalCalls = 0;
 
   auto ScanningTask = [&](DependencyScanningService &Service) {
-    std::unique_ptr<llvm::vfs::FileSystem> FS = llvm::vfs::createPhysicalFileSystem();
-    if (CAS)
-      FS = llvm::cas::createCASProvidingFileSystem(CAS, std::move(FS));
-    DependencyScanningTool WorkerTool(Service, std::move(FS));
+    DependencyScanningTool WorkerTool(Service, llvm::vfs::createPhysicalFileSystem());
 
     llvm::DenseSet<ModuleID> AlreadySeenModules;
     while (auto MaybeInputIndex = GetNextInputIndex()) {
@@ -1204,7 +1201,7 @@ int clang_scan_deps_main(int argc, char **argv, const llvm::ToolContext &) {
           HadErrors = true;
       } else if (Format == ScanningOutputFormat::IncludeTree) {
         auto MaybeTree = WorkerTool.getIncludeTree(
-            *CAS, Input->CommandLine, CWD, LookupOutput);
+            CAS, Input->CommandLine, CWD, LookupOutput);
         std::unique_lock<std::mutex> LockGuard(Lock);
         TreeResults.emplace_back(LocalIndex, std::move(Filename),
                                  std::move(MaybeTree));

clang/tools/driver/cc1depscan_main.cpp

@@ -371,7 +371,7 @@ static Expected<llvm::cas::CASID> scanAndUpdateCC1InlineWithTool(
     tooling::dependencies::DependencyScanningTool &Tool,
     DiagnosticConsumer &DiagsConsumer, raw_ostream *VerboseOS, const char *Exec,
     ArrayRef<const char *> InputArgs, StringRef WorkingDirectory,
-    SmallVectorImpl<const char *> &OutputArgs, llvm::cas::ObjectStore &DB,
+    SmallVectorImpl<const char *> &OutputArgs, std::shared_ptr<llvm::cas::ObjectStore> DB,
     llvm::function_ref<const char *(const Twine &)> SaveArg);
 
 #ifdef LLVM_ON_UNIX
@@ -978,13 +978,8 @@ int ScanServer::listen() {
 
       // Is this safe to reuse? Or does DependendencyScanningWorkerFileSystem
       // make some bad assumptions about relative paths?
-      if (!Tool) {
-        llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> UnderlyingFS =
-            llvm::vfs::createPhysicalFileSystem();
-        UnderlyingFS = llvm::cas::createCASProvidingFileSystem(
-            CAS, std::move(UnderlyingFS));
-        Tool.emplace(Service, std::move(UnderlyingFS));
-      }
+      if (!Tool)
+        Tool.emplace(Service, llvm::vfs::createPhysicalFileSystem());
 
       std::unique_ptr<DiagnosticOptions> DiagOpts =
           CreateAndPopulateDiagOpts(Args);
@@ -997,7 +992,7 @@ int ScanServer::listen() {
       SmallVector<const char *> NewArgs;
       auto RootID = scanAndUpdateCC1InlineWithTool(
           *Tool, *DiagsConsumer, &DiagsOS, Argv0, Args, WorkingDirectory,
-          NewArgs, *CAS, [&](const Twine &T) { return Saver.save(T).data(); });
+          NewArgs, CAS, [&](const Twine &T) { return Saver.save(T).data(); });
       if (!RootID) {
         consumeError(Comms.putScanResultFailed(toString(RootID.takeError()),
                                                DiagsOS.str()));
@@ -1081,7 +1076,7 @@ static Expected<llvm::cas::CASID> scanAndUpdateCC1InlineWithTool(
     tooling::dependencies::DependencyScanningTool &Tool,
     DiagnosticConsumer &DiagsConsumer, raw_ostream *VerboseOS, const char *Exec,
     ArrayRef<const char *> InputArgs, StringRef WorkingDirectory,
-    SmallVectorImpl<const char *> &OutputArgs, llvm::cas::ObjectStore &DB,
+    SmallVectorImpl<const char *> &OutputArgs, std::shared_ptr<llvm::cas::ObjectStore> DB,
     llvm::function_ref<const char *(const Twine &)> SaveArg) {
   DiagnosticOptions DiagOpts;
   DiagnosticsEngine Diags(new DiagnosticIDs(), DiagOpts);
@@ -1117,12 +1112,8 @@ scanAndUpdateCC1Inline(const char *Exec, ArrayRef<const char *> InputArgs,
       tooling::dependencies::ScanningMode::DependencyDirectivesScan,
       tooling::dependencies::ScanningOutputFormat::IncludeTree, CASOpts, DB,
       Cache);
-  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> UnderlyingFS =
-      llvm::vfs::createPhysicalFileSystem();
-  UnderlyingFS =
-      llvm::cas::createCASProvidingFileSystem(DB, std::move(UnderlyingFS));
   tooling::dependencies::DependencyScanningTool Tool(Service,
-                                                     std::move(UnderlyingFS));
+                                                     llvm::vfs::createPhysicalFileSystem());
 
   std::unique_ptr<DiagnosticOptions> DiagOpts =
       CreateAndPopulateDiagOpts(InputArgs);
@@ -1131,7 +1122,7 @@ scanAndUpdateCC1Inline(const char *Exec, ArrayRef<const char *> InputArgs,
 
   auto E = scanAndUpdateCC1InlineWithTool(
                Tool, *DiagsConsumer, /*VerboseOS*/ nullptr, Exec, InputArgs,
-               WorkingDirectory, OutputArgs, *DB, SaveArg)
+               WorkingDirectory, OutputArgs, DB, SaveArg)
                .moveInto(RootID);
   if (E) {
     Diag.Report(diag::err_cas_depscan_failed) << std::move(E);