[clangd] Find definition of ClassTemplate without going through index.

[adamcz]

Summary

I noticed that, while go-to-def works on cases like:

namespace ns {

template<typename T> struct Foo {};

}
using ::ns::Fo^o;

it only works because of the FileIndex. We can get definition location
directly from AST too.

[kadircet]

thanks, lgtm!

clang-tools-extra/clangd/XRefs.cpp

const NamedDecl *getDefinition(const NamedDecl *D) {
   assert(D);
   // Decl has one definition that we can find.
   if (const auto *TD = dyn_cast<TagDecl>(D))
     return TD->getDefinition();
   if (const auto *VD = dyn_cast<VarDecl>(D))
     return VD->getDefinition();
   if (const auto *FD = dyn_cast<FunctionDecl>(D))
     return FD->getDefinition();
+  if (const auto *CTD = dyn_cast<ClassTemplateDecl>(D))
+    if (const auto *RD = CTD->getTemplatedDecl())
+      return RD->getDefinition();
   // Objective-C classes can have three types of declarations:
   //
   // - forward declaration: @class MyClass;
   // - true declaration (interface definition): @interface MyClass ... @end
   // - true definition (implementation): @implementation MyClass ... @end
   //
   // Objective-C categories are extensions are on classes:
   //

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

const char *Tests[] = {
         struct S2 { S1 * $decl[[operator]]->(); };
         void test(S2 s2) {
           s2-^>f();
         }
       )cpp",
 
       R"cpp(// Declaration of explicit template specialization
         template <typename T>
-        struct $decl[[Foo]] {};
+        struct $decl[[$def[[Foo]]]] {};
 
         template <>
         struct Fo^o<int> {};
       )cpp",
 
       R"cpp(// Declaration of partial template specialization
         template <typename T>
-        struct $decl[[Foo]] {};
+        struct $decl[[$def[[Foo]]]] {};
 
         template <typename T>
         struct Fo^o<T*> {};
       )cpp",
 
+      R"cpp(// Definition on ClassTemplateDecl
+        namespace ns {
+          // Forward declaration.
+          template<typename T>
+          struct $decl[[Foo]];
+
+          template <typename T>
+          struct $def[[Foo]] {};
+        }
+
+        using ::ns::Fo^o;
+      )cpp",
+
       R"cpp(// auto builtin type (not supported)
         ^auto x = 42;
       )cpp",
 
       R"cpp(// auto on lambda
         auto x = [[[]]]{};
         ^auto y = x;
       )cpp",