[clangd] Allow programmatically disabling rename of virtual method hierarchies.

[sammccall]

Summary

This feature relies on Relations in the index being complete.
An out-of-tree index implementation is missing some override relations, so
such renames end up breaking the code.
We plan to fix it, but this flag is a cheap band-aid for now.

[kadircet]

thanks, lgtm!

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

223

nit: maybe do the check near the top, where the rest of the unsupportedsymbols are checked (+ it gives us a early bail out and skip a bunch of file/location conversions).

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

 
 struct RenameOptions {
   /// The maximum number of affected files (0 means no limit), only meaningful
   /// when AllowCrossFile = true.
   /// If the actual number exceeds the limit, rename is forbidden.
   size_t LimitFiles = 50;
   /// If true, format the rename edits, only meaningful in ClangdServer layer.
   bool WantFormat = false;
+  /// Allow rename of virtual method hierarchies.
+  /// Disable to support broken index implementations with missing relations.
+  /// FIXME: fix those implementations and remove this option.
+  bool RenameVirtual = true;
 };
 
 struct RenameInputs {
   Position Pos; // the position triggering the rename
   llvm::StringRef NewName;
 
   ParsedAST *
   llvm::StringRef MainFilePath;

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

enum class ReasonToReject {
   AmbiguousSymbol,
 
   // name validation. FIXME: reconcile with InvalidName
   SameName,
 };
 
 llvm::Optional<ReasonToReject> renameable(const NamedDecl &RenameDecl,
                                           StringRef MainFilePath,
-                                          const SymbolIndex *Index) {
+                                          const SymbolIndex *Index,
+                                          const RenameOptions& Opts) {
   trace::Span Tracer("Renameable");
+  if (!Opts.RenameVirtual) {
+    if (const auto *S = llvm::dyn_cast<CXXMethodDecl>(&RenameDecl)) {
+      if (S->isVirtual())
+        return ReasonToReject::UnsupportedSymbol;
+    }
+  }
   // Filter out symbols that are unsupported in both rename modes.
   if (llvm::isa<NamespaceDecl>(&RenameDecl))
     return ReasonToReject::UnsupportedSymbol;
   if (const auto *FD = llvm::dyn_cast<FunctionDecl>(&RenameDecl)) {
     if (FD->isOverloadedOperator())
       return ReasonToReject::UnsupportedSymbol;
   }
   // function-local symbols is safe to rename.
if (MainFileIsHeader)
     IsMainFileOnly = false;
   else if (!DeclaredInMainFile)
     IsMainFileOnly = false;
   // If the symbol is not indexable, we disallow rename.
   if (!SymbolCollector::shouldCollectSymbol(
           RenameDecl, RenameDecl.getASTContext(), SymbolCollector::Options(),
           IsMainFileOnly))
     return ReasonToReject::NonIndexable;
 
   return None;
 }
 
 llvm::Error makeError(ReasonToReject Reason) {
   auto Message = [](ReasonToReject Reason) {
     switch (Reason) {
     case ReasonToReject::NoSymbolFound:
       return "there is no symbol at the given location";
llvm::Expected<RenameResult> rename(const RenameInputs &RInputs) {
   if (!ID)
     return makeError(ReasonToReject::UnsupportedSymbol);
   if (ID->getName() == RInputs.NewName)
     return makeError(ReasonToReject::SameName);
   auto Invalid = checkName(RenameDecl, RInputs.NewName);
   if (Invalid)
     return makeError(std::move(*Invalid));
 
-  auto Reject = renameable(RenameDecl, RInputs.MainFilePath, RInputs.Index);
+  auto Reject =
+      renameable(RenameDecl, RInputs.MainFilePath, RInputs.Index, Opts);
   if (Reject)
     return makeError(*Reject);
 
   // We have two implementations of the rename:
   //   - AST-based rename: used for renaming local symbols, e.g. variables
   //     defined in a function body;
   //   - index-based rename: used for renaming non-local symbols, and not
   //     feasible for local symbols (as by design our index don't index these