[clangd] Add rename support.

[hokein]

Summary

Make clangd handle "textDocument/rename" request. The rename
functionality comes from the "local-rename" sub-tool of clang-refactor.

Currently clangd only supports local rename (only symbol occurrences in
the main file will be renamed).

[sammccall]

Impl LG apart from error handling :-)

clangd/ClangdServer.cpp

338

I think you can split out a private method:

Expected<vector<Replacement>> ClangdServer::applyRefactoring(RefactoringActionRuleBase&);

This would make this function easier to read by separating out the rename-specific stuff from (some of) the boilerplate.
(It also seems likely to be reusable if we add direct support for other refactorings, but that's not the main reason I think)

345

don't you want to do something here?

347

I don't think you need to override this, assuming you don't expect any of these

369

else?

377

Add to the comment what you actually want to fix :-)
Things we may want:

• rename in any included header
• rename only in the "main" header
• provide an error if there are decls we won't rename (e.g. if you rename std::vector)
• rename globally in project (this may be slow or surprising, so I'd make that a more explicit action)
• rename in open files (though I'm leery about side-effects of open files)

clangd/ClangdUnit.cpp

1399

nit: the rest of this file defines functions outside their namespace.

TBH I prefer the style you're using here, but we should be consistent within a file.

test/clangd/rename.test

2

For new tests after rL317486, please add -pretty and FileCheck -strict-whitespace

(See that patch for how the CHECKs should look)

15

uber-nit: the # line previous to this one is for spacing, no need for another blank line (or any of them, as far as I'm concerned)

26

No need to assert the response from shutdown (I removed most of these recently)

[arphaman]

Side-comment: will want to let the user know about the fact that global symbols aren't really renamed yet until global rename works?

[ilya-biryukov]

Just a few minor code style comments.

clangd/ClangdServer.cpp

367

NIT: local vars are UpperCamelCase

clangd/ClangdUnit.cpp

1399

+1. Let's document and enforce the preferred style in new commits.
But better done in a separate commit for all of clangd and let's stick to the original style in this file for now.

[hokein]

• address review comments.
• add error handling.

[hokein]

clangd/ClangdServer.cpp

338

I'd keep the code in Rename currently, as most of the code is rename-specific, we can refactor it out when the need arises.

347

We have to override this method, the default implementation (generating an "unsupported result" error) is not sensible for clangd.
Added a comment for it.

clangd/ClangdUnit.cpp

1399

Reserved to the original style. Yeah, +1 on change the style for this huge file. Currently, it is not clear for read.

[sammccall]

clangd/ClangdServer.cpp

338

OK, then please find some other way to simplify/break up this method - it's too long and complicated.

347

I don't understand.

My reading was that we expect handle(SymbolOccurrences) to never be called. If it was called, this is an internal problem and reporting an error seems reasonable.

Under what circumstances would it be called *and* the right response would be to ignore it?

359

the current refactoring engine doesn't call handle() multiple times, nor both handleError() and handle(), but I don't see that guaranteed anywhere.

At least we should assert that we're not overwriting anything.

[hokein]

Simplify the code.

[hokein]

clangd/ClangdServer.cpp

347

Oops, you are right. I misread the code of RenameOccurrences: I thought the rename workflow is to find the occurrences, pass to occurrences to the ResultConsumer, generate the atomic change and pass it to ResultConsumer. But the it turns out it just uses the occurrences to generate atomic change directly.

359

I think the engine should do it (the current refactoring rule implementations imply it). If the refactoring succeeds, call "handle(AtomicChanges)" to pass the result; If any error happened during refactoring, call "handle(Error)".

But adding assert is safer.

[sammccall]

clangd/ClangdServer.cpp

67

why is this needed? shouldn't inheriting the base method be enough if it's only ever called through the base?

[hokein]

clangd/ClangdServer.cpp

67

We need this to make compiler happy, otherwise the compiler will emit "overloaded-virtual" error (the handle(SymbolOccurrences) will be hidden in this class).

clangd/CMakeLists.txt

add_clang_library(clangDaemon
   clangFormat
   clangFrontend
   clangIndex
   clangLex
   clangSema
   clangSerialization
   clangTooling
   clangToolingCore
+  clangToolingRefactor
   ${LLVM_PTHREAD_LIB}
   )
 
 if( LLVM_LIB_FUZZING_ENGINE OR LLVM_USE_SANITIZE_COVERAGE )
   add_subdirectory(fuzzer)
 endif()
 add_subdirectory(tool)

clangd/ClangdLSPServer.h

private:
   void onDocumentFormatting(Ctx C, DocumentFormattingParams &Params) override;
   void onCodeAction(Ctx C, CodeActionParams &Params) override;
   void onCompletion(Ctx C, TextDocumentPositionParams &Params) override;
   void onSignatureHelp(Ctx C, TextDocumentPositionParams &Params) override;
   void onGoToDefinition(Ctx C, TextDocumentPositionParams &Params) override;
   void onSwitchSourceHeader(Ctx C, TextDocumentIdentifier &Params) override;
   void onFileEvent(Ctx C, DidChangeWatchedFilesParams &Params) override;
   void onCommand(Ctx C, ExecuteCommandParams &Params) override;
+  void onRename(Ctx C, RenameParams &Parames) override;
 
   std::vector<clang::tooling::Replacement>
   getFixIts(StringRef File, const clangd::Diagnostic &D);
 
   JSONOutput &Out;
   /// Used to indicate that the 'shutdown' request was received from the
   /// Language Server client.
   bool ShutdownRequestReceived = false;

clangd/ClangdLSPServer.cpp

C.reply(json::obj{
            {"resolveProvider", false},
            {"triggerCharacters", {".", ">", ":"}},
        }},
       {"signatureHelpProvider",
        json::obj{
            {"triggerCharacters", {"(", ","}},
        }},
       {"definitionProvider", true},
+      {"renameProvider", true},
       {"executeCommandProvider",
        json::obj{
            {"commands", {ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND}},
        }},
   });
   if (Params.rootUri && !Params.rootUri->file.empty())
     Server.setRootPath(Params.rootUri->file);
   else if (Params.rootPath && !Params.rootPath->empty())
if (Params.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND &&
     // parsed in the first place and this handler should not be called. But if
     // more commands are added, this will be here has a safe guard.
     C.replyError(
         ErrorCode::InvalidParams,
         llvm::formatv("Unsupported command \"{0}\".", Params.command).str());
   }
 }
 
+void ClangdLSPServer::onRename(Ctx C, RenameParams &Params) {
+  auto File = Params.textDocument.uri.file;
+  auto Replacements = Server.rename(File, Params.position, Params.newName);
+  if (!Replacements) {
+    C.replyError(
+        ErrorCode::InternalError,
+        llvm::toString(Replacements.takeError()));
+    return;
+  }
+  std::string Code = Server.getDocument(File);
+  std::vector<TextEdit> Edits = replacementsToEdits(Code, *Replacements);
+  WorkspaceEdit WE;
+  WE.changes = {{llvm::yaml::escape(Params.textDocument.uri.uri), Edits}};
+  C.reply(WorkspaceEdit::unparse(WE));
+}
+
 void ClangdLSPServer::onDocumentDidClose(Ctx C,
                                          DidCloseTextDocumentParams &Params) {
   Server.removeDocument(Params.textDocument.uri.file);
 }
 
 void ClangdLSPServer::onDocumentOnTypeFormatting(
     Ctx C, DocumentOnTypeFormattingParams &Params) {
   auto File = Params.textDocument.uri.file;

clangd/ClangdServer.h

public:
   llvm::Optional<Path> switchSourceHeader(PathRef Path);
 
   /// Run formatting for \p Rng inside \p File.
   std::vector<tooling::Replacement> formatRange(PathRef File, Range Rng);
   /// Run formatting for the whole \p File.
   std::vector<tooling::Replacement> formatFile(PathRef File);
   /// Run formatting after a character was typed at \p Pos in \p File.
   std::vector<tooling::Replacement> formatOnType(PathRef File, Position Pos);
+  /// Rename all occurrences of the symbol at the \p Pos in \p File to
+  /// \p NewName.
+  Expected<std::vector<tooling::Replacement>> rename(PathRef File, Position Pos,
+                                                     llvm::StringRef NewName);
 
   /// Gets current document contents for \p File. \p File must point to a
   /// currently tracked file.
   /// FIXME(ibiryukov): This function is here to allow offset-to-Position
   /// conversions in outside code, maybe there's a way to get rid of it.
   std::string getDocument(PathRef File);
 
   /// Only for testing purposes.

clangd/ClangdServer.cpp

 //===--- ClangdServer.cpp - Main clangd server code --------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===-------------------------------------------------------------------===//
 
 #include "ClangdServer.h"
 #include "clang/Format/Format.h"
+#include "clang/Tooling/Refactoring/RefactoringResultConsumer.h"
+#include "clang/Tooling/Refactoring/Rename/RenamingAction.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatProviders.h"
 #include "llvm/Support/FormatVariadic.h"
size_t clangd::positionToOffset(StringRef Code, Position P) {
   size_t Offset = 0;
   for (int I = 0; I != P.line; ++I) {
     // FIXME: \r\n
     // FIXME: UTF-8
     size_t F = Code.find('\n', Offset);
     if (F == StringRef::npos)
       return 0; // FIXME: Is this reasonable?
     Offset = F + 1;
   }
   return (Offset == 0 ? 0 : (Offset - 1)) + P.character;
 }
 
 /// Turn an offset in Code into a [line, column] pair.
 Position clangd::offsetToPosition(StringRef Code, size_t Offset) {
   StringRef JustBefore = Code.substr(0, Offset);
   // FIXME: \r\n
   // FIXME: UTF-8
std::vector<tooling::Replacement> ClangdServer::formatOnType(PathRef File,
   size_t PreviousLBracePos = StringRef(Code).find_last_of('{', CursorPos);
   if (PreviousLBracePos == StringRef::npos)
     PreviousLBracePos = CursorPos;
   size_t Len = 1 + CursorPos - PreviousLBracePos;
 
   return formatCode(Code, File, {tooling::Range(PreviousLBracePos, Len)});
 }
 
+Expected<std::vector<tooling::Replacement>>
+ClangdServer::rename(PathRef File, Position Pos, llvm::StringRef NewName) {
+  std::string Code = getDocument(File);
+  std::shared_ptr<CppFile> Resources = Units.getFile(File);
+  class RenameResultCollector final
+      : public tooling::RefactoringResultConsumer {
+  public:
+    void handleError(llvm::Error Err) override {
+      // FIXME: figure out a way to return better message for DiagnosticError.
+      // clangd uses llvm::toString to convert the Err to string, however, for
+      // DiagnosticError, only "clang diagnostic" will be generated.
+      Result = std::move(Err);
+    }
+
+    void handle(tooling::SymbolOccurrences) override {
+      // Don't reply on the default implementation.
+      // The default implementation will generate "unsupported" error, but we
+      // don't want it in clangd.
+    }
+
+    void handle(tooling::AtomicChanges SourceReplacements) override {
+      Result = std::move(SourceReplacements);
+    }
+
+    Optional<Expected<tooling::AtomicChanges>> Result;
+  };
+  RenameResultCollector ResultCollector;
+  Resources->getAST().get()->runUnderLock([&](ParsedAST *AST) {
+    const SourceManager &SourceMgr = AST->getASTContext().getSourceManager();
+    const FileEntry *FE =
+        SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
+    if (!FE)
+      return;
+    SourceLocation SourceLocationBeg =
+        clangd::getBeginningOfIdentifier(*AST, Pos, FE);
+    tooling::RefactoringRuleContext Context(
+        AST->getASTContext().getSourceManager());
+    Context.setASTContext(AST->getASTContext());
+    auto Rename = clang::tooling::RenameOccurrences::initiate(
+        Context, SourceRange(SourceLocationBeg), NewName.str());
+    if (!Rename) {
+      ResultCollector.Result = Rename.takeError();
+      return;
+    }
+    Rename->invoke(ResultCollector, Context);
+  });
+  assert(ResultCollector.Result.hasValue());
+  if (!ResultCollector.Result.getValue())
+    return ResultCollector.Result->takeError();
+
+  std::vector<tooling::Replacement> Replacements;
+  for (const tooling::AtomicChange &Change : ResultCollector.Result->get()) {
+    tooling::Replacements ChangeReps = Change.getReplacements();
+    for (const auto &Rep : ChangeReps) {
+      // FIXME: Right now we only support renaming the main file, so we drop
+      // replacements not for the main file. In the future, we might consider to
+      // support:
+      //   * rename in any included header
+      //   * rename only in the "main" header
+      //   * provide an error if there are symbols we won't rename (e.g.
+      //     std::vector)
+      //   * rename globally in project
+      //   * rename in open files
+      if (Rep.getFilePath() == File)
+        Replacements.push_back(Rep);
+    }
+  }
+  return Replacements;
+}
+
 std::string ClangdServer::getDocument(PathRef File) {
   auto draft = DraftMgr.getDraft(File);
   assert(draft.Draft && "File is not tracked, cannot get contents");
   return *draft.Draft;
 }
 
 std::string ClangdServer::dumpAST(PathRef File) {
   std::shared_ptr<CppFile> Resources = Units.getFile(File);

clangd/ClangdUnit.h

 SignatureHelp signatureHelp(PathRef FileName,
                             const tooling::CompileCommand &Command,
                             PrecompiledPreamble const *Preamble,
                             StringRef Contents, Position Pos,
                             IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                             std::shared_ptr<PCHContainerOperations> PCHs,
                             clangd::Logger &Logger);
 
+/// Get the beginning SourceLocation at a specified \p Pos.
+SourceLocation getBeginningOfIdentifier(ParsedAST &Unit, const Position &Pos,
+                                        const FileEntry *FE);
+
 /// Get definition of symbol at a specified \p Pos.
 std::vector<Location> findDefinitions(ParsedAST &AST, Position Pos,
                                       clangd::Logger &Logger);
 
 /// For testing/debugging purposes. Note that this method deserializes all
 /// unserialized Decls, so use with care.
 void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS);
 
 } // namespace clangd
 } // namespace clang
 #endif

clangd/ClangdUnit.cpp

if (!Lexer::getRawToken(SearchedLocation, Result, AST.getSourceManager(),
           addDeclarationLocation(SourceRange(MacroInf->getDefinitionLoc(),
                                              MacroInf->getDefinitionEndLoc()));
         }
       }
     }
   }
 };
 
-SourceLocation getBeginningOfIdentifier(ParsedAST &Unit, const Position &Pos,
-                                        const FileEntry *FE) {
-  // The language server protocol uses zero-based line and column numbers.
-  // Clang uses one-based numbers.
-
-  const ASTContext &AST = Unit.getASTContext();
-  const SourceManager &SourceMgr = AST.getSourceManager();
-
-  SourceLocation InputLocation =
-      getMacroArgExpandedLocation(SourceMgr, FE, Pos);
-  if (Pos.character == 0) {
-    return InputLocation;
-  }
-
-  // This handle cases where the position is in the middle of a token or right
-  // after the end of a token. In theory we could just use GetBeginningOfToken
-  // to find the start of the token at the input position, but this doesn't
-  // work when right after the end, i.e. foo|.
-  // So try to go back by one and see if we're still inside the an identifier
-  // token. If so, Take the beginning of this token.
-  // (It should be the same identifier because you can't have two adjacent
-  // identifiers without another token in between.)
-  SourceLocation PeekBeforeLocation = getMacroArgExpandedLocation(
-      SourceMgr, FE, Position{Pos.line, Pos.character - 1});
-  Token Result;
-  if (Lexer::getRawToken(PeekBeforeLocation, Result, SourceMgr,
-                         AST.getLangOpts(), false)) {
-    // getRawToken failed, just use InputLocation.
-    return InputLocation;
-  }
-
-  if (Result.is(tok::raw_identifier)) {
-    return Lexer::GetBeginningOfToken(PeekBeforeLocation, SourceMgr,
-                                      AST.getLangOpts());
-  }
-
-  return InputLocation;
-}
 } // namespace
 
 std::vector<Location> clangd::findDefinitions(ParsedAST &AST, Position Pos,
                                               clangd::Logger &Logger) {
   const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
   const FileEntry *FE = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
   if (!FE)
     return {};
if (File.RebuildCounter == RequestRebuildCounter) {
     // Our rebuild request was cancelled, because further reparse was requested.
     assert(!futureIsReady(File.ASTFuture));
     assert(!futureIsReady(File.PreambleFuture));
   }
 
   Lock.unlock();
   File.RebuildCond.notify_all();
 }
+
+SourceLocation clangd::getBeginningOfIdentifier(ParsedAST &Unit,
+                                                const Position &Pos,
+                                                const FileEntry *FE) {
+  // The language server protocol uses zero-based line and column numbers.
+  // Clang uses one-based numbers.
+
+  const ASTContext &AST = Unit.getASTContext();
+  const SourceManager &SourceMgr = AST.getSourceManager();
+
+  SourceLocation InputLocation =
+      getMacroArgExpandedLocation(SourceMgr, FE, Pos);
+  if (Pos.character == 0) {
+    return InputLocation;
+  }
+
+  // This handle cases where the position is in the middle of a token or right
+  // after the end of a token. In theory we could just use GetBeginningOfToken
+  // to find the start of the token at the input position, but this doesn't
+  // work when right after the end, i.e. foo|.
+  // So try to go back by one and see if we're still inside the an identifier
+  // token. If so, Take the beginning of this token.
+  // (It should be the same identifier because you can't have two adjacent
+  // identifiers without another token in between.)
+  SourceLocation PeekBeforeLocation = getMacroArgExpandedLocation(
+      SourceMgr, FE, Position{Pos.line, Pos.character - 1});
+  Token Result;
+  if (Lexer::getRawToken(PeekBeforeLocation, Result, SourceMgr,
+                         AST.getLangOpts(), false)) {
+    // getRawToken failed, just use InputLocation.
+    return InputLocation;
+  }
+
+  if (Result.is(tok::raw_identifier)) {
+    return Lexer::GetBeginningOfToken(PeekBeforeLocation, SourceMgr,
+                                      AST.getLangOpts());
+  }
+
+  return InputLocation;
+}

clangd/Protocol.h

struct SignatureHelp {
   int activeSignature = 0;
 
   /// The active parameter of the active signature.
   int activeParameter = 0;
 
   static json::Expr unparse(const SignatureHelp &);
 };
 
+struct RenameParams {
+  /// The document that was opened.
+  TextDocumentIdentifier textDocument;
+
+  /// The position at which this request was sent.
+  Position position;
+
+  /// The new name of the symbol.
+  std::string newName;
+
+  static llvm::Optional<RenameParams> parse(llvm::yaml::MappingNode *Params,
+                                            clangd::Logger &Logger);
+};
+
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/Protocol.cpp

json::Expr SignatureHelp::unparse(const SignatureHelp &SH) {
   assert(SH.activeParameter >= 0 &&
          "Unexpected negative value for active parameter index");
   return json::obj{
       {"activeSignature", SH.activeSignature},
       {"activeParameter", SH.activeParameter},
       {"signatures", json::ary(SH.signatures)},
   };
 }
+
+llvm::Optional<RenameParams>
+RenameParams::parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger) {
+  RenameParams Result;
+  for (auto &NextKeyValue : *Params) {
+    auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
+    if (!KeyString)
+      return llvm::None;
+
+    llvm::SmallString<10> KeyStorage;
+    StringRef KeyValue = KeyString->getValue(KeyStorage);
+
+    if (KeyValue == "textDocument") {
+      auto *Value =
+        dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
+      if (!Value)
+        continue;
+      auto *Map = dyn_cast<llvm::yaml::MappingNode>(Value);
+      if (!Map)
+        return llvm::None;
+      auto Parsed = TextDocumentIdentifier::parse(Map, Logger);
+      if (!Parsed)
+        return llvm::None;
+      Result.textDocument = std::move(*Parsed);
+    } else if (KeyValue == "position") {
+      auto *Value =
+          dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
+      if (!Value)
+        continue;
+      auto Parsed = Position::parse(Value, Logger);
+      if (!Parsed)
+        return llvm::None;
+      Result.position = std::move(*Parsed);
+    } else if (KeyValue == "newName") {
+      auto *Value = NextKeyValue.getValue();
+      if (!Value)
+        continue;
+      auto *Node = dyn_cast<llvm::yaml::ScalarNode>(Value);
+      if (!Node)
+        return llvm::None;
+      llvm::SmallString<10> Storage;
+      Result.newName = Node->getValue(Storage);
+    } else {
+      logIgnoredField(KeyValue, Logger);
+    }
+  }
+  return Result;
+}

clangd/ProtocolHandlers.h

public:
   onDocumentRangeFormatting(Ctx C, DocumentRangeFormattingParams &Params) = 0;
   virtual void onCodeAction(Ctx C, CodeActionParams &Params) = 0;
   virtual void onCompletion(Ctx C, TextDocumentPositionParams &Params) = 0;
   virtual void onSignatureHelp(Ctx C, TextDocumentPositionParams &Params) = 0;
   virtual void onGoToDefinition(Ctx C, TextDocumentPositionParams &Params) = 0;
   virtual void onSwitchSourceHeader(Ctx C, TextDocumentIdentifier &Params) = 0;
   virtual void onFileEvent(Ctx C, DidChangeWatchedFilesParams &Params) = 0;
   virtual void onCommand(Ctx C, ExecuteCommandParams &Params) = 0;
+  virtual void onRename(Ctx C, RenameParams &Parames) = 0;
 };
 
 void registerCallbackHandlers(JSONRPCDispatcher &Dispatcher, JSONOutput &Out,
                               ProtocolCallbacks &Callbacks);
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/ProtocolHandlers.cpp

Register("textDocument/onTypeFormatting",
            &ProtocolCallbacks::onDocumentOnTypeFormatting);
   Register("textDocument/formatting", &ProtocolCallbacks::onDocumentFormatting);
   Register("textDocument/codeAction", &ProtocolCallbacks::onCodeAction);
   Register("textDocument/completion", &ProtocolCallbacks::onCompletion);
   Register("textDocument/signatureHelp", &ProtocolCallbacks::onSignatureHelp);
   Register("textDocument/definition", &ProtocolCallbacks::onGoToDefinition);
   Register("textDocument/switchSourceHeader",
            &ProtocolCallbacks::onSwitchSourceHeader);
+  Register("textDocument/rename", &ProtocolCallbacks::onRename);
   Register("workspace/didChangeWatchedFiles", &ProtocolCallbacks::onFileEvent);
   Register("workspace/executeCommand", &ProtocolCallbacks::onCommand);
 }

test/clangd/initialize-params-invalid.test

 # CHECK-NEXT:      "moreTriggerCharacter": []
 # CHECK-NEXT:    },
 # CHECK-NEXT:    "documentRangeFormattingProvider": true,
 # CHECK-NEXT:    "executeCommandProvider": {
 # CHECK-NEXT:      "commands": [
 # CHECK-NEXT:        "clangd.applyFix"
 # CHECK-NEXT:      ]
 # CHECK-NEXT:    },
+# CHECK-NEXT:    "renameProvider": true,
 # CHECK-NEXT:    "signatureHelpProvider": {
 # CHECK-NEXT:      "triggerCharacters": [
 # CHECK-NEXT:        "(",
 # CHECK-NEXT:        ","
 # CHECK-NEXT:      ]
 # CHECK-NEXT:    },
 # CHECK-NEXT:    "textDocumentSync": 1
 # CHECK-NEXT:  }
 Content-Length: 44
 
 {"jsonrpc":"2.0","id":3,"method":"shutdown"}
 Content-Length: 33
 
 {"jsonrpc":"2.0":"method":"exit"}

test/clangd/initialize-params.test

 # CHECK-NEXT:      "moreTriggerCharacter": []
 # CHECK-NEXT:    },
 # CHECK-NEXT:    "documentRangeFormattingProvider": true,
 # CHECK-NEXT:    "executeCommandProvider": {
 # CHECK-NEXT:      "commands": [
 # CHECK-NEXT:        "clangd.applyFix"
 # CHECK-NEXT:      ]
 # CHECK-NEXT:    },
+# CHECK-NEXT:   "renameProvider": true,
 # CHECK-NEXT:    "signatureHelpProvider": {
 # CHECK-NEXT:      "triggerCharacters": [
 # CHECK-NEXT:        "(",
 # CHECK-NEXT:        ","
 # CHECK-NEXT:      ]
 # CHECK-NEXT:    },
 # CHECK-NEXT:    "textDocumentSync": 1
 # CHECK-NEXT:  }

test/clangd/rename.test

+# RUN: clangd -pretty -run-synchronously < %s | FileCheck -strict-whitespace %s
+# It is absolutely vital that this file has CRLF line endings.
+#
+Content-Length: 125
+
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
+
+Content-Length: 150
+
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///foo.cpp","languageId":"cpp","version":1,"text":"int foo;"}}}
+
+Content-Length: 159
+
+{"jsonrpc":"2.0","id":1,"method":"textDocument/rename","params":{"textDocument":{"uri":"file:///foo.cpp"},"position":{"line":0,"character":5},"newName":"bar"}}
+#      CHECK:  "id": 1,
+# CHECK-NEXT:  "jsonrpc": "2.0",
+# CHECK-NEXT:  "result": {
+# CHECK-NEXT:    "changes": {
+# CHECK-NEXT:      "file:///foo.cpp": [
+# CHECK-NEXT:        {
+# CHECK-NEXT:          "newText": "bar",
+# CHECK-NEXT:          "range": {
+# CHECK-NEXT:            "end": {
+# CHECK-NEXT:              "character": 7
+# CHECK-NEXT:              "line": 0
+# CHECK-NEXT:            },
+# CHECK-NEXT:            "start": {
+# CHECK-NEXT:              "character": 4
+# CHECK-NEXT:              "line": 0
+# CHECK-NEXT:            }
+# CHECK-NEXT:          }
+# CHECK-NEXT:        }
+# CHECK-NEXT:      ]
+# CHECK-NEXT:    }
+# CHECK-NEXT:  }
+Content-Length: 159
+
+{"jsonrpc":"2.0","id":2,"method":"textDocument/rename","params":{"textDocument":{"uri":"file:///foo.cpp"},"position":{"line":0,"character":2},"newName":"bar"}}
+#      CHECK:  "error": {
+# CHECK-NEXT:    "code": -32603,
+# CHECK-NEXT:    "message": "clang diagnostic"
+# CHECK-NEXT:  },
+# CHECK-NEXT:  "id": 2,
+# CHECK-NEXT:  "jsonrpc": "2.0"
+Content-Length: 44
+
+{"jsonrpc":"2.0","id":3,"method":"shutdown"}
+Content-Length: 33
+
+{"jsonrpc":"2.0":"method":"exit"}