[clangd] Avoid redundant testcases in rename unittest, NFC.

[merge_guards_bot]

Unit tests: pass. 62009 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

clang-tools-extra/clangd/refactor/Rename.cpp

 std::vector<SourceLocation> findOccurrencesWithinFile(ParsedAST &AST,
                                                       const NamedDecl &ND) {
   // If the cursor is at the underlying CXXRecordDecl of the
   // ClassTemplateDecl, ND will be the CXXRecordDecl. In this case, we need to
   // get the primary template maunally.
   // getUSRsForDeclaration will find other related symbols, e.g. virtual and its
   // overriddens, primary template and all explicit specializations.
   // FIXME: Get rid of the remaining tooling APIs.
-  const auto RenameDecl =
+  const auto *RenameDecl =
       ND.getDescribedTemplate() ? ND.getDescribedTemplate() : &ND;
   std::vector<std::string> RenameUSRs =
       tooling::getUSRsForDeclaration(RenameDecl, AST.getASTContext());
   llvm::DenseSet<SymbolID> TargetIDs;
   for (auto &USR : RenameUSRs)
     TargetIDs.insert(SymbolID(USR));
 
   std::vector<SourceLocation> Results;

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

 
 TEST(CrossFileRenameTests, WithUpToDateIndex) {
   MockCompilationDatabase CDB;
   CDB.ExtraClangFlags = {"-xc++"};
   class IgnoreDiagnostics : public DiagnosticsConsumer {
     void onDiagnosticsReady(PathRef File,
                             std::vector<Diag> Diagnostics) override {}
   } DiagConsumer;
-  // rename is runnning on the "^" point in FooH, and "[[]]" ranges are the
+  // rename is runnning on all "^" points in FooH, and "[[]]" ranges are the
   // expected rename occurrences.
   struct Case {
     llvm::StringRef FooH;
     llvm::StringRef FooCC;
   } Cases[] = {
       {
           // classes.
           R"cpp(
llvm::StringRef FooCC;
         void Foo::[[foo]]() {}
 
         void func(Foo* p) {
           p->[[foo]]();
         }
       )cpp",
       },
       {
-          // Constructor.
+          // rename on constructor and destructor.
           R"cpp(
         class [[Foo]] {
           [[^Foo]]();
-          ~[[Foo]]();
-        };
-      )cpp",
-          R"cpp(
-        #include "foo.h"
-        [[Foo]]::[[Foo]]() {}
-        [[Foo]]::~[[Foo]]() {}
-
-        void func() {
-          [[Foo]] foo;
-        }
-      )cpp",
-      },
-      {
-          // Destructor (selecting before the identifier).
-          R"cpp(
-        class [[Foo]] {
-          [[Foo]]();
           ~[[Foo^]]();
         };
       )cpp",
           R"cpp(
         #include "foo.h"
         [[Foo]]::[[Foo]]() {}
         [[Foo]]::~[[Foo]]() {}
 
for (const auto& T : Cases) {
     ClangdServer Server(CDB, FS, DiagConsumer, ServerOpts);
 
     // Add all files to clangd server to make sure the dynamic index has been
     // built.
     runAddDocument(Server, FooHPath, FooH.code());
     runAddDocument(Server, FooCCPath, FooCC.code());
 
     llvm::StringRef NewName = "NewName";
+    for (const auto &RenamePos : FooH.points()) {
       auto FileEditsList =
-        llvm::cantFail(runRename(Server, FooHPath, FooH.point(), NewName));
-    EXPECT_THAT(applyEdits(std::move(FileEditsList)),
-                UnorderedElementsAre(
-                    Pair(Eq(FooHPath), Eq(expectedResult(T.FooH, NewName))),
-                    Pair(Eq(FooCCPath), Eq(expectedResult(T.FooCC, NewName)))));
+          llvm::cantFail(runRename(Server, FooHPath, RenamePos, NewName));
+      EXPECT_THAT(
+          applyEdits(std::move(FileEditsList)),
     }
   }
+}
 
 TEST(CrossFileRenameTests, CrossFileOnLocalSymbol) {
   // cross-file rename should work for function-local symbols, even there is no
   // index provided.
   Annotations Code("void f(int [[abc]]) { [[a^bc]] = 3; }");
   auto TU = TestTU::withCode(Code.code());
   auto Path = testPath(TU.Filename);
   auto AST = TU.build();