[clangd] Replace the hacky include-cleaner macro-reference implementation.

[hokein]

Summary

Now MainFileMacros preserves enough information, we perform a just-in-time
convertion to interop with include-cleaner::Macro for include-cleaer features.

[hokein]

Friendly ping in case you missed it.

[kadircet]

thanks!

clang-tools-extra/clangd/IncludeCleaner.cpp

128

nit: const auto &[SID, Refs]

130

it's unfortunate that we're scanning the file for every occurrence of a macro just to get an offset. this might get problematic in big test files, what about introducing an offset to MacroOccurence?

135

nit: early exit instead

141

we should use Macro->NameLoc, not the definition loc inside macro-info

147

i believe you meant Ambigious here. the reference is "explicitly" in the code, but we can't say for sure if it's intended.

[hokein]

address comments

[hokein]

thanks for the comments.

clang-tools-extra/clangd/IncludeCleaner.cpp

130

it's unfortunate that we're scanning the file for every occurrence of a macro just to get an offset. this might get problematic in big test files, what about introducing an offset to MacroOccurence?

130

thanks, it makes sense, sent out https://reviews.llvm.org/D153259.

141

oh, right. NameLoc takes the preamble patch into account.

[kadircet]

clang-tools-extra/clangd/IncludeCleaner.cpp

376

nit: auto Loc = SM.getComposedLoc(MainFile, Offset)

385

nit: do early exit here as well

[hokein]

address comments

clang-tools-extra/clangd/IncludeCleaner.cpp

if (!AST.getPreprocessor().getHeaderSearchInfo().isFileMultipleIncludeGuarded(
           &FE->getFileEntry())) {
     dlog("{0} doesn't have header guard and will not be considered unused",
          FE->getName());
     return false;
   }
   return true;
 }
 
 llvm::StringRef getResolvedPath(const include_cleaner::Header &SymProvider) {
   switch (SymProvider.kind()) {
   case include_cleaner::Header::Physical:
     return SymProvider.physical()->tryGetRealPathName();
   case include_cleaner::Header::Standard:
     return SymProvider.standard().name().trim("<>\"");
   case include_cleaner::Header::Verbatim:
     return SymProvider.verbatim().trim("<>\"");
   }
   llvm_unreachable("Unknown header kind");
 }
 
 std::vector<Diag> generateMissingIncludeDiagnostics(
     ParsedAST &AST, llvm::ArrayRef<MissingIncludeDiagInfo> MissingIncludes,
     llvm::StringRef Code, HeaderFilter IgnoreHeaders) {
   std::vector<Diag> Result;
   const SourceManager &SM = AST.getSourceManager();
   const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID());
 
   auto FileStyle = format::getStyle(
       format::DefaultFormatStyle, AST.tuPath(), format::DefaultFallbackStyle,
       Code, &SM.getFileManager().getVirtualFileSystem());
   if (!FileStyle) {
     elog("Couldn't infer style", FileStyle.takeError());
     FileStyle = format::getLLVMStyle();
   }
 
   tooling::HeaderIncludes HeaderIncludes(AST.tuPath(), Code,
getUnused(ParsedAST &AST,
   return Unused;
 }
 
 } // namespace
 
 std::vector<include_cleaner::SymbolReference>
 collectMacroReferences(ParsedAST &AST) {
   const auto &SM = AST.getSourceManager();
-  //  FIXME: !!this is a hacky way to collect macro references.
-  std::vector<include_cleaner::SymbolReference> Macros;
   auto &PP = AST.getPreprocessor();
-  for (const syntax::Token &Tok :
-       AST.getTokens().spelledTokens(SM.getMainFileID())) {
-    auto Macro = locateMacroAt(Tok, PP);
+  std::vector<include_cleaner::SymbolReference> Macros;
+  for (const auto &[_, Refs] : AST.getMacros().MacroRefs) {
+    for (const auto &Ref : Refs) {
+      auto Loc = SM.getComposedLoc(SM.getMainFileID(), Ref.StartOffset);
+      const auto *Tok = AST.getTokens().spelledTokenAt(Loc);
+      if (!Tok)
+        continue;
+      auto Macro = locateMacroAt(*Tok, PP);
       if (!Macro)
         continue;
-    if (auto DefLoc = Macro->Info->getDefinitionLoc(); DefLoc.isValid())
+      auto DefLoc = Macro->NameLoc;
+      if (!DefLoc.isValid())
+        continue;
       Macros.push_back(
-          {include_cleaner::Macro{/*Name=*/PP.getIdentifierInfo(Tok.text(SM)),
+          {include_cleaner::Macro{/*Name=*/PP.getIdentifierInfo(Tok->text(SM)),
                                   DefLoc},
-           Tok.location(), include_cleaner::RefType::Explicit});
+           Tok->location(),
+           Ref.InConditionalDirective ? include_cleaner::RefType::Ambiguous
+                                      : include_cleaner::RefType::Explicit});
+    }
   }
+
   return Macros;
 }
 
 include_cleaner::Includes
 convertIncludes(const SourceManager &SM,
                 const llvm::ArrayRef<Inclusion> Includes) {
   include_cleaner::Includes ConvertedIncludes;
   for (const Inclusion &Inc : Includes) {
     include_cleaner::Include TransformedInc;
     llvm::StringRef WrittenRef = llvm::StringRef(Inc.Written);
     TransformedInc.Spelled = WrittenRef.trim("\"<>");
     TransformedInc.HashLocation =
         SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
     TransformedInc.Line = Inc.HashLine + 1;
     TransformedInc.Angled = WrittenRef.starts_with("<");

clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp

 $insert_d[[]]$insert_foo[[]]#include "fuzz.h"
 #include "header.h"
 $insert_foobar[[]]#include <e.h>
 $insert_f[[]]$insert_vector[[]]
 
 #define DEF(X) const Foo *X;
 #define BAZ(X) const X x
 
+// No missing include insertion for ambiguous macro refs.
+#if defined(FOO)
+#endif
+
   void foo() {
     $b[[b]]();
 
     ns::$bar[[Bar]] bar;
     bar.d();
     $f[[f]]();
 
     // this should not be diagnosed, because it's ignored in the config