[clangd] Navigation from definition of template specialization to primary template

[nridge]

Summary

Fixes https://github.com/clangd/clangd/issues/212.

[sammccall]

Nice!

clang-tools-extra/clangd/XRefs.cpp

194

Not thrilled about reusing this after previous patches disentangled it - it works well for macros but if (for example) you have a templated operator<< I think the feature you're adding probably won't work.

That said, I don't see a simple alternative, and it's unlikely to be a big deal, so I think this is OK.

240

Be aware that this is going to break "go to definition" toggling between def and decl. I think that's fine.

240

(I think you probably want the macro-arg-expanded location here)

[nridge]

Address comment

clang-tools-extra/clangd/XRefs.cpp

240

For what will this break toggling? Aas far as I'm aware, partial and explicit specializations of templates do not have separate declarations.

[nridge]

clang-tools-extra/clangd/XRefs.cpp

240

I stand corrected: I checked, and it seems like specializations can indeed have forward declarations.

I expect they are relatively rare, though, and it's probably fine to break toggling for them, like you said.

clang-tools-extra/clangd/XRefs.cpp

if (!Inc.Resolved.empty() && Inc.R.start.line == Pos.line) {
       File.Definition = File.PreferredDeclaration;
       // We're not going to find any further symbols on #include lines.
       return {std::move(File)};
     }
   }
 
   // Macros are simple: there's no declaration/definition distinction.
   // As a consequence, there's no need to look them up in the index either.
-  SourceLocation MaybeMacroLocation = SM.getMacroArgExpandedLocation(
+  SourceLocation IdentStartLoc = SM.getMacroArgExpandedLocation(
       getBeginningOfIdentifier(Pos, AST.getSourceManager(), AST.getLangOpts()));
   std::vector<LocatedSymbol> Result;
-  if (auto M = locateMacroAt(MaybeMacroLocation, AST.getPreprocessor())) {
+  if (auto M = locateMacroAt(IdentStartLoc, AST.getPreprocessor())) {
     if (auto Loc = makeLocation(AST.getASTContext(),
                                 M->Info->getDefinitionLoc(), *MainFilePath)) {
       LocatedSymbol Macro;
       Macro.Name = M->Name;
       Macro.PreferredDeclaration = *Loc;
       Macro.Definition = Loc;
       Result.push_back(std::move(Macro));
 
std::vector<LocatedSymbol> locateSymbolAt(ParsedAST &AST, Position Pos,
   }
 
   // Emit all symbol locations (declaration or definition) from AST.
   DeclRelationSet Relations =
       DeclRelation::TemplatePattern | DeclRelation::Alias;
   for (const Decl *D : getDeclAtPosition(AST, SourceLoc, Relations)) {
     const Decl *Def = getDefinition(D);
     const Decl *Preferred = Def ? Def : D;
+
+    // If we're at the point of declaration of a template specialization,
+    // it's more useful to navigate to the template declaration.
+    if (Preferred->getLocation() == IdentStartLoc) {
+      if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Preferred)) {
+        D = CTSD->getSpecializedTemplate();
+        Def = getDefinition(D);
+        Preferred = Def ? Def : D;
+      }
+    }
+
     auto Loc = makeLocation(AST.getASTContext(),
                             spellingLocIfSpelled(findName(Preferred), SM),
                             *MainFilePath);
     if (!Loc)
       continue;
 
     Result.emplace_back();
     if (auto *ND = dyn_cast<NamedDecl>(Preferred))

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

const char *Tests[] = {
       R"cpp(
         struct X {
           X& [[operator]]++() {}
         };
         void foo(X& x) {
           +^+x;
         }
       )cpp",
-  };
+
+      R"cpp(// Declaration of explicit template specialization
+        template <typename T>
+        struct $decl[[Foo]] {};
+
+        template <>
+        struct Fo^o<int> {};
+      )cpp",
+
+      R"cpp(// Declaration of partial template specialization
+        template <typename T>
+        struct $decl[[Foo]] {};
+
+        template <typename T>
+        struct Fo^o<T*> {};
+      )cpp"};
   for (const char *Test : Tests) {
     Annotations T(Test);
     llvm::Optional<Range> WantDecl;
     llvm::Optional<Range> WantDef;
     if (!T.ranges().empty())
       WantDecl = WantDef = T.range();
     if (!T.ranges("decl").empty())
       WantDecl = T.range("decl");