1 files changed, 96 insertions, 44 deletions

diff --git a/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp b/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp
index 4868f2663796..f382c202f8c2 100644
--- a/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp
+++ b/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp
@@ -8,9 +8,12 @@
 
 #include "clang/Tooling/DependencyScanning/DependencyScanningWorker.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
+#include "clang/Lex/PreprocessorOptions.h"
+#include "clang/Tooling/DependencyScanning/DependencyScanningService.h"
 #include "clang/Tooling/Tooling.h"
 
 using namespace clang;
@@ -19,21 +22,25 @@ using namespace dependencies;
 
 namespace {
 
-/// Prints out all of the gathered dependencies into a string.
-class DependencyPrinter : public DependencyFileGenerator {
+/// Forwards the gatherered dependencies to the consumer.
+class DependencyConsumerForwarder : public DependencyFileGenerator {
 public:
-  DependencyPrinter(std::unique_ptr<DependencyOutputOptions> Opts,
-                    std::string &S)
-      : DependencyFileGenerator(*Opts), Opts(std::move(Opts)), S(S) {}
+  DependencyConsumerForwarder(std::unique_ptr<DependencyOutputOptions> Opts,
+                              DependencyConsumer &C)
+      : DependencyFileGenerator(*Opts), Opts(std::move(Opts)), C(C) {}
 
   void finishedMainFile(DiagnosticsEngine &Diags) override {
-    llvm::raw_string_ostream OS(S);
-    outputDependencyFile(OS);
+    llvm::SmallString<256> CanonPath;
+    for (const auto &File : getDependencies()) {
+      CanonPath = File;
+      llvm::sys::path::remove_dots(CanonPath, /*remove_dot_dot=*/true);
+      C.handleFileDependency(*Opts, CanonPath);
+    }
   }
 
 private:
   std::unique_ptr<DependencyOutputOptions> Opts;
-  std::string &S;
+  DependencyConsumer &C;
 };
 
 /// A proxy file system that doesn't call `chdir` when changing the working
@@ -62,10 +69,12 @@ private:
 /// dependency scanning for the given compiler invocation.
 class DependencyScanningAction : public tooling::ToolAction {
 public:
-  DependencyScanningAction(StringRef WorkingDirectory,
-                           std::string &DependencyFileContents)
-      : WorkingDirectory(WorkingDirectory),
-        DependencyFileContents(DependencyFileContents) {}
+  DependencyScanningAction(
+      StringRef WorkingDirectory, DependencyConsumer &Consumer,
+      llvm::IntrusiveRefCntPtr<DependencyScanningWorkerFilesystem> DepFS,
+      ExcludedPreprocessorDirectiveSkipMapping *PPSkipMappings)
+      : WorkingDirectory(WorkingDirectory), Consumer(Consumer),
+        DepFS(std::move(DepFS)), PPSkipMappings(PPSkipMappings) {}
 
   bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
                      FileManager *FileMgr,
@@ -74,8 +83,6 @@ public:
     // Create a compiler instance to handle the actual work.
     CompilerInstance Compiler(std::move(PCHContainerOps));
     Compiler.setInvocation(std::move(Invocation));
-    FileMgr->getFileSystemOpts().WorkingDir = WorkingDirectory;
-    Compiler.setFileManager(FileMgr);
 
     // Don't print 'X warnings and Y errors generated'.
     Compiler.getDiagnosticOpts().ShowCarets = false;
@@ -84,6 +91,32 @@ public:
     if (!Compiler.hasDiagnostics())
       return false;
 
+    // Use the dependency scanning optimized file system if we can.
+    if (DepFS) {
+      const CompilerInvocation &CI = Compiler.getInvocation();
+      // Add any filenames that were explicity passed in the build settings and
+      // that might be opened, as we want to ensure we don't run source
+      // minimization on them.
+      DepFS->IgnoredFiles.clear();
+      for (const auto &Entry : CI.getHeaderSearchOpts().UserEntries)
+        DepFS->IgnoredFiles.insert(Entry.Path);
+      for (const auto &Entry : CI.getHeaderSearchOpts().VFSOverlayFiles)
+        DepFS->IgnoredFiles.insert(Entry);
+
+      // Support for virtual file system overlays on top of the caching
+      // filesystem.
+      FileMgr->setVirtualFileSystem(createVFSFromCompilerInvocation(
+          CI, Compiler.getDiagnostics(), DepFS));
+
+      // Pass the skip mappings which should speed up excluded conditional block
+      // skipping in the preprocessor.
+      if (PPSkipMappings)
+        Compiler.getPreprocessorOpts()
+            .ExcludedConditionalDirectiveSkipMappings = PPSkipMappings;
+    }
+
+    FileMgr->getFileSystemOpts().WorkingDir = WorkingDirectory;
+    Compiler.setFileManager(FileMgr);
     Compiler.createSourceManager(*FileMgr);
 
     // Create the dependency collector that will collect the produced
@@ -93,57 +126,76 @@ public:
     // invocation to the collector. The options in the invocation are reset,
     // which ensures that the compiler won't create new dependency collectors,
     // and thus won't write out the extra '.d' files to disk.
-    auto Opts = llvm::make_unique<DependencyOutputOptions>(
+    auto Opts = std::make_unique<DependencyOutputOptions>(
         std::move(Compiler.getInvocation().getDependencyOutputOpts()));
     // We need at least one -MT equivalent for the generator to work.
     if (Opts->Targets.empty())
       Opts->Targets = {"clang-scan-deps dependency"};
-    Compiler.addDependencyCollector(std::make_shared<DependencyPrinter>(
-        std::move(Opts), DependencyFileContents));
+    Compiler.addDependencyCollector(
+        std::make_shared<DependencyConsumerForwarder>(std::move(Opts),
+                                                      Consumer));
 
-    auto Action = llvm::make_unique<PreprocessOnlyAction>();
+    auto Action = std::make_unique<PreprocessOnlyAction>();
     const bool Result = Compiler.ExecuteAction(*Action);
-    FileMgr->clearStatCache();
+    if (!DepFS)
+      FileMgr->clearStatCache();
     return Result;
   }
 
 private:
   StringRef WorkingDirectory;
-  /// The dependency file will be written to this string.
-  std::string &DependencyFileContents;
+  DependencyConsumer &Consumer;
+  llvm::IntrusiveRefCntPtr<DependencyScanningWorkerFilesystem> DepFS;
+  ExcludedPreprocessorDirectiveSkipMapping *PPSkipMappings;
 };
 
 } // end anonymous namespace
 
-DependencyScanningWorker::DependencyScanningWorker() {
+DependencyScanningWorker::DependencyScanningWorker(
+    DependencyScanningService &Service) {
   DiagOpts = new DiagnosticOptions();
   PCHContainerOps = std::make_shared<PCHContainerOperations>();
-  /// FIXME: Use the shared file system from the service for fast scanning
-  /// mode.
-  WorkerFS = new ProxyFileSystemWithoutChdir(llvm::vfs::getRealFileSystem());
+  RealFS = new ProxyFileSystemWithoutChdir(llvm::vfs::getRealFileSystem());
+  if (Service.canSkipExcludedPPRanges())
+    PPSkipMappings =
+        std::make_unique<ExcludedPreprocessorDirectiveSkipMapping>();
+  if (Service.getMode() == ScanningMode::MinimizedSourcePreprocessing)
+    DepFS = new DependencyScanningWorkerFilesystem(
+        Service.getSharedCache(), RealFS, PPSkipMappings.get());
+  if (Service.canReuseFileManager())
+    Files = new FileManager(FileSystemOptions(), RealFS);
 }
 
-llvm::Expected<std::string>
-DependencyScanningWorker::getDependencyFile(const std::string &Input,
-                                            StringRef WorkingDirectory,
-                                            const CompilationDatabase &CDB) {
+static llvm::Error runWithDiags(
+    DiagnosticOptions *DiagOpts,
+    llvm::function_ref<bool(DiagnosticConsumer &DC)> BodyShouldSucceed) {
   // Capture the emitted diagnostics and report them to the client
   // in the case of a failure.
   std::string DiagnosticOutput;
   llvm::raw_string_ostream DiagnosticsOS(DiagnosticOutput);
-  TextDiagnosticPrinter DiagPrinter(DiagnosticsOS, DiagOpts.get());
-
-  WorkerFS->setCurrentWorkingDirectory(WorkingDirectory);
-  tooling::ClangTool Tool(CDB, Input, PCHContainerOps, WorkerFS);
-  Tool.clearArgumentsAdjusters();
-  Tool.setRestoreWorkingDir(false);
-  Tool.setPrintErrorMessage(false);
-  Tool.setDiagnosticConsumer(&DiagPrinter);
-  std::string Output;
-  DependencyScanningAction Action(WorkingDirectory, Output);
-  if (Tool.run(&Action)) {
-    return llvm::make_error<llvm::StringError>(DiagnosticsOS.str(),
-                                               llvm::inconvertibleErrorCode());
-  }
-  return Output;
+  TextDiagnosticPrinter DiagPrinter(DiagnosticsOS, DiagOpts);
+
+  if (BodyShouldSucceed(DiagPrinter))
+    return llvm::Error::success();
+  return llvm::make_error<llvm::StringError>(DiagnosticsOS.str(),
+                                             llvm::inconvertibleErrorCode());
+}
+
+llvm::Error DependencyScanningWorker::computeDependencies(
+    const std::string &Input, StringRef WorkingDirectory,
+    const CompilationDatabase &CDB, DependencyConsumer &Consumer) {
+  RealFS->setCurrentWorkingDirectory(WorkingDirectory);
+  return runWithDiags(DiagOpts.get(), [&](DiagnosticConsumer &DC) {
+    /// Create the tool that uses the underlying file system to ensure that any
+    /// file system requests that are made by the driver do not go through the
+    /// dependency scanning filesystem.
+    tooling::ClangTool Tool(CDB, Input, PCHContainerOps, RealFS, Files);
+    Tool.clearArgumentsAdjusters();
+    Tool.setRestoreWorkingDir(false);
+    Tool.setPrintErrorMessage(false);
+    Tool.setDiagnosticConsumer(&DC);
+    DependencyScanningAction Action(WorkingDirectory, Consumer, DepFS,
+                                    PPSkipMappings.get());
+    return !Tool.run(&Action);
+  });
 }