[include-cleaner] Filter references to identity macros

[kadircet]

Summary

Despite being true positives, these results just confuse users. So
filter them out.

[sammccall]

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

39

shouldIgnoreMacroReference would better distinguish vs macro definition

45

Comment nit: I'm having trouble imagining cases that are actually*unrelated* to the stdlib.

If stderr is an impl-defined macro, then the only way to use the name to refer to something else is if it's not defined (inside ifndef stderr, or if you can be sure your TU doesn't include stdio first). Seems implausible...

That said I feel like we've had this conversation before and I've just forgotten the details.

46

Nit: "false positives" is a little unclear: positives for this function are negatives for walkAST and could be either for diagnostics.

Also, I think you mean *references* rather than declarations?

[kadircet]

• Rename helper, update comments.

[kadircet]

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

45

If stderr is an impl-defined macro, then the only way to use the name to refer to something else is if it's not defined

That's absolutely right. The issue here is macro expansion triggers independent of the context, e.g.

#include <stdio.h>
namespace ns { void stderr(); }
void foo() { ns::stderr(); }

here we have a (well two) reference to stderr macro from stdandard library, which is not user's intent, but rather a quirk of the language.

46

this should've been "false negatives" from the "usedness perspective", we basically drop the reference to ns::stderr in above example, because the name is not spelled in the main file (but rather spelled inside a macro body).

[sammccall]

still LG, comments are still confusing me a little

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

45

Sure, but this code is not valid C++ (since stderr is not guaranteed to expand to a single identifier). Is this actually a common/motivating case?

46

And now it's backwards if your perspective is this function itself!

just avoid "false positives"/"false negatives" terminology and describe the actual effect?

[kadircet]

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

45

Sure, but this code is not valid C++ (since stderr is not guaranteed to expand to a single identifier).

That's true. Most of the standard library implementations I checked does that, but I also don't like that reliance, so making it a little bit more generic (which meant some more plumbing, sorry for the big diff :( ), by making sure that we apply this to all the macros that expand to themselves.

[kadircet]

• Apply filtering only to macros that expand to themselves

[sammccall]

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

44

still call out stdout/stderr?

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h

 #include "../ClangTidyDiagnosticConsumer.h"
 #include "../ClangTidyOptions.h"
 #include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/HeaderSearch.h"
+#include "clang/Lex/Preprocessor.h"
 #include "llvm/Support/Regex.h"
 #include <vector>
 
 namespace clang::tidy::misc {
 
 /// Checks for unused and missing includes. Generates findings only for
 /// the main file of a translation unit.
 /// Findings correspond to https://clangd.llvm.org/design/include-cleaner.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/misc/include-cleaner.html
 class IncludeCleanerCheck : public ClangTidyCheck {
 public:
   IncludeCleanerCheck(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
 
 private:
   include_cleaner::RecordedPP RecordedPreprocessor;
   include_cleaner::PragmaIncludes RecordedPI;
-  HeaderSearch *HS;
+  const Preprocessor *PP = nullptr;
   std::vector<StringRef> IgnoreHeaders;
   // Whether emit only one finding per usage of a symbol.
   const bool DeduplicateFindings;
   llvm::SmallVector<llvm::Regex> IgnoreHeadersRegex;
   bool shouldIgnore(const include_cleaner::Header &H);
 };
 
 } // namespace clang::tidy::misc
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCLUDECLEANER_H

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

 void IncludeCleanerCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(translationUnitDecl().bind("top"), this);
 }
 
 void IncludeCleanerCheck::registerPPCallbacks(const SourceManager &SM,
                                               Preprocessor *PP,
                                               Preprocessor *ModuleExpanderPP) {
   PP->addPPCallbacks(RecordedPreprocessor.record(*PP));
-  HS = &PP->getHeaderSearchInfo();
+  this->PP = PP;
   RecordedPI.record(*PP);
 }
 
 bool IncludeCleanerCheck::shouldIgnore(const include_cleaner::Header &H) {
   return llvm::any_of(IgnoreHeadersRegex, [&H](const llvm::Regex &R) {
     switch (H.kind()) {
     case include_cleaner::Header::Standard:
       return R.match(H.standard().name());
if (!SM->isWrittenInMainFile(SM->getExpansionLoc(D->getLocation())))
       continue;
     // FIXME: Filter out implicit template specializations.
     MainFileDecls.push_back(D);
   }
   llvm::DenseSet<include_cleaner::Symbol> SeenSymbols;
   // FIXME: Find a way to have less code duplication between include-cleaner
   // analysis implementation and the below code.
   walkUsed(MainFileDecls, RecordedPreprocessor.MacroReferences, &RecordedPI,
-           *SM,
+           *PP,
            [&](const include_cleaner::SymbolReference &Ref,
                llvm::ArrayRef<include_cleaner::Header> Providers) {
              // Process each symbol once to reduce noise in the findings.
              // Tidy checks are used in two different workflows:
              // - Ones that show all the findings for a given file. For such
              // workflows there is not much point in showing all the occurences,
              // as one is enough to indicate the issue.
              // - Ones that show only the findings on changed pieces. For such
diag(Inc->HashLocation, "included header %0 is not used directly")
         << FixItHint::CreateRemoval(CharSourceRange::getCharRange(
                SM->translateLineCol(SM->getMainFileID(), Inc->Line, 1),
                SM->translateLineCol(SM->getMainFileID(), Inc->Line + 1, 1)));
   }
 
   tooling::HeaderIncludes HeaderIncludes(getCurrentMainFile(), Code,
                                          FileStyle->IncludeStyle);
   for (const auto &Inc : Missing) {
-    std::string Spelling =
-        include_cleaner::spellHeader({Inc.Missing, *HS, MainFile});
+    std::string Spelling = include_cleaner::spellHeader(
+        {Inc.Missing, PP->getHeaderSearchInfo(), MainFile});
     bool Angled = llvm::StringRef{Spelling}.starts_with("<");
     // We might suggest insertion of an existing include in edge cases, e.g.,
     // include is present in a PP-disabled region, or spelling of the header
     // turns out to be the same as one of the unresolved includes in the
     // main file.
     if (auto Replacement =
             HeaderIncludes.insert(llvm::StringRef{Spelling}.trim("\"<>"),
                                   Angled, tooling::IncludeDirective::Include))

clang-tools-extra/clangd/Hover.cpp

std::string getSymbolName(include_cleaner::Symbol Sym) {
   case include_cleaner::Symbol::Macro:
     Name = Sym.macro().Name->getName();
     break;
   }
   return Name;
 }
 
 void maybeAddUsedSymbols(ParsedAST &AST, HoverInfo &HI, const Inclusion &Inc) {
-  const SourceManager &SM = AST.getSourceManager();
   auto Converted = convertIncludes(AST);
   llvm::DenseSet<include_cleaner::Symbol> UsedSymbols;
   include_cleaner::walkUsed(
       AST.getLocalTopLevelDecls(), collectMacroReferences(AST),
-      AST.getPragmaIncludes().get(), SM,
+      AST.getPragmaIncludes().get(), AST.getPreprocessor(),
       [&](const include_cleaner::SymbolReference &Ref,
           llvm::ArrayRef<include_cleaner::Header> Providers) {
         if (Ref.RT != include_cleaner::RefType::Explicit ||
             UsedSymbols.contains(Ref.Target))
           return;
 
         if (isPreferredProvider(Inc, Converted, Providers))
           UsedSymbols.insert(Ref.Target);

clang-tools-extra/clangd/IncludeCleaner.cpp

IncludeCleanerFindings computeIncludeCleanerFindings(ParsedAST &AST) {
 
   std::vector<include_cleaner::SymbolReference> Macros =
       collectMacroReferences(AST);
   std::vector<MissingIncludeDiagInfo> MissingIncludes;
   llvm::DenseSet<IncludeStructure::HeaderID> Used;
   trace::Span Tracer("include_cleaner::walkUsed");
   include_cleaner::walkUsed(
       AST.getLocalTopLevelDecls(), /*MacroRefs=*/Macros,
-      AST.getPragmaIncludes().get(), SM,
+      AST.getPragmaIncludes().get(), AST.getPreprocessor(),
       [&](const include_cleaner::SymbolReference &Ref,
           llvm::ArrayRef<include_cleaner::Header> Providers) {
         bool Satisfied = false;
         for (const auto &H : Providers) {
           if (H.kind() == include_cleaner::Header::Physical &&
               (H.physical() == MainFile || H.physical() == PreamblePatch)) {
             Satisfied = true;
             continue;

clang-tools-extra/clangd/XRefs.cpp

maybeFindIncludeReferences(ParsedAST &AST, Position Pos,
   if (IncludeOnLine == Includes.end())
     return std::nullopt;
 
   const SourceManager &SM = AST.getSourceManager();
   ReferencesResult Results;
   auto Converted = convertIncludes(AST);
   include_cleaner::walkUsed(
       AST.getLocalTopLevelDecls(), collectMacroReferences(AST),
-      AST.getPragmaIncludes().get(), SM,
+      AST.getPragmaIncludes().get(), AST.getPreprocessor(),
       [&](const include_cleaner::SymbolReference &Ref,
           llvm::ArrayRef<include_cleaner::Header> Providers) {
         if (Ref.RT != include_cleaner::RefType::Explicit ||
             !isPreferredProvider(*IncludeOnLine, Converted, Providers))
           return;
 
         auto Loc = SM.getFileLoc(Ref.RefLocation);
         // File locations can be outside of the main file if macro is

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

 
 #ifndef CLANG_INCLUDE_CLEANER_ANALYSIS_H
 #define CLANG_INCLUDE_CLEANER_ANALYSIS_H
 
 #include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "clang/Format/Format.h"
 #include "clang/Lex/HeaderSearch.h"
+#include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace clang {
 class SourceLocation;

 ///
 /// 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 Preprocessor &PP,
+              UsedSymbolCB CB);
 
 struct AnalysisResults {
   std::vector<const Include *> Unused;
   std::vector<std::string> Missing; // Spellings, like "<vector>"
 };
 
 /// Determine which headers should be inserted or removed from the main file.
 /// This exposes conclusions but not reasons: use lower-level walkUsed for that.
 ///
 /// The HeaderFilter is a predicate that receives absolute path or spelling
 /// without quotes/brackets, when a phyiscal file doesn't exist.
 /// No analysis will be performed for headers that satisfy the predicate.
 AnalysisResults
 analyze(llvm::ArrayRef<Decl *> ASTRoots,
         llvm::ArrayRef<SymbolReference> MacroRefs, const Includes &I,
-        const PragmaIncludes *PI, const SourceManager &SM,
-        const HeaderSearch &HS,
+        const PragmaIncludes *PI, const Preprocessor &PP,
         llvm::function_ref<bool(llvm::StringRef)> HeaderFilter = nullptr);
 
 /// Removes unused includes and inserts missing ones in the main file.
 /// Returns the modified main-file code.
 /// The FormatStyle must be C++ or ObjC (to support include ordering).
 std::string fixIncludes(const AnalysisResults &Results,
                         llvm::StringRef FileName, llvm::StringRef Code,
                         const format::FormatStyle &IncludeStyle);

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

 #include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/Basic/FileEntry.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "clang/Lex/HeaderSearch.h"
+#include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
+#include <cassert>
+#include <climits>
 #include <string>
 
 namespace clang::include_cleaner {
 
+namespace {
+bool shouldIgnoreMacroReference(const Preprocessor &PP, const Macro &M) {
+  auto *MI = PP.getMacroInfo(M.Name);
+  // Macros that expand to themselves are confusing from user's point of view.
+  // They usually aspect the usage to be attributed to the underlying decl and
+  // not the macro definition. So ignore such macros (e.g. std{in,out,err} are
+  // implementation defined macros, that just resolve to themselves in
+  // practice).
+  return MI && MI->getNumTokens() == 1 && MI->isObjectLike() &&
+         MI->getReplacementToken(0).getIdentifierInfo() == M.Name;
+}
+} // namespace
+
 void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
               llvm::ArrayRef<SymbolReference> MacroRefs,
-              const PragmaIncludes *PI, const SourceManager &SM,
+              const PragmaIncludes *PI, const Preprocessor &PP,
               UsedSymbolCB CB) {
+  const auto &SM = PP.getSourceManager();
   // This is duplicated in writeHTMLReport, changes should be mirrored there.
   tooling::stdlib::Recognizer Recognizer;
   for (auto *Root : ASTRoots) {
     walkAST(*Root, [&](SourceLocation Loc, NamedDecl &ND, RefType RT) {
       auto FID = SM.getFileID(SM.getSpellingLoc(Loc));
       if (FID != SM.getMainFileID() && FID != SM.getPreambleFileID())
         return;
       // FIXME: Most of the work done here is repetitive. It might be useful to
       // have a cache/batching.
       SymbolReference SymRef{ND, Loc, RT};
       return CB(SymRef, headersForSymbol(ND, SM, PI));
     });
   }
   for (const SymbolReference &MacroRef : MacroRefs) {
     assert(MacroRef.Target.kind() == Symbol::Macro);
-    if (!SM.isWrittenInMainFile(SM.getSpellingLoc(MacroRef.RefLocation)))
+    if (!SM.isWrittenInMainFile(SM.getSpellingLoc(MacroRef.RefLocation)) ||
+        shouldIgnoreMacroReference(PP, MacroRef.Target.macro()))
       continue;
     CB(MacroRef, headersForSymbol(MacroRef.Target, SM, PI));
   }
 }
 
 AnalysisResults
 analyze(llvm::ArrayRef<Decl *> ASTRoots,
         llvm::ArrayRef<SymbolReference> MacroRefs, const Includes &Inc,
-        const PragmaIncludes *PI, const SourceManager &SM,
-        const HeaderSearch &HS,
+        const PragmaIncludes *PI, const Preprocessor &PP,
         llvm::function_ref<bool(llvm::StringRef)> HeaderFilter) {
+  auto &SM = PP.getSourceManager();
   const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID());
   llvm::DenseSet<const Include *> Used;
   llvm::StringSet<> Missing;
   if (!HeaderFilter)
     HeaderFilter = [](llvm::StringRef) { return false; };
-  walkUsed(ASTRoots, MacroRefs, PI, SM,
+  walkUsed(ASTRoots, MacroRefs, PI, PP,
            [&](const SymbolReference &Ref, llvm::ArrayRef<Header> Providers) {
              bool Satisfied = false;
              for (const Header &H : Providers) {
                if (H.kind() == Header::Physical && H.physical() == MainFile)
                  Satisfied = true;
                for (const Include *I : Inc.match(H)) {
                  Used.insert(I);
                  Satisfied = true;
                }
              }
              if (!Satisfied && !Providers.empty() &&
                  Ref.RT == RefType::Explicit &&
                  !HeaderFilter(Providers.front().resolvedPath()))
-               Missing.insert(spellHeader({Providers.front(), HS, MainFile}));
+               Missing.insert(spellHeader(
+                   {Providers.front(), PP.getHeaderSearchInfo(), MainFile}));
            });
 
   AnalysisResults Results;
   for (const Include &I : Inc.all()) {
     if (Used.contains(&I) || !I.Resolved ||
         HeaderFilter(I.Resolved->getFileEntry().tryGetRealPathName()))
       continue;
     if (PI) {

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

if (SM.getDiagnostics().hasUncompilableErrorOccurred()) {
           << " due to compiler errors. clang-include-cleaner expects to "
              "work on compilable source code.\n";
       return;
     }
 
     if (!HTMLReportPath.empty())
       writeHTML();
 
-    auto &HS = getCompilerInstance().getPreprocessor().getHeaderSearchInfo();
     llvm::StringRef Path =
         SM.getFileEntryForID(SM.getMainFileID())->tryGetRealPathName();
     assert(!Path.empty() && "Main file path not known?");
     llvm::StringRef Code = SM.getBufferData(SM.getMainFileID());
 
-    auto Results = analyze(AST.Roots, PP.MacroReferences, PP.Includes, &PI, SM,
-                           HS, HeaderFilter);
+    auto Results =
+        analyze(AST.Roots, PP.MacroReferences, PP.Includes, &PI,
+                getCompilerInstance().getPreprocessor(), HeaderFilter);
     if (!Insert)
       Results.Missing.clear();
     if (!Remove)
       Results.Unused.clear();
     std::string Final = fixIncludes(Results, Path, Code, getStyle(Path));
 
     if (Print.getNumOccurrences()) {
       switch (Print) {

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

Inputs.MakeAction = [this] {
 
         PragmaIncludes *Out;
       };
       return std::make_unique<Hook>(&PI);
     };
   }
 
   std::multimap<size_t, std::vector<Header>>
-  offsetToProviders(TestAST &AST, SourceManager &SM,
+  offsetToProviders(TestAST &AST,
                     llvm::ArrayRef<SymbolReference> MacroRefs = {}) {
+    const auto &SM = AST.sourceManager();
     llvm::SmallVector<Decl *> TopLevelDecls;
     for (Decl *D : AST.context().getTranslationUnitDecl()->decls()) {
       if (!SM.isWrittenInMainFile(SM.getExpansionLoc(D->getLocation())))
         continue;
       TopLevelDecls.emplace_back(D);
     }
     std::multimap<size_t, std::vector<Header>> OffsetToProviders;
-    walkUsed(TopLevelDecls, MacroRefs, &PI, SM,
+    walkUsed(TopLevelDecls, MacroRefs, &PI, AST.preprocessor(),
              [&](const SymbolReference &Ref, llvm::ArrayRef<Header> Providers) {
                auto [FID, Offset] = SM.getDecomposedLoc(Ref.RefLocation);
                if (FID != SM.getMainFileID())
                  ADD_FAILURE() << "Reference outside of the main file!";
                OffsetToProviders.emplace(Offset, Providers.vec());
              });
     return OffsetToProviders;
   }
TEST_F(WalkUsedTest, Basic) {
   auto &SM = AST.sourceManager();
   auto HeaderFile = Header(AST.fileManager().getFile("header.h").get());
   auto PrivateFile = Header(AST.fileManager().getFile("private.h").get());
   auto PublicFile = Header("\"path/public.h\"");
   auto MainFile = Header(SM.getFileEntryForID(SM.getMainFileID()));
   auto VectorSTL = Header(*tooling::stdlib::Header::named("<vector>"));
   auto UtilitySTL = Header(*tooling::stdlib::Header::named("<utility>"));
   EXPECT_THAT(
-      offsetToProviders(AST, SM),
+      offsetToProviders(AST),
       UnorderedElementsAre(
           Pair(Code.point("bar"), UnorderedElementsAre(MainFile)),
           Pair(Code.point("private"),
                UnorderedElementsAre(PublicFile, PrivateFile)),
           Pair(Code.point("foo"), UnorderedElementsAre(HeaderFile)),
           Pair(Code.point("vector"), UnorderedElementsAre(VectorSTL)),
           Pair(Code.point("vconstructor"), UnorderedElementsAre(VectorSTL)),
           Pair(Code.point("v"), UnorderedElementsAre(MainFile)),
TEST_F(WalkUsedTest, MultipleProviders) {
   )cpp");
 
   TestAST AST(Inputs);
   auto &SM = AST.sourceManager();
   auto HeaderFile1 = Header(AST.fileManager().getFile("header1.h").get());
   auto HeaderFile2 = Header(AST.fileManager().getFile("header2.h").get());
   auto MainFile = Header(SM.getFileEntryForID(SM.getMainFileID()));
   EXPECT_THAT(
-      offsetToProviders(AST, SM),
+      offsetToProviders(AST),
       Contains(Pair(Code.point("foo"),
                     UnorderedElementsAre(HeaderFile1, HeaderFile2, MainFile))));
 }
 
 TEST_F(WalkUsedTest, MacroRefs) {
   llvm::Annotations Code(R"cpp(
     #include "hdr.h"
     int $3^x = $1^ANSWER;
     int $4^y = $2^ANSWER;
   )cpp");
   llvm::Annotations Hdr(guard("#define ^ANSWER 42"));
   Inputs.Code = Code.code();
   Inputs.ExtraFiles["hdr.h"] = Hdr.code();
   TestAST AST(Inputs);
   auto &SM = AST.sourceManager();
+  auto &PP = AST.preprocessor();
   const auto *HdrFile = SM.getFileManager().getFile("hdr.h").get();
   auto MainFile = Header(SM.getFileEntryForID(SM.getMainFileID()));
 
   auto HdrID = SM.translateFile(HdrFile);
 
-  IdentifierTable Idents;
-  Symbol Answer1 =
-      Macro{&Idents.get("ANSWER"), SM.getComposedLoc(HdrID, Hdr.point())};
-  Symbol Answer2 =
-      Macro{&Idents.get("ANSWER"), SM.getComposedLoc(HdrID, Hdr.point())};
+  Symbol Answer1 = Macro{PP.getIdentifierInfo("ANSWER"),
+                         SM.getComposedLoc(HdrID, Hdr.point())};
+  Symbol Answer2 = Macro{PP.getIdentifierInfo("ANSWER"),
+                         SM.getComposedLoc(HdrID, Hdr.point())};
   EXPECT_THAT(
       offsetToProviders(
-          AST, SM,
+          AST,
           {SymbolReference{
                Answer1, SM.getComposedLoc(SM.getMainFileID(), Code.point("1")),
                RefType::Explicit},
            SymbolReference{
                Answer2, SM.getComposedLoc(SM.getMainFileID(), Code.point("2")),
                RefType::Explicit}}),
       UnorderedElementsAre(
           Pair(Code.point("1"), UnorderedElementsAre(HdrFile)),
Inputs.ExtraFiles["b.h"] = guard(R"cpp(
     int b;
   )cpp");
   Inputs.ExtraFiles["c.h"] = guard("int c;");
   Inputs.ExtraFiles["keep.h"] = guard("");
   TestAST AST(Inputs);
   auto Decls = AST.context().getTranslationUnitDecl()->decls();
   auto Results =
       analyze(std::vector<Decl *>{Decls.begin(), Decls.end()},
-              PP.MacroReferences, PP.Includes, &PI, AST.sourceManager(),
-              AST.preprocessor().getHeaderSearchInfo());
+              PP.MacroReferences, PP.Includes, &PI, AST.preprocessor());
 
   const Include *B = PP.Includes.atLine(3);
   ASSERT_EQ(B->Spelled, "b.h");
   EXPECT_THAT(Results.Missing, ElementsAre("\"c.h\""));
   EXPECT_THAT(Results.Unused, ElementsAre(B));
 }
 
 TEST_F(AnalyzeTest, PrivateUsedInPublic) {
   // Check that umbrella header uses private include.
   Inputs.Code = R"cpp(#include "private.h")cpp";
   Inputs.ExtraFiles["private.h"] =
       guard("// IWYU pragma: private, include \"public.h\"");
   Inputs.FileName = "public.h";
   TestAST AST(Inputs);
   EXPECT_FALSE(PP.Includes.all().empty());
-  auto Results = analyze({}, {}, PP.Includes, &PI, AST.sourceManager(),
-                         AST.preprocessor().getHeaderSearchInfo());
+  auto Results = analyze({}, {}, PP.Includes, &PI, AST.preprocessor());
   EXPECT_THAT(Results.Unused, testing::IsEmpty());
 }
 
 TEST_F(AnalyzeTest, NoCrashWhenUnresolved) {
   // Check that umbrella header uses private include.
   Inputs.Code = R"cpp(#include "not_found.h")cpp";
   Inputs.ErrorOK = true;
   TestAST AST(Inputs);
   EXPECT_FALSE(PP.Includes.all().empty());
-  auto Results = analyze({}, {}, PP.Includes, &PI, AST.sourceManager(),
-                         AST.preprocessor().getHeaderSearchInfo());
+  auto Results = analyze({}, {}, PP.Includes, &PI, AST.preprocessor());
   EXPECT_THAT(Results.Unused, testing::IsEmpty());
 }
 
 TEST(FixIncludes, Basic) {
   llvm::StringRef Code = R"cpp(#include "d.h"
 #include "a.h"
 #include "b.h"
 #include <c.h>
for (const auto &T : TestCases) {
     TestAST AST(Inputs);
     llvm::SmallVector<Decl *> TopLevelDecls;
     for (Decl *D : AST.context().getTranslationUnitDecl()->decls())
       TopLevelDecls.emplace_back(D);
     auto &SM = AST.sourceManager();
 
     SourceLocation RefLoc;
     walkUsed(TopLevelDecls, Recorded.MacroReferences,
-             /*PragmaIncludes=*/nullptr, SM,
+             /*PragmaIncludes=*/nullptr, AST.preprocessor(),
              [&](const SymbolReference &Ref, llvm::ArrayRef<Header>) {
                if (!Ref.RefLocation.isMacroID())
                  return;
                if (llvm::to_string(Ref.Target) == "target") {
                  ASSERT_TRUE(RefLoc.isInvalid())
                      << "Expected only one 'target' ref loc per testcase";
                  RefLoc = Ref.RefLocation;
                }
Inputs.ExtraFiles["partial.h"] =
       guard("template<typename T> struct Foo<T*> {};");
   TestAST AST(Inputs);
   auto &SM = AST.sourceManager();
   const auto *Fwd = SM.getFileManager().getFile("fwd.h").get();
   const auto *Def = SM.getFileManager().getFile("def.h").get();
   const auto *Partial = SM.getFileManager().getFile("partial.h").get();
 
   EXPECT_THAT(
-      offsetToProviders(AST, SM),
+      offsetToProviders(AST),
       AllOf(Contains(
                 Pair(Code.point("exp_spec"), UnorderedElementsAre(Fwd, Def))),
             Contains(Pair(Code.point("exp"), UnorderedElementsAre(Fwd, Def))),
             Contains(Pair(Code.point("full"), UnorderedElementsAre(Fwd, Def))),
             Contains(
                 Pair(Code.point("implicit"), UnorderedElementsAre(Fwd, Def))),
             Contains(
                 Pair(Code.point("partial"), UnorderedElementsAre(Partial)))));
 }
 
+TEST_F(WalkUsedTest, IgnoresIdentityMacros) {
+  llvm::Annotations Code(R"cpp(
+  #include "header.h"
+  void $bar^bar() {
+    $stdin^stdin();
+  }
+  )cpp");
+  Inputs.Code = Code.code();
+  Inputs.ExtraFiles["header.h"] = guard(R"cpp(
+  #include "inner.h"
+  void stdin();
+  )cpp");
+  Inputs.ExtraFiles["inner.h"] = guard(R"cpp(
+  #define stdin stdin
+  )cpp");
+
+  TestAST AST(Inputs);
+  auto &SM = AST.sourceManager();
+  auto MainFile = Header(SM.getFileEntryForID(SM.getMainFileID()));
+  EXPECT_THAT(offsetToProviders(AST),
+              UnorderedElementsAre(
+                  // FIXME: we should have a reference from stdin to header.h
+                  Pair(Code.point("bar"), UnorderedElementsAre(MainFile))));
+}
 } // namespace
 } // namespace clang::include_cleaner