[clangd] locateMacroAt returns definition range instead of MacroInfo

[kadircet]

Summary

Depends on D79879.

clang-tools-extra/clangd/Hover.cpp

HoverInfo getHoverContents(const DefinedMacro &Macro, ParsedAST &AST) {
   HoverInfo HI;
   SourceManager &SM = AST.getSourceManager();
   HI.Name = std::string(Macro.Name);
   HI.Kind = index::SymbolKind::Macro;
   // FIXME: Populate documentation
   // FIXME: Populate parameters
 
   // Try to get the full definition, not just the name
-  SourceLocation StartLoc = Macro.Info->getDefinitionLoc();
-  SourceLocation EndLoc = Macro.Info->getDefinitionEndLoc();
+  SourceLocation StartLoc = Macro.DefRange.getBegin();
+  SourceLocation EndLoc = Macro.DefRange.getEnd();
   if (EndLoc.isValid()) {
     EndLoc = Lexer::getLocForEndOfToken(EndLoc, 0, SM, AST.getLangOpts());
     bool Invalid;
     StringRef Buffer = SM.getBufferData(SM.getFileID(StartLoc), &Invalid);
     if (!Invalid) {
       unsigned StartOffset = SM.getFileOffset(StartLoc);
       unsigned EndOffset = SM.getFileOffset(EndLoc);
       if (EndOffset <= Buffer.size() && StartOffset < EndOffset)

clang-tools-extra/clangd/SourceCode.h

 /// of \p FullyQualifiedName. Returns EOF if there are no shared namespaces.
 /// \p FullyQualifiedName should not contain anonymous namespaces.
 EligibleRegion getEligiblePoints(llvm::StringRef Code,
                                  llvm::StringRef FullyQualifiedName,
                                  const LangOptions &LangOpts);
 
 struct DefinedMacro {
   llvm::StringRef Name;
-  const MacroInfo *Info;
+  CharSourceRange DefRange;
 };
 /// Gets the macro referenced by \p SpelledTok. It must be a spelled token
 /// aligned to the beginning of an identifier.
 llvm::Optional<DefinedMacro> locateMacroAt(const syntax::Token &SpelledTok,
                                            Preprocessor &PP);
 
 /// Infers whether this is a header from the FileName and LangOpts (if
 /// presents).

clang-tools-extra/clangd/SourceCode.cpp

llvm::Optional<DefinedMacro> locateMacroAt(const syntax::Token &SpelledTok,
 
   // Get the definition just before the searched location so that a macro
   // referenced in a '#undef MACRO' can still be found. Note that we only do
   // that if Loc is not pointing at start of file.
   if (SM.getLocForStartOfFile(SM.getFileID(Loc)) != Loc)
     Loc = Loc.getLocWithOffset(-1);
   MacroDefinition MacroDef = PP.getMacroDefinitionAtLoc(IdentifierInfo, Loc);
   if (auto *MI = MacroDef.getMacroInfo())
-    return DefinedMacro{IdentifierInfo->getName(), MI};
+    return DefinedMacro{
+        IdentifierInfo->getName(),
+        // MacroInfo::getDefinitionEndLoc returns the location for last token.
+        CharSourceRange::getTokenRange(MI->getDefinitionLoc(),
+                                       MI->getDefinitionEndLoc())};
   return None;
 }
 
 llvm::Expected<std::string> Edit::apply() const {
   return tooling::applyAllReplacements(InitialCode, Replacements);
 }
 
 std::vector<TextEdit> Edit::asTextEdits() const {

clang-tools-extra/clangd/XRefs.cpp

 }
 
 // Macros are simple: there's no declaration/definition distinction.
 // As a consequence, there's no need to look them up in the index either.
 llvm::Optional<LocatedSymbol>
 locateMacroReferent(const syntax::Token &TouchedIdentifier, ParsedAST &AST,
                     llvm::StringRef MainFilePath) {
   if (auto M = locateMacroAt(TouchedIdentifier, AST.getPreprocessor())) {
-    if (auto Loc = makeLocation(AST.getASTContext(),
-                                M->Info->getDefinitionLoc(), MainFilePath)) {
+    if (auto Loc = makeLocation(AST.getASTContext(), M->DefRange.getBegin(),
+                                MainFilePath)) {
       LocatedSymbol Macro;
       Macro.Name = std::string(M->Name);
       Macro.PreferredDeclaration = *Loc;
       Macro.Definition = Loc;
       return Macro;
     }
   }
   return llvm::None;
ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
   }
   llvm::Optional<DefinedMacro> Macro;
   if (const auto *IdentifierAtCursor =
           syntax::spelledIdentifierTouching(*CurLoc, AST.getTokens())) {
     Macro = locateMacroAt(*IdentifierAtCursor, AST.getPreprocessor());
   }
 
   RefsRequest Req;
-  if (Macro && Macro->Info) {
+  if (Macro) {
     // Handle references to macro.
     if (auto MacroSID =
-            getSymbolID(Macro->Name, Macro->Info->getDefinitionLoc(), SM)) {
+            getSymbolID(Macro->Name, Macro->DefRange.getBegin(), SM)) {
       // Collect macro references from main file.
       const auto &IDToRefs = AST.getMacros().MacroRefs;
       auto Refs = IDToRefs.find(*MacroSID);
       if (Refs != IDToRefs.end()) {
         for (const auto Ref : Refs->second) {
           Location Result;
           Result.range = Ref;
           Result.uri = URIMainFile;
const auto *IdentifierAtCursor =
       syntax::spelledIdentifierTouching(*CurLoc, AST.getTokens());
   if (!IdentifierAtCursor)
     return Results;
 
   if (auto M = locateMacroAt(*IdentifierAtCursor, AST.getPreprocessor())) {
     SymbolDetails NewMacro;
     NewMacro.name = std::string(M->Name);
     llvm::SmallString<32> USR;
-    if (!index::generateUSRForMacro(NewMacro.name, M->Info->getDefinitionLoc(),
-                                    SM, USR)) {
+    if (!index::generateUSRForMacro(NewMacro.name, M->DefRange.getBegin(), SM,
+                                    USR)) {
       NewMacro.USR = std::string(USR.str());
       NewMacro.ID = SymbolID(NewMacro.USR);
     }
     Results.push_back(std::move(NewMacro));
   }
 
   return Results;
 }

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

for (int I = 1;; I++) {
       if (ExpectedRefs.empty())
         break;
 
       auto Loc = sourceLocationInMainFile(SM, ExpectedRefs.begin()->start);
       ASSERT_TRUE(bool(Loc));
       const auto *Id = syntax::spelledIdentifierTouching(*Loc, AST.getTokens());
       ASSERT_TRUE(Id);
       auto Macro = locateMacroAt(*Id, PP);
-      assert(Macro && Macro->Info);
-      auto SID = getSymbolID(Macro->Name, Macro->Info->getDefinitionLoc(), SM);
+      assert(Macro);
+      auto SID = getSymbolID(Macro->Name, Macro->DefRange.getBegin(), SM);
       assert(SID);
 
       EXPECT_THAT(ExpectedRefs,
                   UnorderedElementsAreArray(ActualMacroRefs.MacroRefs[*SID]))
           << "Annotation=" << I << ", MacroName=" << Macro->Name
           << ", Test = " << Test;
     }
     // Unknown macros.
     EXPECT_THAT(AST.getMacros().UnknownMacros,
                 UnorderedElementsAreArray(T.ranges("Unknown")))
         << "Unknown macros doesn't match in " << Test;
   }
 }
 } // namespace
 } // namespace clangd
 } // namespace clang