[clangd] Add missing tests to rename feature

[kbobyrev]

Summary

This adds a couple of missed tests from existing clang-rename ones and
introduces several new ones (e.g. static class member). This patch is required
to ensure feature parity for migration off Clang-Rename API D71880.

[hokein]

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

203

hmm, I'm not sure this is needed, I think it is identical with C.

712

nit: we have groups of templates on ~Line 215 already, I'd suggest to move these template-related cases to there.

778

nit: add a comment, this is variable template.

797

this test case is about function templates, move to Line 683.

[kbobyrev]

Address the comments.

[hokein]

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

712

this looks like still undone.

I would move this section (from Line638-Line710) to Line307.

[kbobyrev]

Move the rest of templated cases to appropriate location.

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

llvm::StringRef Tests[] = {
       // Template class, its constructor and destructor.
       R"cpp(
         template <typename T>
         class [[F^oo]] {
           [[F^oo]]();
           ~[[F^oo]]();
           void f([[F^oo]] x);
         };
+
+        template<typename T>
+        [[F^oo]]<T>::[[Fo^o]]() {}
+
+        template<typename T>
+        [[F^oo]]<T>::~[[Fo^o]]() {}
       )cpp",
 
       // Template class constructor.
       R"cpp(
         class [[F^oo]] {
           template<typename T>
           [[Fo^o]]();
 
           template<typename T>
           [[F^oo]](T t);
         };
+
+        template<typename T>
+        [[F^oo]]::[[Fo^o]]() {}
       )cpp",
 
       // Class in template argument.
       R"cpp(
         class [[F^oo]] {};
         template <typename T> void func();
         template <typename T> class Baz {};
         int main() {
llvm::StringRef Tests[] = {
          virtual void [[f^oo]]() {}
         };
         struct B : A {
           void [[f^oo]]() override {}
         };
         struct C : B {
           void [[f^oo]]() override {}
         };
 
         void func() {
           A().[[f^oo]]();
           B().[[f^oo]]();
           C().[[f^oo]]();
         }
       )cpp",
 
+      // Templated method instantiation.
+      R"cpp(
+        template<typename T>
+        class Foo {
+        public:
+          static T [[f^oo]]() {}
+        };
+
+        void bar() {
+          Foo<int>::[[f^oo]]();
+        }
+      )cpp",
+      R"cpp(
+        template<typename T>
+        class Foo {
+        public:
+          T [[f^oo]]() {}
+        };
+
+        void bar() {
+          Foo<int>().[[f^oo]]();
+        }
+      )cpp",
+
       // Template class (partial) specializations.
       R"cpp(
         template <typename T>
         class [[F^oo]] {};
 
         template<>
         class [[F^oo]]<bool> {};
         template <typename T>
llvm::StringRef Tests[] = {
 
         void func() {
           A<int>().[[f^oo]]();
           A<double>().[[f^oo]]();
           A<float>().[[f^oo]]();
         }
       )cpp",
 
+      // Templated class specialization.
+      R"cpp(
+        template<typename T, typename U=bool>
+        class [[Foo^]];
+
+        template<typename T, typename U>
+        class [[Foo^]] {};
+
+        template<typename T=int, typename U>
+        class [[Foo^]];
+      )cpp",
+      R"cpp(
+        template<typename T=float, typename U=int>
+        class [[Foo^]];
+
+        template<typename T, typename U>
+        class [[Foo^]] {};
+      )cpp",
+
+      // Function template specialization.
+      R"cpp(
+        template<typename T=int, typename U=bool>
+        U [[foo^]]();
+
+        template<typename T, typename U>
+        U [[foo^]]() {};
+      )cpp",
+      R"cpp(
+        template<typename T, typename U>
+        U [[foo^]]() {};
+
+        template<typename T=int, typename U=bool>
+        U [[foo^]]();
+      )cpp",
+      R"cpp(
+        template<typename T=int, typename U=bool>
+        U [[foo^]]();
+
+        template<typename T, typename U>
+        U [[foo^]]();
+      )cpp",
+      R"cpp(
+        template <typename T>
+        void [[f^oo]](T t);
+
+        template <>
+        void [[f^oo]](int a);
+
+        void test() {
+          [[f^oo]]<double>(1);
+        }
+      )cpp",
+
+      // Variable template.
+      R"cpp(
+        template <typename T, int U>
+        bool [[F^oo]] = true;
+
+        // Explicit template specialization
+        template <>
+        bool [[F^oo]]<int, 0> = false;
+
+        // Partial template specialization
+        template <typename T>
+        bool [[F^oo]]<T, 1> = false;
+
+        void foo() {
+          // Ref to the explicit template specialization
+          [[F^oo]]<int, 0>;
+          // Ref to the primary template.
+          [[F^oo]]<double, 2>;
+        }
+      )cpp",
+
       // Complicated class type.
       R"cpp(
          // Forward declaration.
         class [[Fo^o]];
         class Baz {
           virtual int getValue() const = 0;
         };
 
llvm::StringRef Tests[] = {
           const Baz &BazReference = foo;
           const Baz *BazPointer = &foo;
           reinterpret_cast<const [[^Foo]] *>(BazPointer)->getValue();
           static_cast<const [[^Foo]] &>(BazReference).getValue();
           static_cast<const [[^Foo]] *>(BazPointer)->getValue();
         }
       )cpp",
 
+      // Static class member.
+      R"cpp(
+        struct Foo {
+          static Foo *[[Static^Member]];
+        };
+
+        Foo* Foo::[[Static^Member]] = nullptr;
+
+        void foo() {
+          Foo* Pointer = Foo::[[Static^Member]];
+        }
+      )cpp",
+
       // Reference in lambda parameters.
       R"cpp(
         template <class T>
         class function;
         template <class R, class... ArgTypes>
         class function<R(ArgTypes...)> {
         public:
           template <typename Functor>
llvm::StringRef Tests[] = {
 
         [[Old^Alias]] old_alias;
         }
 
         void bar() {
           ns::[[Old^Alias]] Bar;
         }
       )cpp",
+
+      // User defined conversion.
+      R"cpp(
+        class [[F^oo]] {
+        public:
+          [[F^oo]]() {}
+        };
+
+        class Baz {
+        public:
+          operator [[F^oo]]() {
+            return [[F^oo]]();
+          }
+        };
+
+        int main() {
+          Baz boo;
+          [[F^oo]] foo = static_cast<[[F^oo]]>(boo);
+        }
+      )cpp",
   };
   llvm::StringRef NewName = "NewName";
   for (llvm::StringRef T : Tests) {
     SCOPED_TRACE(T);
     Annotations Code(T);
     auto TU = TestTU::withCode(Code.code());
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
     auto AST = TU.build();
TEST(RenameTest, Renameable) {
   const bool HeaderFile = true;
   Case Cases[] = {
       {R"cpp(// allow -- function-local
         void f(int [[Lo^cal]]) {
           [[Local]] = 2;
         }
       )cpp",
        nullptr, HeaderFile, Index},
 
       {R"cpp(// allow -- symbol is indexable and has no refs in index.
         void [[On^lyInThisFile]]();
       )cpp",
        nullptr, HeaderFile, Index},
 
       {R"cpp(
         void ^f();
       )cpp",
        "keyword", HeaderFile, Index, "return"},
 
       {R"cpp(// disallow -- symbol is indexable and has other refs in index.
         void f() {
           Out^side s;
         }
       )cpp",
        "used outside main file", HeaderFile, Index},
 
       {R"cpp(// disallow -- symbol in anonymous namespace in header is not indexable.
         namespace {
         class Unin^dexable {};
         }
       )cpp",
        "not eligible for indexing", HeaderFile, Index},
 
       {R"cpp(// allow -- symbol in anonymous namespace in non-header file is indexable.
         namespace {
         class [[F^oo]] {};