[clangd] Add go-to-def metric.

[hokein]

Summary

to track the number of different "special" go-to-def request.

[sammccall]

clang-tools-extra/clangd/XRefs.cpp

376

name could be a bit more explicit, particularly I'd confuse it with go-to on the override keyword.

Maybe method-to-override and method-to-base?

408

template-specialization-to-primary?

429–430

objc-category-to-class?

[hokein]

address comments.

clang-tools-extra/clangd/XRefs.cpp

locateASTReferent(SourceLocation CurLoc, const syntax::Token *TouchedIdentifier,
                   ParsedAST &AST, llvm::StringRef MainFilePath,
                   const SymbolIndex *Index, ASTNodeKind *NodeKind) {
   const SourceManager &SM = AST.getSourceManager();
   // Results follow the order of Symbols.Decls.
   std::vector<LocatedSymbol> Result;
   // Keep track of SymbolID -> index mapping, to fill in index data later.
   llvm::DenseMap<SymbolID, size_t> ResultIndex;
 
+  static constexpr trace::Metric LocateASTReferentMetric(
+      "locate_ast_referent", trace::Metric::Counter, "case");
   auto AddResultDecl = [&](const NamedDecl *D) {
     D = getPreferredDecl(D);
     auto Loc =
         makeLocation(AST.getASTContext(), nameLocation(*D, SM), MainFilePath);
     if (!Loc)
       return;
 
     Result.emplace_back();
locateASTReferent(SourceLocation CurLoc, const syntax::Token *TouchedIdentifier,
   for (const auto &E : Candidates) {
     const NamedDecl *D = E.first;
     if (const auto *CMD = llvm::dyn_cast<CXXMethodDecl>(D)) {
       // Special case: virtual void ^method() = 0: jump to all overrides.
       // FIXME: extend it to ^virtual, unfortunately, virtual location is not
       // saved in the AST.
       if (CMD->isPure()) {
         if (TouchedIdentifier && SM.getSpellingLoc(CMD->getLocation()) ==
-                                     TouchedIdentifier->location())
+                                     TouchedIdentifier->location()) {
           VirtualMethods.insert(getSymbolID(CMD));
+          LocateASTReferentMetric.record(1, "method-to-override");
+        }
       }
       // Special case: void foo() ^override: jump to the overridden method.
       const InheritableAttr *Attr = D->getAttr<OverrideAttr>();
       if (!Attr)
         Attr = D->getAttr<FinalAttr>();
       if (Attr && TouchedIdentifier &&
           SM.getSpellingLoc(Attr->getLocation()) ==
               TouchedIdentifier->location()) {
+        LocateASTReferentMetric.record(1, "method-to-base");
         // We may be overridding multiple methods - offer them all.
         for (const NamedDecl *ND : CMD->overridden_methods())
           AddResultDecl(ND);
         continue;
       }
     }
 
     // Special case: the cursor is on an alias, prefer other results.
     // This targets "using ns::^Foo", where the target is more interesting.
     // This does not trigger on renaming aliases:
     //   `using Foo = ^Bar` already targets Bar via a TypeLoc
     //   `using ^Foo = Bar` has no other results, as Underlying is filtered.
     if (E.second & DeclRelation::Alias && Candidates.size() > 1 &&
         // beginLoc/endLoc are a token range, so rewind the identifier we're in.
         SM.isPointWithin(TouchedIdentifier ? TouchedIdentifier->location()
                                            : CurLoc,
                          D->getBeginLoc(), D->getEndLoc()))
       continue;
 
     // Special case: the point of declaration of a template specialization,
     // it's more useful to navigate to the template declaration.
     if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
       if (TouchedIdentifier &&
           D->getLocation() == TouchedIdentifier->location()) {
+        LocateASTReferentMetric.record(1, "template-specialization-to-primary");
         AddResultDecl(CTSD->getSpecializedTemplate());
         continue;
       }
     }
 
     // Special case: if the class name is selected, also map Objective-C
     // categories and category implementations back to their class interface.
     //
     // Since `TouchedIdentifier` might refer to the `ObjCCategoryImplDecl`
     // instead of the `ObjCCategoryDecl` we intentionally check the contents
     // of the locs when checking for class name equivalence.
     if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D))
       if (const auto *ID = CD->getClassInterface())
         if (TouchedIdentifier &&
             (CD->getLocation() == TouchedIdentifier->location() ||
-             ID->getName() == TouchedIdentifier->text(SM)))
+             ID->getName() == TouchedIdentifier->text(SM))) {
+          LocateASTReferentMetric.record(1, "objc-category-to-class");
           AddResultDecl(ID);
+        }
 
+    LocateASTReferentMetric.record(1, "regular");
     // Otherwise the target declaration is the right one.
     AddResultDecl(D);
   }
 
   // Now query the index for all Symbol IDs we found in the AST.
   if (Index && !ResultIndex.empty()) {
     LookupRequest QueryRequest;
     for (auto It : ResultIndex)