[clangd] Change getSymbolID to accept macro location instead of macro info

clang-tools-extra/clangd/AST.h

 /// Gets the symbol ID for a macro, if possible.
 /// Currently, this is an encoded USR of the macro, which incorporates macro
 /// locations (e.g. file name, offset in file).
 /// FIXME: the USR semantics might not be stable enough as the ID for index
 /// macro (e.g. a change in definition offset can result in a different USR). We
 /// could change these semantics in the future by reimplementing this funcure
 /// (e.g. avoid USR for macros).
 llvm::Optional<SymbolID> getSymbolID(const llvm::StringRef MacroName,
-                                     const MacroInfo *MI,
+                                     SourceLocation DefLoc,
                                      const SourceManager &SM);
 
 /// Returns a QualType as string. The result doesn't contain unwritten scopes
 /// like anonymous/inline namespace.
 std::string printType(const QualType QT, const DeclContext &CurContext);
 
 /// Indicates if \p D is a template instantiation implicitly generated by the
 /// compiler, e.g.

clang-tools-extra/clangd/AST.cpp

 llvm::Optional<SymbolID> getSymbolID(const Decl *D) {
   llvm::SmallString<128> USR;
   if (index::generateUSRForDecl(D, USR))
     return None;
   return SymbolID(USR);
 }
 
 llvm::Optional<SymbolID> getSymbolID(const llvm::StringRef MacroName,
-                                     const MacroInfo *MI,
+                                     SourceLocation DefLoc,
                                      const SourceManager &SM) {
-  if (MI == nullptr)
-    return None;
   llvm::SmallString<128> USR;
-  if (index::generateUSRForMacro(MacroName, MI->getDefinitionLoc(), SM, USR))
+  if (index::generateUSRForMacro(MacroName, DefLoc, SM, USR))
     return None;
   return SymbolID(USR);
 }
 
 // FIXME: This should be handled while printing underlying decls instead.
 std::string printType(const QualType QT, const DeclContext &CurContext) {
   std::string Result;
   llvm::raw_string_ostream OS(Result);

clang-tools-extra/clangd/CodeComplete.cpp

llvm::Optional<SymbolID> getSymbolID(const CodeCompletionResult &R,
   case CodeCompletionResult::RK_Declaration:
   case CodeCompletionResult::RK_Pattern: {
     // Computing USR caches linkage, which may change after code completion.
     if (hasUnstableLinkage(R.Declaration))
       return llvm::None;
     return clang::clangd::getSymbolID(R.Declaration);
   }
   case CodeCompletionResult::RK_Macro:
-    return clang::clangd::getSymbolID(R.Macro->getName(), R.MacroDefInfo, SM);
+    if (!R.MacroDefInfo)
+      return llvm::None;
+    return clang::clangd::getSymbolID(R.Macro->getName(),
+                                      R.MacroDefInfo->getDefinitionLoc(), SM);
   case CodeCompletionResult::RK_Keyword:
-    return None;
+    return llvm::None;
   }
   llvm_unreachable("unknown CodeCompletionResult kind");
 }
 
 // Scopes of the partial identifier we're trying to complete.
 // It is used when we query the index for more completion results.
 struct SpecifiedScope {
   // The scopes we should look in, determined by Sema.

clang-tools-extra/clangd/CollectMacros.cpp

 //===--- CollectMacros.cpp ---------------------------------------*- C++-*-===//
 //
 // 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 "CollectMacros.h"
+#include "index/SymbolID.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/Lexer.h"
+#include "llvm/ADT/Optional.h"
 
 namespace clang {
 namespace clangd {
 
 void CollectMainFileMacros::add(const Token &MacroNameTok,
                                 const MacroInfo *MI) {
   if (!InMainFile)
     return;
   auto Loc = MacroNameTok.getLocation();
   if (Loc.isInvalid() || Loc.isMacroID())
     return;
 
   auto Name = MacroNameTok.getIdentifierInfo()->getName();
   Out.Names.insert(Name);
   auto Range = halfOpenToRange(
       SM, CharSourceRange::getCharRange(Loc, MacroNameTok.getEndLoc()));
-  if (auto SID = getSymbolID(Name, MI, SM))
+  llvm::Optional<SymbolID> SID;
+  if (MI)
+    SID = getSymbolID(Name, MI->getDefinitionLoc(), SM);
+  if (SID)
     Out.MacroRefs[*SID].push_back(Range);
   else
     Out.UnknownMacros.push_back(Range);
 }
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/XRefs.cpp

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) {
+  if (Macro && Macro->Info) {
     // Handle references to macro.
-    if (auto MacroSID = getSymbolID(Macro->Name, Macro->Info, SM)) {
+    if (auto MacroSID =
+            getSymbolID(Macro->Name, Macro->Info->getDefinitionLoc(), 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;

clang-tools-extra/clangd/index/SymbolCollector.cpp

bool SymbolCollector::handleMacroOccurrence(const IdentifierInfo *Name,
   // Builtin macros don't have useful locations and aren't needed in completion.
   if (MI->isBuiltinMacro())
     return true;
 
   // Also avoid storing predefined macros like __DBL_MIN__.
   if (SM.isWrittenInBuiltinFile(DefLoc))
     return true;
 
-  auto ID = getSymbolID(Name->getName(), MI, SM);
+  auto ID = getSymbolID(Name->getName(), DefLoc, SM);
   if (!ID)
     return true;
 
   // Do not store references to main-file macros.
   if ((static_cast<unsigned>(Opts.RefFilter) & Roles) && !IsMainFileSymbol &&
       (Opts.RefsInHeaders || SM.getFileID(SpellingLoc) == SM.getMainFileID()))
     MacroRefs[*ID].push_back({Loc, Roles});
 
if (auto ID = getSymbolID(ND)) {
       IncRef(*ID);
     }
   }
   if (Opts.CollectMacro) {
     assert(PP);
     // First, drop header guards. We can't identify these until EOF.
     for (const IdentifierInfo *II : IndexedMacros) {
       if (const auto *MI = PP->getMacroDefinition(II).getMacroInfo())
-        if (auto ID = getSymbolID(II->getName(), MI, PP->getSourceManager()))
+        if (auto ID = getSymbolID(II->getName(), MI->getDefinitionLoc(),
+                                  PP->getSourceManager()))
           if (MI->isUsedForHeaderGuard())
             Symbols.erase(*ID);
     }
     // Now increment refcounts.
     for (const IdentifierInfo *II : ReferencedMacros) {
       if (const auto *MI = PP->getMacroDefinition(II).getMacroInfo())
-        if (auto ID = getSymbolID(II->getName(), MI, PP->getSourceManager()))
+        if (auto ID = getSymbolID(II->getName(), MI->getDefinitionLoc(),
+                                  PP->getSourceManager()))
           IncRef(*ID);
     }
   }
   // Fill in IncludeHeaders.
   // We delay this until end of TU so header guards are all resolved.
   // Symbols in slabs aren' mutable, so insert() has to walk all the strings
   // :-(
   llvm::SmallString<256> QName;

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);
-      auto SID = getSymbolID(Macro->Name, Macro->Info, SM);
+      assert(Macro && Macro->Info);
+      auto SID = getSymbolID(Macro->Name, Macro->Info->getDefinitionLoc(), 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