[clangd] Rename: Allow renaming virtual methods overriding multiple base methods [2/3]

[tom-anders]

Summary

For virtual methods that override the same method from multiple base classes (e.g. diamond-shaped inheritance graph) previously only one of the base class methods would be renamed.
Now, we report a canonicalDeclaration for each base class and will thus correctly rename all of them.

[tom-anders]

clang-format

[tom-anders]

Fix test case

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

return canonicalRenameDecls(
             ->getTemplatedDecl());
   if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
     if (Method->getDeclKind() == Decl::Kind::CXXConstructor ||
         Method->getDeclKind() == Decl::Kind::CXXDestructor)
       return canonicalRenameDecls(Method->getParent());
     if (const FunctionDecl *InstantiatedMethod =
             Method->getInstantiatedFromMemberFunction())
       return canonicalRenameDecls(InstantiatedMethod);
-    // FIXME(kirillbobyrev): For virtual methods with
-    // size_overridden_methods() > 1, this will not rename all functions it
-    // overrides, because this code assumes there is a single canonical
-    // declaration.
-    if (Method->isVirtual() && Method->size_overridden_methods())
-      return {canonicalRenameDecls(*Method->overridden_methods().begin())};
+    if (Method->isVirtual() && Method->size_overridden_methods()) {
+      llvm::DenseSet<const NamedDecl *> Result;
+      for (const auto *OM : Method->overridden_methods()) {
+        auto Decls = canonicalRenameDecls(OM);
+        Result.insert(Decls.begin(), Decls.end());
+      }
+      return Result;
+    }
   }
   if (const auto *Function = dyn_cast<FunctionDecl>(D))
     if (const FunctionTemplateDecl *Template = Function->getPrimaryTemplate())
       return canonicalRenameDecls(Template);
   if (const auto *Field = dyn_cast<FieldDecl>(D)) {
     // This is a hacky way to do something like
     // CXXMethodDecl::getInstantiatedFromMemberFunction for the field because
     // Clang AST does not store relevant information about the field that is

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

llvm::StringRef FooCC;
       },
       {
           // virtual methods.
           R"cpp(
         class Base {
           virtual void [[foo]]();
         };
         class Derived1 : public Base {
-          void [[f^oo]]() override;
+          void [[foo]]() override;
         };
-        class NotDerived {
-          void foo() {};
+        class Derived2 : public Base {
+          void [[foo]]() override;
+        };
+        class DerivedDerived : public Derived1, public Derived2 {
+          void foo() override;
         }
       )cpp",
           R"cpp(
         #include "foo.h"
         void Base::[[foo]]() {}
         void Derived1::[[foo]]() {}
+        void Derived2::[[foo]]() {}
+        void DerivedDerived::[[foo]]() {}
 
-        class Derived2 : public Derived1 {
+        class Derived3 : public Derived1 {
           void [[foo]]() override {};
         };
 
-        void func(Base* b, Derived1* d1, 
-                  Derived2* d2, NotDerived* nd) {
+        void func(Base* b, Derived1* d1, Derived2* d2,
+                  DerivedDerived* dd, NotDerived* nd) {
           b->[[foo]]();
           d1->[[foo]]();
           d2->[[foo]]();
+          dd->[[foo]]();
           nd->foo();
         }
       )cpp",
       },
       {
           // virtual templated method
           R"cpp(
         template <typename> class Foo { virtual void [[m]](); };