[include-cleaner] pass through recorded macro refs in walkUsed

[sammccall]

rebase

[kadircet]

thanks, lgtm!

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

47–48

nit: you mind moving sourcemanager to be after roots and macrorefs?

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

 /// and rank the results.
 using UsedSymbolCB = llvm::function_ref<void(SymbolReference SymRef,
                                              llvm::ArrayRef<Header> Providers)>;
 
 /// Find and report all references to symbols in a region of code.
 ///
 /// The AST traversal is rooted at ASTRoots - typically top-level declarations
 /// of a single source file.
-/// FIXME: Handle macro uses.
+/// The references to macros must be recorded separately and provided.
 ///
 /// 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
 /// FIXME: Take in an include structure to improve location to header mappings
 /// (e.g. IWYU pragmas).
-void walkUsed(llvm::ArrayRef<Decl *> ASTRoots, UsedSymbolCB CB);
+void walkUsed(const SourceManager &, llvm::ArrayRef<Decl *> ASTRoots,
+              llvm::ArrayRef<SymbolReference> MacroRefs, UsedSymbolCB CB);
 
 } // namespace include_cleaner
 } // namespace clang
 
 #endif

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

 llvm::SmallVector<Header>
 toHeader(llvm::ArrayRef<tooling::stdlib::Header> Headers) {
   llvm::SmallVector<Header> Result;
   llvm::for_each(Headers, [&](tooling::stdlib::Header H) {
     Result.emplace_back(Header(H));
   });
   return Result;
 }
-
 } // namespace
-void walkUsed(llvm::ArrayRef<Decl *> ASTRoots, UsedSymbolCB CB) {
+
+void walkUsed(const SourceManager &SM, llvm::ArrayRef<Decl *> ASTRoots,
+              llvm::ArrayRef<SymbolReference> MacroRefs, UsedSymbolCB CB) {
   tooling::stdlib::Recognizer Recognizer;
   for (auto *Root : ASTRoots) {
     auto &SM = Root->getASTContext().getSourceManager();
     walkAST(*Root, [&](SourceLocation Loc, NamedDecl &ND, RefType 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.
         return CB({Loc, Symbol(*SS), RT}, toHeader(SS->headers()));
       }
       // FIXME: Extract locations from redecls.
       // FIXME: Handle IWYU pragmas, non self-contained files.
       // FIXME: Handle macro locations.
       if (auto *FE = SM.getFileEntryForID(SM.getFileID(ND.getLocation())))
         return CB({Loc, Symbol(ND), RT}, {Header(FE)});
     });
   }
-  // FIXME: Handle references of macros.
+  for (const SymbolReference &MacroRef : MacroRefs) {
+    assert(MacroRef.Target.kind() == Symbol::Macro);
+    // FIXME: Handle IWYU pragmas, non self-contained files.
+    // FIXME: Handle macro locations.
+    if (auto *FE = SM.getFileEntryForID(
+            SM.getFileID(MacroRef.Target.macro().Definition)))
+      CB(MacroRef, {Header(FE)});
+  }
 }
 
 } // namespace clang::include_cleaner

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,
+  walkUsed(SM, TopLevelDecls, /*MacroRefs=*/{},
            [&](SymbolReference SymRef, llvm::ArrayRef<Header> Providers) {
              auto [FID, Offset] = SM.getDecomposedLoc(SymRef.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());
   EXPECT_THAT(
       OffsetToProviders,
       UnorderedElementsAre(
           Pair(Code.point("bar"), UnorderedElementsAre(MainFile)),
           Pair(Code.point("foo"), UnorderedElementsAre(HeaderFile)),
           Pair(Code.point("vector"), UnorderedElementsAre(VectorSTL)),
           Pair(Code.point("vconstructor"), UnorderedElementsAre(VectorSTL))));
 }
 
+TEST(WalkUsed, MacroRefs) {
+  llvm::Annotations Hdr(R"cpp(
+    #define ^ANSWER 42
+  )cpp");
+  llvm::Annotations Main(R"cpp(
+    #include "hdr.h"
+    int x = ^ANSWER;
+  )cpp");
+
+  SourceManagerForFile SMF("main.cpp", Main.code());
+  auto &SM = SMF.get();
+  const FileEntry *HdrFile =
+      SM.getFileManager().getVirtualFile("hdr.h", Hdr.code().size(), 0);
+  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;
+  walkUsed(SM, /*ASTRoots=*/{}, /*MacroRefs=*/
+           {SymbolReference{SM.getComposedLoc(SM.getMainFileID(), Main.point()),
+                            Answer, RefType::Explicit}},
+           [&](SymbolReference SymRef, llvm::ArrayRef<Header> Providers) {
+             auto [FID, Offset] = SM.getDecomposedLoc(SymRef.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