[include-cleaner] add macro symbols and implicit refs to HTML report

[sammccall]

Summary

Demo: http://htmlpreview.github.io/?https://gist.githubusercontent.com/sam-mccall/fec9b77c726cfb3cc7c424b197e3f68c/raw/8c5c5ad927b0485db76c34c25250b0ae8f7637f8/ASTTests.html

[hokein]

clang-tools-extra/include-cleaner/lib/HTMLReport.cpp

300

It seems noisy to print it even there is only one candidate, maybe exclude it if there is only one candidate?

[sammccall]

• hover card follows the internal data model: symbol -> location -> header (->include, later)
• don't use public API, so we can get at internal details

[sammccall]

format

[sammccall]

Updated the demo link, PTAL (significant changes since last review)

[hokein]

The new UI looks good.

clang-tools-extra/include-cleaner/lib/Analysis.cpp

24

nit: mention the writeHTMLReport function explicitly.

clang-tools-extra/include-cleaner/lib/HTMLReport.cpp

350

We need a special logic (if (auto SS = Recognizer(&ND)) {...}) for the stdlib symbols, otherwise, they will be treated as normal Decl symbols.

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Analysis.h

 ///
 /// This is the main entrypoint of the include-cleaner library, and can be used:
 ///  - to diagnose missing includes: a referenced symbol is provided by
 ///    headers which don't match any #include in the main file
 ///  - to diagnose unused includes: an #include in the main file does not match
 ///    the headers for any referenced symbol
 void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
               llvm::ArrayRef<SymbolReference> MacroRefs,
-              const PragmaIncludes &PI, const SourceManager &, UsedSymbolCB CB);
+              const PragmaIncludes *PI, const SourceManager &, UsedSymbolCB CB);
 
 } // namespace include_cleaner
 } // namespace clang
 
 #endif

clang-tools-extra/include-cleaner/lib/Analysis.cpp

 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace clang::include_cleaner {
 
 void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
               llvm::ArrayRef<SymbolReference> MacroRefs,
-              const PragmaIncludes &PI, const SourceManager &SM,
+              const PragmaIncludes *PI, const SourceManager &SM,
               UsedSymbolCB CB) {
+  // This is duplicated in writeHTMLReport, changes should be mirrored there.
   tooling::stdlib::Recognizer Recognizer;
   for (auto *Root : ASTRoots) {
     auto &SM = Root->getASTContext().getSourceManager();
     walkAST(*Root, [&](SourceLocation Loc, NamedDecl &ND, RefType RT) {
       SymbolReference SymRef{Loc, ND, RT};
       if (auto SS = Recognizer(&ND)) {
         // FIXME: Also report forward decls from main-file, so that the caller
         // can decide to insert/ignore a header.

clang-tools-extra/include-cleaner/lib/AnalysisInternal.h

struct SymbolLocation {
   tooling::stdlib::Symbol standard() const {
     return std::get<Standard>(Storage);
   }
 
 private:
   // Order must match Kind enum!
   std::variant<SourceLocation, tooling::stdlib::Symbol> Storage;
 };
-llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Header &);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SymbolLocation &);
 
 /// Finds the headers that provide the symbol location.
 // FIXME: expose signals
 llvm::SmallVector<Header> findHeaders(const SymbolLocation &Loc,
                                       const SourceManager &SM,
-                                      const PragmaIncludes &PI);
+                                      const PragmaIncludes *PI);
 
 /// Write an HTML summary of the analysis to the given stream.
-/// FIXME: Once analysis has a public API, this should be public too.
-void writeHTMLReport(FileID File, llvm::ArrayRef<Decl *> Roots, ASTContext &Ctx,
-                     llvm::raw_ostream &OS);
+void writeHTMLReport(FileID File, llvm::ArrayRef<Decl *> Roots,
+                     llvm::ArrayRef<SymbolReference> MacroRefs, ASTContext &Ctx,
+                     PragmaIncludes *PI, llvm::raw_ostream &OS);
 
 } // namespace include_cleaner
 } // namespace clang
 
 #endif

clang-tools-extra/include-cleaner/lib/FindHeaders.cpp

 //===--- FindHeaders.cpp --------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "AnalysisInternal.h"
 #include "clang-include-cleaner/Record.h"
 #include "clang/Basic/SourceManager.h"
 
 namespace clang::include_cleaner {
 
 llvm::SmallVector<Header> findHeaders(const SymbolLocation &Loc,
                                       const SourceManager &SM,
-                                      const PragmaIncludes &PI) {
+                                      const PragmaIncludes *PI) {
   llvm::SmallVector<Header> Results;
   switch (Loc.kind()) {
   case SymbolLocation::Physical: {
     // FIXME: Handle macro locations.
     // FIXME: Handle non self-contained files.
     FileID FID = SM.getFileID(Loc.physical());
     const auto *FE = SM.getFileEntryForID(FID);
     if (!FE)
       return {};
 
+    Results = {Header(FE)};
+    if (PI) {
       // We treat the spelling header in the IWYU pragma as the final public
       // header.
       // FIXME: look for exporters if the public header is exported by another
       // header.
-    llvm::StringRef VerbatimSpelling = PI.getPublic(FE);
+      llvm::StringRef VerbatimSpelling = PI->getPublic(FE);
       if (!VerbatimSpelling.empty())
         return {Header(VerbatimSpelling)};
 
-    Results = {Header(FE)};
       // FIXME: compute transitive exporter headers.
-    for (const auto *Export : PI.getExporters(FE, SM.getFileManager()))
+      for (const auto *Export : PI->getExporters(FE, SM.getFileManager()))
         Results.push_back(Export);
+    }
+
     return Results;
   }
   case SymbolLocation::Standard: {
     for (const auto &H : Loc.standard().headers())
       Results.push_back(H);
     return Results;
   }
   }
   llvm_unreachable("unhandled SymbolLocation kind!");
 }
 
 } // namespace clang::include_cleaner
 No newline at end of file

clang-tools-extra/include-cleaner/lib/HTMLReport.cpp

 //===--- HTMLReport.cpp - Explain the analysis for humans -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // If we're debugging this tool or trying to explain its conclusions, we need to
 // be able to identify specific facts about the code and the inferences made.
 //
 // This library prints an annotated version of the code
 //
 //===----------------------------------------------------------------------===//
 
 #include "AnalysisInternal.h"
-#include "clang-include-cleaner/Analysis.h"
+#include "clang-include-cleaner/Types.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/AST/Decl.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
+#include "clang/Tooling/Inclusions/StandardLibrary.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang::include_cleaner {
 namespace {
 
 constexpr llvm::StringLiteral CSS = R"css(
   body { margin: 0; }
   pre { line-height: 1.5em; counter-reset: line; margin: 0; }
   pre .line { counter-increment: line; }
   pre .line::before {
     content: counter(line);
     display: inline-block;
     background-color: #eee; border-right: 1px solid #ccc;
     text-align: right;
     width: 3em; padding-right: 0.5em; margin-right: 0.5em;
   }
   .ref { text-decoration: underline; color: #008; }
   .sel { position: relative; cursor: pointer; }
+  .ref.implicit { background-color: #ff8; }
   #hover {
-    background-color: #aaccff; border: 1px solid black;
+    color: black;
+    background-color: #aaccff; border: 1px solid #444;
     z-index: 1;
     position: absolute; top: 100%; left: 0;
     font-family: sans-serif;
     padding: 0.5em;
   }
   #hover p, #hover pre { margin: 0; }
-  #hover section header { font-weight: bold; }
-  #hover section:not(:first-child) { margin-top: 1em; }
+  #hover .target.implicit { background-color: #bbb; }
+  #hover .target.ambiguous { background-color: #caf; }
+  #hover th { color: #008; text-align: right; padding-right: 0.5em; }
+  #hover .target:not(:first-child) {
+    margin-top: 1em;
+    padding-top: 1em;
+    border-top: 1px solid #444;
+  }
 )css";
 
 constexpr llvm::StringLiteral JS = R"js(
   // Recreate the #hover div inside whichever target .sel element was clicked.
   function select(event) {
     var target = event.target.closest('.sel');
     var hover = document.getElementById('hover');
     if (hover) {
constexpr llvm::StringLiteral JS = R"js(
   function fillHover(hover, target) {
     target.dataset.hover?.split(',').forEach(function(id) {
       for (c of document.getElementById(id).content.childNodes)
         hover.appendChild(c.cloneNode(true));
     })
   }
 )js";
 
-// Print the declaration tersely, but enough to identify e.g. which overload.
-std::string printDecl(const NamedDecl &ND) {
-  std::string S;
-  llvm::raw_string_ostream OS(S);
-  PrintingPolicy PP = ND.getASTContext().getPrintingPolicy();
-  PP.FullyQualifiedName = true;
-  PP.TerseOutput = true;
-  PP.SuppressInitializers = true;
-  ND.print(OS, PP);
-  llvm::erase_value(S, '\n');
-  return S;
+// Categorize the symbol, like FunctionDecl or Macro
+llvm::StringRef describeSymbol(const Symbol &Sym) {
+  switch (Sym.kind()) {
+  case Symbol::Declaration:
+    return Sym.declaration().getDeclKindName();
+  case Symbol::Macro:
+    return "Macro";
+  }
+  llvm_unreachable("unhandled symbol kind");
+}
+
+llvm::StringRef refType(RefType T) {
+  switch (T) {
+  case RefType::Explicit:
+    return "explicit";
+  case RefType::Implicit:
+    return "implicit";
+  case RefType::Ambiguous:
+    return "ambiguous";
+  }
 }
 
 class Reporter {
   llvm::raw_ostream &OS;
   const ASTContext &Ctx;
   const SourceManager &SM;
+  const PragmaIncludes *PI;
   FileID File;
 
-  // Symbols that are referenced from the main file.
+  // References to symbols from the main file.
+  // FIXME: should we deduplicate these?
   struct Target {
-    const NamedDecl *D;
+    Symbol Sym;
+    RefType Type;
+    SmallVector<SymbolLocation> Locations;
+    SmallVector<Header> Headers;
   };
   std::vector<Target> Targets;
   // Points within the main file that reference a Target.
-  std::vector<std::pair</*Offset*/ unsigned, /*TargetIndex*/ unsigned>> Refs;
+  // Implicit refs will be marked with a symbol just before the token.
+  struct Ref {
+    unsigned Offset;
+    bool Implicit;
+    size_t TargetIndex;
+    bool operator<(const Ref &Other) const {
+      return std::forward_as_tuple(Offset, !Implicit, TargetIndex) <
+             std::forward_as_tuple(Other.Offset, !Other.Implicit, TargetIndex);
+    }
+  };
+  std::vector<Ref> Refs;
+
+  Target makeTarget(const SymbolReference &SR) {
+    Target T{SR.Target, SR.RT, {}, {}};
+
+    // Duplicates logic from walkUsed(), which doesn't expose SymbolLocations.
+    // FIXME: use locateDecl and friends once implemented.
+    // This doesn't use stdlib::Recognizer, but locateDecl will soon do that.
+    switch (SR.Target.kind()) {
+    case Symbol::Declaration:
+      T.Locations.push_back(SR.Target.declaration().getLocation());
+      break;
+    case Symbol::Macro:
+      T.Locations.push_back(SR.Target.macro().Definition);
+      break;
+    }
+
+    for (const auto &Loc : T.Locations)
+      T.Headers = findHeaders(Loc, SM, PI);
+
+    return T;
+  }
 
 public:
-  Reporter(llvm::raw_ostream &OS, ASTContext &Ctx, FileID File)
-      : OS(OS), Ctx(Ctx), SM(Ctx.getSourceManager()), File(File) {}
+  Reporter(llvm::raw_ostream &OS, ASTContext &Ctx, const PragmaIncludes *PI,
+           FileID File)
+      : OS(OS), Ctx(Ctx), SM(Ctx.getSourceManager()), PI(PI), File(File) {}
 
-  void addRef(SourceLocation Loc, const NamedDecl &D) {
-    auto [File, Offset] = SM.getDecomposedLoc(SM.getFileLoc(Loc));
+  void addRef(const SymbolReference &SR) {
+    auto [File, Offset] = SM.getDecomposedLoc(SM.getFileLoc(SR.RefLocation));
     if (File != this->File) {
       // Can get here e.g. if there's an #include inside a root Decl.
       // FIXME: do something more useful than this.
-      llvm::errs() << "Ref location outside file! "
-                   << D.getQualifiedNameAsString() << " at "
-                   << Loc.printToString(SM) << "\n";
+      llvm::errs() << "Ref location outside file! " << SR.Target << " at "
+                   << SR.RefLocation.printToString(SM) << "\n";
       return;
     }
-    Targets.push_back({&D});
-    Refs.push_back({Offset, Targets.size() - 1});
+
+    Refs.push_back({Offset, SR.RT == RefType::Implicit, Targets.size()});
+    Targets.push_back(makeTarget(SR));
   }
 
   void write() {
     OS << "<!doctype html>\n";
     OS << "<html>\n";
     OS << "<head>\n";
     OS << "<style>" << CSS << "</style>\n";
     OS << "<script>" << JS << "</script>\n";
     for (unsigned I = 0; I < Targets.size(); ++I) {
-      OS << "<template id='t" << I << "'><section>";
+      OS << "<template id='t" << I << "'>";
       writeTarget(Targets[I]);
-      OS << "</section></template>\n";
+      OS << "</template>\n";
     }
     OS << "</head>\n";
     OS << "<body>\n";
     writeCode();
     OS << "</body>\n";
     OS << "</html>\n";
   }
 
void escapeChar(char C) {
     }
   }
 
   void escapeString(llvm::StringRef S) {
     for (char C : S)
       escapeChar(C);
   }
 
+  // Abbreviate a path ('path/to/Foo.h') to just the filename ('Foo.h').
+  // The full path is available on hover.
+  void printFilename(llvm::StringRef Path) {
+    llvm::StringRef File = llvm::sys::path::filename(Path);
+    if (File == Path)
+      return escapeString(Path);
+    OS << "<span title='";
+    escapeString(Path);
+    OS << "'>";
+    escapeString(File);
+    OS << "</span>";
+  }
+
+  // Print a source location in compact style.
+  void printSourceLocation(SourceLocation Loc) {
+    if (Loc.isInvalid())
+      return escapeString("<invalid>");
+    if (!Loc.isMacroID())
+      return printFilename(Loc.printToString(SM));
+
+    // Replicating printToString() is a bit simpler than parsing/reformatting.
+    printFilename(SM.getExpansionLoc(Loc).printToString(SM));
+    OS << " &lt;Spelling=";
+    printFilename(SM.getSpellingLoc(Loc).printToString(SM));
+    OS << ">";
+  }
+
   void writeTarget(const Target &T) {
-    OS << "<header>" << T.D->getDeclKindName() << " ";
-    escapeString(T.D->getQualifiedNameAsString());
-    OS << "</header>";
-
-    OS << "<p>declared at ";
-    escapeString(SM.getFileLoc(T.D->getLocation()).printToString(SM));
-    OS << "</p><pre>";
-    escapeString(printDecl(*T.D));
-    OS << "</pre>";
+    OS << "<table class='target " << refType(T.Type) << "'>";
+
+    OS << "<tr><th>Symbol</th><td>";
+    OS << describeSymbol(T.Sym) << " <code>";
+    escapeString(llvm::to_string(T.Sym));
+    OS << "</code></td></tr>\n";
+
+    if (T.Sym.kind() == Symbol::Declaration) {
+      // Print the declaration of the symbol, e.g. to disambiguate overloads.
+      const auto &D = T.Sym.declaration();
+      PrintingPolicy PP = D.getASTContext().getPrintingPolicy();
+      PP.FullyQualifiedName = true;
+      PP.TerseOutput = true;
+      PP.SuppressInitializers = true;
+      std::string S;
+      llvm::raw_string_ostream SS(S);
+      D.print(SS, PP);
+
+      OS << "<tr><td></td><td><code>";
+      escapeString(S);
+      OS << "</code></td></tr>\n";
+    }
+
+    for (const auto &Loc : T.Locations) {
+      OS << "<tr><th>Location</th><td>";
+      if (Loc.kind() == SymbolLocation::Physical) // needs SM to print properly.
+        printSourceLocation(Loc.physical());
+      else
+        escapeString(llvm::to_string(Loc));
+      OS << "</td></tr>\n";
+    }
+
+    for (const auto &H : T.Headers) {
+      OS << "<tr><th>Header</th><td>";
+      switch (H.kind()) {
+      case Header::Physical:
+        printFilename(H.physical()->getName());
+        break;
+      case Header::Standard:
+        OS << "stdlib " << H.standard().name();
+        break;
+      case Header::Verbatim:
+        OS << "verbatim ";
+        escapeString(H.verbatim());
+        break;
+      }
+      OS << "</td></tr>\n";
+    }
+
+    OS << "</table>";
   }
 
   void writeCode() {
     llvm::sort(Refs);
     llvm::StringRef Code = SM.getBufferData(File);
 
     OS << "<pre onclick='select(event)' class='code'>";
     OS << "<code class='line'>";
     auto Rest = llvm::makeArrayRef(Refs);
     unsigned End = 0;
     for (unsigned I = 0; I < Code.size(); ++I) {
       // Finish refs early at EOL to avoid dealing with splitting the span.
       if (End && (End == I || Code[I] == '\n')) {
         OS << "</span>";
         End = 0;
       }
+      // Handle implicit refs, which are rendered *before* the token.
+      while (!Rest.empty() && Rest.front().Offset == I &&
+             Rest.front().Implicit) {
+        const Ref &R = Rest.front();
+        OS << "<span class='ref sel implicit' data-hover='t" << R.TargetIndex
+           << "'>&loz;</span>";
+        Rest = Rest.drop_front();
+      };
+      // Accumulate all explicit refs that appear on the same token.
       std::string TargetList;
-      Rest = Rest.drop_while([&](auto &R) {
-        if (R.first != I)
+      Rest = Rest.drop_while([&](const Ref &R) {
+        if (R.Offset != I)
           return false;
         if (!TargetList.empty())
           TargetList.push_back(',');
         TargetList.push_back('t');
-        TargetList.append(std::to_string(R.second));
+        TargetList.append(std::to_string(R.TargetIndex));
         return true;
       });
       if (!TargetList.empty()) {
         assert(End == 0 && "Overlapping tokens!");
         OS << "<span class='ref sel' data-hover='" << TargetList << "'>";
         End = I + Lexer::MeasureTokenLength(SM.getComposedLoc(File, I), SM,
                                             Ctx.getLangOpts());
       }
       if (Code[I] == '\n')
         OS << "</code>\n<code class='line'>";
       else
         escapeChar(Code[I]);
     }
     OS << "</code></pre>\n";
   }
 };
 
 } // namespace
 
-void writeHTMLReport(FileID File, llvm::ArrayRef<Decl *> Roots, ASTContext &Ctx,
-                     llvm::raw_ostream &OS) {
-  Reporter R(OS, Ctx, File);
+void writeHTMLReport(FileID File, llvm::ArrayRef<Decl *> Roots,
+                     llvm::ArrayRef<SymbolReference> MacroRefs, ASTContext &Ctx,
+                     PragmaIncludes *PI, llvm::raw_ostream &OS) {
+  Reporter R(OS, Ctx, PI, File);
   for (Decl *Root : Roots)
-    walkAST(*Root, [&](SourceLocation Loc, const NamedDecl &D, RefType) {
-      R.addRef(Loc, D);
+    walkAST(*Root, [&](SourceLocation Loc, const NamedDecl &D, RefType T) {
+      R.addRef(SymbolReference{Loc, D, T});
     });
+  for (const SymbolReference &Ref : MacroRefs)
+    R.addRef(Ref);
   R.write();
 }
 
 } // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/lib/Types.cpp

 #include "llvm/Support/raw_ostream.h"
 
 namespace clang::include_cleaner {
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Symbol &S) {
   switch (S.kind()) {
   case Symbol::Declaration:
     if (const auto *ND = llvm::dyn_cast<NamedDecl>(&S.declaration()))
-      return OS << ND->getNameAsString();
+      return OS << ND->getQualifiedNameAsString();
     return OS << S.declaration().getDeclKindName();
   case Symbol::Macro:
-    return OS << S.macro().Name;
+    return OS << S.macro().Name->getName();
   }
   llvm_unreachable("Unhandled Symbol kind");
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Header &H) {
   switch (H.kind()) {
   case Header::Physical:
     return OS << H.physical()->getName();

clang-tools-extra/include-cleaner/tool/IncludeCleaner.cpp

cl::opt<std::string> HTMLReportPath{
     "html",
     cl::desc("Specify an output filename for an HTML report. "
              "This describes both recommendations and reasons for changes."),
     cl::cat(IncludeCleaner),
 };
 
 class HTMLReportAction : public clang::ASTFrontendAction {
   RecordedAST AST;
+  RecordedPP PP;
+  PragmaIncludes PI;
+
+  void ExecuteAction() override {
+    auto &P = getCompilerInstance().getPreprocessor();
+    P.addPPCallbacks(PP.record(P));
+    PI.record(getCompilerInstance());
+    ASTFrontendAction::ExecuteAction();
+  }
 
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef File) override {
     return AST.record();
   }
 
   void EndSourceFile() override {
     std::error_code EC;
     llvm::raw_fd_ostream OS(HTMLReportPath, EC);
     if (EC) {
       llvm::errs() << "Unable to write HTML report to " << HTMLReportPath
                    << ": " << EC.message() << "\n";
       exit(1);
     }
     writeHTMLReport(AST.Ctx->getSourceManager().getMainFileID(), AST.Roots,
-                    *AST.Ctx, OS);
+                    PP.MacroReferences, *AST.Ctx, &PI, OS);
   }
 };
 
 } // namespace
 } // namespace include_cleaner
 } // namespace clang
 
 int main(int argc, const char **argv) {

clang-tools-extra/include-cleaner/unittests/AnalysisTest.cpp

TEST(WalkUsed, Basic) {
 
   llvm::SmallVector<Decl *> TopLevelDecls;
   for (Decl *D : AST.context().getTranslationUnitDecl()->decls()) {
     TopLevelDecls.emplace_back(D);
   }
 
   auto &SM = AST.sourceManager();
   llvm::DenseMap<size_t, std::vector<Header>> OffsetToProviders;
-  walkUsed(TopLevelDecls, /*MacroRefs=*/{}, PI, SM,
+  walkUsed(TopLevelDecls, /*MacroRefs=*/{}, &PI, SM,
            [&](const SymbolReference &Ref, llvm::ArrayRef<Header> Providers) {
              auto [FID, Offset] = SM.getDecomposedLoc(Ref.RefLocation);
              EXPECT_EQ(FID, SM.getMainFileID());
              OffsetToProviders.try_emplace(Offset, Providers.vec());
            });
   auto HeaderFile = Header(AST.fileManager().getFile("header.h").get());
   auto MainFile = Header(SM.getFileEntryForID(SM.getMainFileID()));
   auto VectorSTL = Header(tooling::stdlib::Header::named("<vector>").value());
TEST(WalkUsed, MacroRefs) {
   SM.overrideFileContents(HdrFile,
                           llvm::MemoryBuffer::getMemBuffer(Hdr.code().str()));
   FileID HdrID = SM.createFileID(HdrFile, SourceLocation(), SrcMgr::C_User);
 
   IdentifierTable Idents;
   Symbol Answer =
       Macro{&Idents.get("ANSWER"), SM.getComposedLoc(HdrID, Hdr.point())};
   llvm::DenseMap<size_t, std::vector<Header>> OffsetToProviders;
-  PragmaIncludes PI;
   walkUsed(/*ASTRoots=*/{}, /*MacroRefs=*/
            {SymbolReference{SM.getComposedLoc(SM.getMainFileID(), Main.point()),
                             Answer, RefType::Explicit}},
-           PI, SM,
+           /*PI=*/nullptr, SM,
            [&](const SymbolReference &Ref, llvm::ArrayRef<Header> Providers) {
              auto [FID, Offset] = SM.getDecomposedLoc(Ref.RefLocation);
              EXPECT_EQ(FID, SM.getMainFileID());
              OffsetToProviders.try_emplace(Offset, Providers.vec());
            });
 
   EXPECT_THAT(
       OffsetToProviders,
       UnorderedElementsAre(Pair(Main.point(), UnorderedElementsAre(HdrFile))));
 }
 
 
 } // namespace
 } // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/unittests/FindHeadersTest.cpp

TEST(FindIncludeHeaders, IWYU) {
   const auto &SM = AST.sourceManager();
   auto &FM = SM.getFileManager();
   // Returns the source location for the start of the file.
   auto SourceLocFromFile = [&](llvm::StringRef FileName) {
     return SM.translateFileLineCol(FM.getFile(FileName).get(),
                                    /*Line=*/1, /*Col=*/1);
   };
 
-  EXPECT_THAT(findHeaders(SourceLocFromFile("header1.h"), SM, PI),
+  EXPECT_THAT(findHeaders(SourceLocFromFile("header1.h"), SM, &PI),
               UnorderedElementsAre(Header("\"path/public.h\"")));
 
-  EXPECT_THAT(findHeaders(SourceLocFromFile("detail1.h"), SM, PI),
+  EXPECT_THAT(findHeaders(SourceLocFromFile("detail1.h"), SM, &PI),
               UnorderedElementsAre(Header(FM.getFile("header2.h").get()),
                                    Header(FM.getFile("detail1.h").get())));
-  EXPECT_THAT(findHeaders(SourceLocFromFile("detail2.h"), SM, PI),
+  EXPECT_THAT(findHeaders(SourceLocFromFile("detail2.h"), SM, &PI),
               UnorderedElementsAre(Header(FM.getFile("header2.h").get()),
                                    Header(FM.getFile("detail2.h").get())));
 
-  EXPECT_THAT(findHeaders(SourceLocFromFile("normal.h"), SM, PI),
+  EXPECT_THAT(findHeaders(SourceLocFromFile("normal.h"), SM, &PI),
               UnorderedElementsAre(Header(FM.getFile("normal.h").get())));
 }
 
 } // namespace
 } // namespace clang::include_cleaner
 No newline at end of file