[clang][cas] Move include-tree-specific code out of core scanner

This hoists all the include-tree specific code out of the core
dependency scanner, and instead injects the necessary PPCallbacks as
part IncludeTreeActionController::initialize. In addition to improved
division of responsibility in the code, this allows include-tree to be
used with ModuleDepCollector, which will (in future commits) allow us to
use include-tree to build and import modules.

(cherry picked from commit 91fa5b1)

Author: benlangmuir

clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp

@@ -234,6 +234,50 @@ class IncludeTreeActionController : public CallbackActionController {
   llvm::DenseMap<const FileEntry *, Optional<cas::ObjectRef>> ObjectForFile;
   Optional<llvm::Error> ErrorToReport;
 };
+
+/// A utility for adding \c PPCallbacks to a compiler instance at the
+/// appropriate time.
+struct PPCallbacksDependencyCollector : public DependencyCollector {
+  using MakeCB =
+      llvm::unique_function<std::unique_ptr<PPCallbacks>(Preprocessor &)>;
+  MakeCB Create;
+  PPCallbacksDependencyCollector(MakeCB Create) : Create(std::move(Create)) {}
+  void attachToPreprocessor(Preprocessor &PP) final {
+    std::unique_ptr<PPCallbacks> CB = Create(PP);
+    assert(CB);
+    PP.addPPCallbacks(std::move(CB));
+  }
+};
+
+struct IncludeTreePPCallbacks : public PPCallbacks {
+  DependencyActionController &Controller;
+  Preprocessor &PP;
+
+public:
+  IncludeTreePPCallbacks(DependencyActionController &Controller,
+                         Preprocessor &PP)
+      : Controller(Controller), PP(PP) {}
+
+  void LexedFileChanged(FileID FID, LexedFileChangeReason Reason,
+                        SrcMgr::CharacteristicKind FileType, FileID PrevFID,
+                        SourceLocation Loc) override {
+    switch (Reason) {
+    case LexedFileChangeReason::EnterFile:
+      Controller.enteredInclude(PP, FID);
+      break;
+    case LexedFileChangeReason::ExitFile: {
+      Controller.exitedInclude(PP, FID, PrevFID, Loc);
+      break;
+    }
+    }
+  }
+
+  void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
+                  OptionalFileEntryRef File,
+                  SrcMgr::CharacteristicKind FileType) override {
+    Controller.handleHasIncludeCheck(PP, File.has_value());
+  }
+};
 } // namespace
 
 /// The PCH recorded file paths with canonical paths, create a VFS that
@@ -274,6 +318,14 @@ Error IncludeTreeActionController::initialize(
   };
   ensurePathRemapping();
 
+  // Attach callbacks for the IncludeTree of the TU. The preprocessor
+  // does not exist yet, so we need to indirect this via DependencyCollector.
+  auto DC = std::make_shared<PPCallbacksDependencyCollector>(
+      [this](Preprocessor &PP) {
+        return std::make_unique<IncludeTreePPCallbacks>(*this, PP);
+      });
+  ScanInstance.addDependencyCollector(std::move(DC));
+
   return Error::success();
 }
 

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

@@ -161,48 +161,17 @@ static void sanitizeDiagOpts(DiagnosticOptions &DiagOpts) {
   DiagOpts.IgnoreWarnings = true;
 }
 
-struct IncludeTreePPCallbacks : public PPCallbacks {
-  DependencyActionController &Controller;
-  Preprocessor &PP;
-
-public:
-  IncludeTreePPCallbacks(DependencyActionController &Controller,
-                         Preprocessor &PP)
-      : Controller(Controller), PP(PP) {}
-
-  void LexedFileChanged(FileID FID, LexedFileChangeReason Reason,
-                        SrcMgr::CharacteristicKind FileType, FileID PrevFID,
-                        SourceLocation Loc) override {
-    switch (Reason) {
-    case LexedFileChangeReason::EnterFile:
-      Controller.enteredInclude(PP, FID);
-      break;
-    case LexedFileChangeReason::ExitFile: {
-      Controller.exitedInclude(PP, FID, PrevFID, Loc);
-      break;
-    }
-    }
-  }
-
-  void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
-                  Optional<FileEntryRef> File,
-                  SrcMgr::CharacteristicKind FileType) override {
-    Controller.handleHasIncludeCheck(PP, File.has_value());
-  }
-};
-
-class IncludeTreeCollector : public DependencyFileGenerator {
-  DependencyActionController &Controller;
-  std::unique_ptr<DependencyOutputOptions> Opts;
-  bool EmitDependencyFile = false;
+/// Builds a dependency file after reversing prefix mappings. This allows
+/// emitting a .d file that has real paths where they would otherwise be
+/// canonicalized.
+class ReversePrefixMappingDependencyFileGenerator
+    : public DependencyFileGenerator {
   llvm::PrefixMapper ReverseMapper;
 
 public:
-  IncludeTreeCollector(DependencyActionController &Controller,
-                       std::unique_ptr<DependencyOutputOptions> Opts,
-                       bool EmitDependencyFile)
-      : DependencyFileGenerator(*Opts), Controller(Controller),
-        Opts(std::move(Opts)), EmitDependencyFile(EmitDependencyFile) {}
+  ReversePrefixMappingDependencyFileGenerator(
+      const DependencyOutputOptions &Opts)
+      : DependencyFileGenerator(Opts) {}
 
   Error initialize(const CompilerInvocation &CI,
                    const DepscanPrefixMapping &PrefixMapping) {
@@ -217,11 +186,6 @@ class IncludeTreeCollector : public DependencyFileGenerator {
     return Error::success();
   }
 
-  void attachToPreprocessor(Preprocessor &PP) override {
-    PP.addPPCallbacks(std::make_unique<IncludeTreePPCallbacks>(Controller, PP));
-    DependencyFileGenerator::attachToPreprocessor(PP);
-  }
-
   void maybeAddDependency(StringRef Filename, bool FromModule, bool IsSystem,
                           bool IsModuleFile, bool IsMissing) override {
     if (ReverseMapper.empty())
@@ -235,11 +199,6 @@ class IncludeTreeCollector : public DependencyFileGenerator {
     return DependencyFileGenerator::maybeAddDependency(
         New, FromModule, IsSystem, IsModuleFile, IsMissing);
   }
-
-  void finishedMainFile(DiagnosticsEngine &Diags) override {
-    if (EmitDependencyFile)
-      DependencyFileGenerator::finishedMainFile(Diags);
-  }
 };
 
 /// See \c WrapScanModuleBuildAction.
@@ -455,17 +414,19 @@ class DependencyScanningAction : public tooling::ToolAction {
           std::make_shared<DependencyConsumerForwarder>(
               std::move(Opts), WorkingDirectory, Consumer, EmitDependencyFile));
       break;
-    case ScanningOutputFormat::IncludeTree: {
-      auto IncTreeCollector = std::make_shared<IncludeTreeCollector>(
-          Controller, std::move(Opts), EmitDependencyFile);
-      if (Error E = IncTreeCollector->initialize(
-              ScanInstance.getInvocation(), *Controller.getPrefixMapping()))
-        return reportError(std::move(E));
-      ScanInstance.addDependencyCollector(std::move(IncTreeCollector));
-      break;
-    }
+    case ScanningOutputFormat::IncludeTree:
     case ScanningOutputFormat::Full:
     case ScanningOutputFormat::FullTree:
+      if (EmitDependencyFile) {
+        auto DFG =
+            std::make_shared<ReversePrefixMappingDependencyFileGenerator>(
+                *Opts);
+        if (auto *Mapping = Controller.getPrefixMapping())
+          if (auto E = DFG->initialize(ScanInstance.getInvocation(), *Mapping))
+            return reportError(std::move(E));
+        ScanInstance.addDependencyCollector(std::move(DFG));
+      }
+
       MDC = std::make_shared<ModuleDepCollector>(
           std::move(Opts), ScanInstance, Consumer, Controller,
           OriginalInvocation, OptimizeArgs, EagerLoadModules);