[analyzer] Add a thin abstraction layer between libCrossTU and libAnalysis.

[NoQ]

Summary

After like ~three reverts of D67422, the last known problem with that patch is a circular dependency that that patch introduces: libCrossTU -> libFrontend -> libSema -> libAnalysis -> libCrossTU. Namely, D67422 causes libAnalysis to depend on libCrossTU due to PlistDiagnosticConsumer (which is moved into libAnalysis in that patch) potentially requiring cross-TU macro expansion information to bundle with the plist.

Circular dependencies are bad because they're not allowed under -DBUILD_SHARED_LIBS. It's likely that this problem can be resolved purely on cmake side and i simply wasn't trying hard enough to find a solution (on the other hand, say, libTooling had to deal with this by introducing libToolingCore - a smaller sub-library with less dependencies).

But, anyway, given that the dependency is extremely tiny, i suggest resolving it by adding a tiny abstraction layer that'd eliminate the dependency entirely. Namely, i'd like to add a virtual interface under CrossTranslationUnitContext. Such interface is defined in libAnalysis and implemented by the CrossTranslationUnitContext class in libCrossTU. This vaguely makes sense because libAnalysis is a low-level collection of analysis algorithms whereas libCrossTU is high-level, even frontend-level management of entire clang invocations so calling from libAnalysis to libCrossTU feels like layering violation.

In this patch i add only one function to the interface. If you guys want i can move all (or at least some) public methods of CrossTranslationUnitContext into that interface but there's no immediate need for that.

[NoQ]

Whoops, fix typos in header formalities.

[xazax.hun]

LGTM!

[martong]

Looks good, thanks!

[vsavchenko]

LGTM!

[martong]

clang/include/clang/CrossTU/CrossTranslationUnit.h

124

Why don't we have a dependency in libCrossTU to libAnalysis? In the CMakeLists.txt?
Here we implement the CrossTUAnalysisHelper's abstract virtual function thus we include the CrossTUAnalysisHelper.h. But
CMake should know about the dependency even if this is only a header only dependency, shouldn't it? (We were talking about this with @steakhal.)

[steakhal]

clang/include/clang/CrossTU/CrossTranslationUnit.h

124

IMO if a library (A) does not depend on another library (B), that means we can safely delete all files of the B and still be able to compile and run the A.
In this case, it won't, as the given header lives under B. So to make sure this principle works, we should state the dependency on B in A.

---

In our case, it means that libCrossTU depends on libAnalysis, as the CrossTUAnalysisHelper lives in libAnalysis which is used by libCrossTU to implement the CrossTranslationUnitContext.

[NoQ]

clang/include/clang/CrossTU/CrossTranslationUnit.h

124

There's already an indirect dependency (you have to look at all those CMakeLists.txt in order to notice it): libCrossTU -> libFrontend -> libSema -> libAnalysis (and a few other paths through the dependency graph). There's no harm in writing it down explicitly but there's also no explicit need and i'd rather have it not specified directly (if there's too little dependencies it'll warn us) than to specify too much by accident (there's no warning for unused dependencies and if a dependency eventually becomes unused it may accidentally prevent people from adding the dependencies they actually need).

[steakhal]

clang/include/clang/CrossTU/CrossTranslationUnit.h

124

Thank you for the explanation.

[NoQ]

clang/lib/Analysis/PlistPathDiagnosticConsumer.cpp

993

We were reverted because there's still a dependency on ASTUnit which lives in libFrontend. I guess i'll simplify the virtual method to return (MacroLoc, PPToUse) directly (?) (the old method will still remain on CrossTranslationUnitContext).

[steakhal]

clang/lib/Analysis/PlistPathDiagnosticConsumer.cpp

993

I don't see much uses of this function in the codebase. Why do you think it worth keeping it?

As a side-note, I'm planning to upstream some serious changes in macro expansion handling. Which will change the highlighted parts, probably resolving this circular dependency too.
Let me polish my work, and expect the patch on monday or tuesday.

clang/include/clang/Analysis/CrossTUAnalysisHelper.h

+//===- CrossTUAnalysisHelper.h - Abstraction layer for CTU ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CLANG_ANALYSIS_CROSS_TU_HELPER_H
+#define LLVM_CLANG_ANALYSIS_CROSS_TU_HELPER_H
+
+#include "llvm/ADT/Optional.h"
+#include "clang/Basic/SourceManager.h"
+
+namespace clang {
+
+class ASTUnit;
+
+/// This class is an abstract interface acting as a bridge between
+/// an analysis that requires lookups across translation units (a user
+/// of that interface) and the facility that implements such lookups
+/// (an implementation of that interface). This is useful to break direct
+/// link-time dependencies between the (possibly shared) libraries in which
+/// the user and the implementation live.
+class CrossTUAnalysisHelper {
+public:
+  /// Determine the original source location in the original TU for an
+  /// imported source location.
+  /// \p ToLoc Source location in the imported-to AST.
+  /// \return Source location in the imported-from AST and the corresponding
+  /// ASTUnit object (the AST was loaded from a file using an internal ASTUnit
+  /// object that is returned here).
+  /// If any error happens (ToLoc is a non-imported source location) empty is
+  /// returned.
+  virtual llvm::Optional<std::pair<SourceLocation /*FromLoc*/, ASTUnit *>>
+  getImportedFromSourceLocation(SourceLocation ToLoc) const = 0;
+
+  virtual ~CrossTUAnalysisHelper() {}
+};
+} // namespace clang
+
+#endif // LLVM_CLANG_ANALYSIS_CROSS_TU_HELPER_H

clang/include/clang/Analysis/PathDiagnosticConsumers.h

 #include <vector>
 
 #include "clang/Analysis/PathDiagnostic.h"
 
 namespace clang {
 
 class AnalyzerOptions;
 class Preprocessor;
-namespace cross_tu {
-class CrossTranslationUnitContext;
-}
+class CrossTUAnalysisHelper;
 
 namespace ento {
 
 class PathDiagnosticConsumer;
 typedef std::vector<PathDiagnosticConsumer *> PathDiagnosticConsumers;
 
 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN)                    \
   void CREATEFN(PathDiagnosticConsumerOptions Diagopts,                        \
                 PathDiagnosticConsumers &C, const std::string &Prefix,         \
-                const Preprocessor &PP,                                        \
-                const cross_tu::CrossTranslationUnitContext &CTU);
+                const Preprocessor &PP, const CrossTUAnalysisHelper &CTU);
 #include "clang/Analysis/PathDiagnosticConsumers.def"
 
 } // end 'ento' namespace
 } // end 'clang' namespace
 
 #endif

clang/include/clang/CrossTU/CrossTranslationUnit.h

 //===--- CrossTranslationUnit.h - -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file provides an interface to load binary AST dumps on demand. This
 //  feature can be utilized for tools that require cross translation unit
 //  support.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_CROSSTU_CROSSTRANSLATIONUNIT_H
 #define LLVM_CLANG_CROSSTU_CROSSTRANSLATIONUNIT_H
 
+#include "clang/Analysis/CrossTUAnalysisHelper.h"
 #include "clang/AST/ASTImporterSharedState.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Path.h"

 ///
 /// This class can load definitions from external AST sources.
 /// The loaded definition will be merged back to the original AST using the
 /// AST Importer.
 /// In order to use this class, an index file is required that describes
 /// the locations of the AST files for each definition.
 ///
 /// Note that this class also implements caching.
-class CrossTranslationUnitContext {
+class CrossTranslationUnitContext : public CrossTUAnalysisHelper {
 public:
   CrossTranslationUnitContext(CompilerInstance &CI);
-  ~CrossTranslationUnitContext();
+  ~CrossTranslationUnitContext() override;
 
   /// This function loads a function or variable definition from an
   ///        external AST file and merges it into the original AST.
   ///
   /// This method should only be used on functions that have no definitions or
   /// variables that have no initializer in
   /// the current translation unit. A function definition with the same
   /// declaration will be looked up in the index file which should be in the
public:
   /// imported source location.
   /// \p ToLoc Source location in the imported-to AST.
   /// \return Source location in the imported-from AST and the corresponding
   /// ASTUnit object (the AST was loaded from a file using an internal ASTUnit
   /// object that is returned here).
   /// If any error happens (ToLoc is a non-imported source location) empty is
   /// returned.
   llvm::Optional<std::pair<SourceLocation /*FromLoc*/, ASTUnit *>>
-  getImportedFromSourceLocation(const clang::SourceLocation &ToLoc) const;
+  getImportedFromSourceLocation(SourceLocation ToLoc) const override;
 
 private:
   using ImportedFileIDMap =
       llvm::DenseMap<FileID, std::pair<FileID, ASTUnit *>>;
 
   void lazyInitImporterSharedSt(TranslationUnitDecl *ToTU);
   ASTImporter &getOrCreateASTImporter(ASTUnit *Unit);
   template <typename T>

clang/lib/Analysis/HTMLPathDiagnosticConsumer.cpp

 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 using namespace clang;
 using namespace ento;
 
+namespace clang {
+class CrossTUAnalysisHelper;
+}
+
 //===----------------------------------------------------------------------===//
 // Boilerplate.
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 class HTMLPathDiagnosticConsumer : public PathDiagnosticConsumer {
   PathDiagnosticConsumerOptions DiagOpts;
void dumpCoverageData(const PathDiagnostic &D,
                         llvm::raw_string_ostream &os);
 };
 
 } // namespace
 
 void ento::createHTMLDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &OutputDir, const Preprocessor &PP,
-    const cross_tu::CrossTranslationUnitContext &CTU) {
+    const CrossTUAnalysisHelper &CTU) {
 
   // FIXME: HTML is currently our default output type, but if the output
   // directory isn't specified, it acts like if it was in the minimal text
   // output mode. This doesn't make much sense, we should have the minimal text
   // as our default. In the case of backward compatibility concerns, this could
   // be preserved with -analyzer-config-compatibility-mode=true.
   createTextMinimalPathDiagnosticConsumer(DiagOpts, C, OutputDir, PP, CTU);
 
   // TODO: Emit an error here.
   if (OutputDir.empty())
     return;
 
   C.push_back(
       new HTMLPathDiagnosticConsumer(std::move(DiagOpts), OutputDir, PP, true));
 }
 
 void ento::createHTMLSingleFileDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &OutputDir, const Preprocessor &PP,
-    const cross_tu::CrossTranslationUnitContext &CTU) {
+    const CrossTUAnalysisHelper &CTU) {
   createTextMinimalPathDiagnosticConsumer(DiagOpts, C, OutputDir, PP, CTU);
 
   // TODO: Emit an error here.
   if (OutputDir.empty())
     return;
 
   C.push_back(new HTMLPathDiagnosticConsumer(std::move(DiagOpts), OutputDir, PP,
                                              false));

clang/lib/Analysis/PlistHTMLPathDiagnosticConsumer.cpp

 #include "clang/Analysis/PathDiagnosticConsumers.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/CrossTU/CrossTranslationUnit.h"
 #include "clang/Lex/Preprocessor.h"
 
 using namespace clang;
 using namespace ento;
 
+namespace clang {
+class CrossTUAnalysisHelper;
+}
+
 void ento::createPlistHTMLDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &Prefix, const Preprocessor &PP,
-    const cross_tu::CrossTranslationUnitContext &CTU) {
+    const CrossTUAnalysisHelper &CTU) {
   createHTMLDiagnosticConsumer(
       DiagOpts, C, std::string(llvm::sys::path::parent_path(Prefix)), PP, CTU);
   createPlistMultiFileDiagnosticConsumer(DiagOpts, C, Prefix, PP, CTU);
   createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, Prefix, PP,
                                           CTU);
 }

clang/lib/Analysis/PlistPathDiagnosticConsumer.cpp

 //===--- PlistPathDiagnosticConsumer.cpp - Plist Diagnostics ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the PlistPathDiagnosticConsumer object.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Analysis/CrossTUAnalysisHelper.h"
 #include "clang/Analysis/IssueHash.h"
 #include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Analysis/PathDiagnosticConsumers.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/PlistSupport.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Version.h"
-#include "clang/CrossTU/CrossTranslationUnit.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/TokenConcatenation.h"
 #include "clang/Rewrite/Core/HTMLRewrite.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Casting.h"
 #include <memory>
 
 using namespace clang;
 using namespace ento;
 using namespace markup;
 
 //===----------------------------------------------------------------------===//
 // Declarations of helper classes and functions for emitting bug reports in
 // plist format.
 //===----------------------------------------------------------------------===//
 
 namespace {
   class PlistPathDiagnosticConsumer : public PathDiagnosticConsumer {
     PathDiagnosticConsumerOptions DiagOpts;
     const std::string OutputFile;
     const Preprocessor &PP;
-    const cross_tu::CrossTranslationUnitContext &CTU;
+    const CrossTUAnalysisHelper &CTU;
     const bool SupportsCrossFileDiagnostics;
 
     void printBugPath(llvm::raw_ostream &o, const FIDMap &FM,
                       const PathPieces &Path);
 
   public:
     PlistPathDiagnosticConsumer(PathDiagnosticConsumerOptions DiagOpts,
                      const std::string &OutputFile, const Preprocessor &PP,
-                     const cross_tu::CrossTranslationUnitContext &CTU,
+                     const CrossTUAnalysisHelper &CTU,
                      bool supportsMultipleFiles);
 
     ~PlistPathDiagnosticConsumer() override {}
 
     void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
                               FilesMade *filesMade) override;
 
     StringRef getName() const override {

 } // end anonymous namespace
 
 namespace {
 
 /// A helper class for emitting a single report.
 class PlistPrinter {
   const FIDMap& FM;
   const Preprocessor &PP;
-  const cross_tu::CrossTranslationUnitContext &CTU;
+  const CrossTUAnalysisHelper &CTU;
   llvm::SmallVector<const PathDiagnosticMacroPiece *, 0> MacroPieces;
 
 public:
   PlistPrinter(const FIDMap& FM,
                const Preprocessor &PP,
-               const cross_tu::CrossTranslationUnitContext &CTU)
+               const CrossTUAnalysisHelper &CTU)
     : FM(FM), PP(PP), CTU(CTU) {
   }
 
   void ReportDiag(raw_ostream &o, const PathDiagnosticPiece& P) {
     ReportPiece(o, P, /*indent*/ 4, /*depth*/ 0, /*includeControlFlow*/ true);
   }
 
   /// Print the expansions of the collected macro pieces.

 static void printCoverage(const PathDiagnostic *D,
                           unsigned InputIndentLevel,
                           SmallVectorImpl<FileID> &Fids,
                           FIDMap &FM,
                           llvm::raw_fd_ostream &o);
 
 static ExpansionInfo
 getExpandedMacro(SourceLocation MacroLoc, const Preprocessor &PP,
-                 const cross_tu::CrossTranslationUnitContext &CTU);
+                 const CrossTUAnalysisHelper &CTU);
 
 //===----------------------------------------------------------------------===//
 // Methods of PlistPrinter.
 //===----------------------------------------------------------------------===//
 
 void PlistPrinter::EmitRanges(raw_ostream &o,
                               const ArrayRef<SourceRange> Ranges,
                               unsigned indent) {

 }
 
 //===----------------------------------------------------------------------===//
 // Methods of PlistPathDiagnosticConsumer.
 //===----------------------------------------------------------------------===//
 
 PlistPathDiagnosticConsumer::PlistPathDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, const std::string &output,
-    const Preprocessor &PP, const cross_tu::CrossTranslationUnitContext &CTU,
+    const Preprocessor &PP, const CrossTUAnalysisHelper &CTU,
     bool supportsMultipleFiles)
     : DiagOpts(std::move(DiagOpts)), OutputFile(output), PP(PP), CTU(CTU),
       SupportsCrossFileDiagnostics(supportsMultipleFiles) {
   // FIXME: Will be used by a later planned change.
   (void)this->CTU;
 }
 
 void ento::createPlistDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &OutputFile, const Preprocessor &PP,
-    const cross_tu::CrossTranslationUnitContext &CTU) {
+    const CrossTUAnalysisHelper &CTU) {
 
   // TODO: Emit an error here.
   if (OutputFile.empty())
     return;
 
   C.push_back(new PlistPathDiagnosticConsumer(DiagOpts, OutputFile, PP, CTU,
                                               /*supportsMultipleFiles=*/false));
   createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, OutputFile,
                                           PP, CTU);
 }
 
 void ento::createPlistMultiFileDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &OutputFile, const Preprocessor &PP,
-    const cross_tu::CrossTranslationUnitContext &CTU) {
+    const CrossTUAnalysisHelper &CTU) {
 
   // TODO: Emit an error here.
   if (OutputFile.empty())
     return;
 
   C.push_back(new PlistPathDiagnosticConsumer(DiagOpts, OutputFile, PP, CTU,
                                               /*supportsMultipleFiles=*/true));
   createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, OutputFile,
static const MacroInfo *getMacroInfoForLocation(const Preprocessor &PP,
                                                 SourceLocation Loc);
 
 //===----------------------------------------------------------------------===//
 // Definitions of helper functions and methods for expanding macros.
 //===----------------------------------------------------------------------===//
 
 static ExpansionInfo
 getExpandedMacro(SourceLocation MacroLoc, const Preprocessor &PP,
-                 const cross_tu::CrossTranslationUnitContext &CTU) {
+                 const CrossTUAnalysisHelper &CTU) {
 
   const Preprocessor *PPToUse = &PP;
   if (auto LocAndUnit = CTU.getImportedFromSourceLocation(MacroLoc)) {
     MacroLoc = LocAndUnit->first;
     PPToUse = &LocAndUnit->second->getPreprocessor();
   }
 
   llvm::SmallString<200> ExpansionBuf;
   llvm::raw_svector_ostream OS(ExpansionBuf);
   TokenPrinter Printer(OS, *PPToUse);
   llvm::SmallPtrSet<IdentifierInfo*, 8> AlreadyProcessedTokens;
 
   std::string MacroName = getMacroNameAndPrintExpansion(

clang/lib/Analysis/SarifPathDiagnosticConsumer.cpp

 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace clang;
 using namespace ento;
 
+namespace clang {
+class CrossTUAnalysisHelper;
+}
+
 namespace {
 class SarifPathDiagnosticConsumer : public PathDiagnosticConsumer {
   std::string OutputFile;
   const LangOptions &LO;
 
 public:
   SarifPathDiagnosticConsumer(const std::string &Output, const LangOptions &LO)
       : OutputFile(Output), LO(LO) {}
   ~SarifPathDiagnosticConsumer() override = default;
 
   void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
                             FilesMade *FM) override;
 
   StringRef getName() const override { return "SarifPathDiagnosticConsumer"; }
   PathGenerationScheme getGenerationScheme() const override { return Minimal; }
   bool supportsLogicalOpControlFlow() const override { return true; }
   bool supportsCrossFileDiagnostics() const override { return true; }
 };
 } // end anonymous namespace
 
 void ento::createSarifDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &Output, const Preprocessor &PP,
-    const cross_tu::CrossTranslationUnitContext &CTU) {
+    const CrossTUAnalysisHelper &CTU) {
 
   // TODO: Emit an error here.
   if (Output.empty())
     return;
 
   C.push_back(new SarifPathDiagnosticConsumer(Output, PP.getLangOpts()));
   createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, Output, PP,
                                           CTU);

clang/lib/Analysis/TextPathDiagnosticConsumer.cpp

 //===--- TextPathDiagnosticConsumer.cpp - Text Diagnostics ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the TextPathDiagnosticConsumer object.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Analysis/PathDiagnosticConsumers.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Version.h"
-#include "clang/CrossTU/CrossTranslationUnit.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Casting.h"
 
 using namespace clang;
 using namespace ento;
 using namespace tooling;
 
+namespace clang {
+class CrossTUAnalysisHelper;
+}
+
 namespace {
-/// Emitsd minimal diagnostics (report message + notes) for the 'none' output
+/// Emits minimal diagnostics (report message + notes) for the 'none' output
 /// type to the standard error, or to to compliment many others. Emits detailed
 /// diagnostics in textual format for the 'text' output type.
 class TextPathDiagnosticConsumer : public PathDiagnosticConsumer {
   PathDiagnosticConsumerOptions DiagOpts;
   DiagnosticsEngine &DiagEng;
   const LangOptions &LO;
   bool ShouldDisplayPathNotes;
 
void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
     Rewrite.overwriteChangedFiles();
   }
 };
 } // end anonymous namespace
 
 void ento::createTextPathDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &Prefix, const clang::Preprocessor &PP,
-    const cross_tu::CrossTranslationUnitContext &CTU) {
+    const CrossTUAnalysisHelper &CTU) {
   C.emplace_back(new TextPathDiagnosticConsumer(
       std::move(DiagOpts), PP.getDiagnostics(), PP.getLangOpts(),
       /*ShouldDisplayPathNotes=*/true));
 }
 
 void ento::createTextMinimalPathDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &Prefix, const clang::Preprocessor &PP,
-    const cross_tu::CrossTranslationUnitContext &CTU) {
+    const CrossTUAnalysisHelper &CTU) {
   C.emplace_back(new TextPathDiagnosticConsumer(
       std::move(DiagOpts), PP.getDiagnostics(), PP.getLangOpts(),
       /*ShouldDisplayPathNotes=*/false));
 }

clang/lib/CrossTU/CrossTranslationUnit.cpp

NewImporter->setFileIDImportHandler([this, Unit](FileID ToID, FileID FromID) {
     ImportedFileIDs[ToID] = std::make_pair(FromID, Unit);
   });
   ASTUnitImporterMap[From.getTranslationUnitDecl()].reset(NewImporter);
   return *NewImporter;
 }
 
 llvm::Optional<std::pair<SourceLocation, ASTUnit *>>
 CrossTranslationUnitContext::getImportedFromSourceLocation(
-    const clang::SourceLocation &ToLoc) const {
+    SourceLocation ToLoc) const {
   const SourceManager &SM = Context.getSourceManager();
   auto DecToLoc = SM.getDecomposedLoc(ToLoc);
 
   auto I = ImportedFileIDs.find(DecToLoc.first);
   if (I == ImportedFileIDs.end())
     return {};
 
   FileID FromID = I->second.first;