[clangd][WIP] Integrate the refactoring actions into clangd

[arphaman]

Summary

This WIP patch provides a sample implementation of an integration of Clang's refactoring actions from libToolingRefactor into clangd.

In terms of protocol support, the patch adds:

• Support for the Command & CommandArgument structures.
• Support for the workspace/executeCommand command.

Note that the rename is not supported as an editor command since LSP has another entry in the protocol for it.

The integration with the refactoring library is done through the RefactoringEditorClient class that's implemented in a parent revision. Right now the test checks that the initial version of the "extract function" refactoring can be performed.

[arphaman]

I think that the clangd editor plugin will have to be modified as well, but I haven't looked into that yet.

[ilya-biryukov]

clangd/ClangdServer.cpp

500

Maybe initialize RefactoringClient in constructor?

514

s/getCommands//

526

NIT: remove empty line.

clangd/Protocol.cpp

992

Maybe use llvm::Optional<CommandArgument> instead of CommandArgument?
If the loop body below won't get executed (i.e., Params is empty), we'll be returning uninitialized local variable.

clangd/Protocol.h

540

Could we make ArgumentKind, union members and default constructor private (makeDocumentID , makeSelectionRange and unparse would be the only way to construct CommandArgument)?

This would give an interface that's much harder to misuse.

[sammccall]

As noted on the other patch, I'm not sure EditorCommands is a useful abstraction.

This shows up one of the problems: clangd is mostly decoupled from the actual behavior/semantics of the commands by the EditorCommands abstraction. However LSP doesn't say what the structure of ExecuteCommandParams.arguments is - it depends on the individual command. But clangd needs to parse those arguments out of the JSON! So we're left with all the EditorCommands needing to take the same set of arguments, which then get hardcoded in clangd.

Coupling clangd more closely to the refactorings seems simpler and more flexible - what would we be losing?

Other than the EditorCommands question, implementation looks fine!

clangd/Protocol.h

535

Why a union-of-unions instead of AlignedCharArrayUnion<Range, TextDocumentIdentifier>?

[ilya-biryukov]

There's another patch (D39276) that tries to add workspace/executeCommand for a slightly different use-case.
Could we take the code for parsing/handling workspace/executeCommand from this patch and extract it into a separate change so that these two patches can be reviewed independently?
I expect that the only addition the other patch needs (D39276) is to add a new kind of CommandArgument.

[sammccall]

In D39057#906297, @ilya-biryukov wrote:

There's another patch (D39276) that tries to add workspace/executeCommand for a slightly different use-case.
Could we take the code for parsing/handling workspace/executeCommand from this patch and extract it into a separate change so that these two patches can be reviewed independently?

@arphaman unless you're far down this path already, I'd actually prefer we land that patch soon and merge this one into it:

• It's got a pretty narrow scope (1 command, not much logic), and will be ready soon. It's almost actually the isolated patch that @ilya-biryukov describes. This patch is both more general in scope and is stacked on top of other nontrivial changes, so will probably take longer.
• It makes a couple of different decisions that I think would aid the design here, will leave detailed comments.

But if people prefer, we can certainly tackle command parsing separately.

clangd/Protocol.cpp

990

Here we're trying to parse the args independent of what the command is. I'm not sure this is a path we want to go down:

• there's no guarantee that args are even Objects, for a start!
• we're detecting the type based on field names "range" and "doc", which don't seem that unlikely to be used in different ways by different commands. In that case, we've painted ourselves into a corner.
• I'm uncomfortable with the idea that if we encounter an unknown command with unknown args, we're going to throw them at "parse" anyway and... probably get None back? (I'd hope our parsers don't crash, but d0k's fuzzing shows otherwise I think)

If we parse the arg list with some small per-command logic, we can still easily share the code that handles common arg types like a selection.

clangd/Protocol.h

533

vector<union> is a good literal translation of any[], but it's not that convenient for the code that's consuming these args, nor is it convenient to implement (basically because LLVM lacks a good variant, I think).

D39276 hints at a different approach that I think is worth a look: basically we try to fit the args into a set of typed "slots" which are just Optional<T> fields on EditorCommand. For each command, we can decide how to parse the args into these slots, and which slots we're going to look at. We can share slots for common attributes (selection), but some of them will probably be specialized. (If size is a concern, we can use unique_ptr instead of Optional).

This does mean making some assumptions (relative order of different args isn't significant, have to choose between "single" and "list" for each slot) but they seem pretty safe/flexible.

[arphaman]

In D39057#907820, @sammccall wrote:

In D39057#906297, @ilya-biryukov wrote:

There's another patch (D39276) that tries to add workspace/executeCommand for a slightly different use-case.
Could we take the code for parsing/handling workspace/executeCommand from this patch and extract it into a separate change so that these two patches can be reviewed independently?

@arphaman unless you're far down this path already, I'd actually prefer we land that patch soon and merge this one into it:

• It's got a pretty narrow scope (1 command, not much logic), and will be ready soon. It's almost actually the isolated patch that @ilya-biryukov describes. This patch is both more general in scope and is stacked on top of other nontrivial changes, so will probably take longer.
• It makes a couple of different decisions that I think would aid the design here, will leave detailed comments.

But if people prefer, we can certainly tackle command parsing separately.

Ok, I will wait until that patch lands.

clangd/CMakeLists.txt

add_clang_library(clangDaemon
   clangFormat
   clangFrontend
   clangIndex
   clangLex
   clangSema
   clangSerialization
   clangTooling
   clangToolingCore
+  clangToolingRefactor
   ${LLVM_PTHREAD_LIB}
   )
 
 add_subdirectory(tool)

clangd/ClangdLSPServer.h

onDocumentRangeFormatting(Ctx C,
                             DocumentRangeFormattingParams &Params) override;
   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 onWorkspaceExecuteCommand(Ctx C, ExecuteCommandParams &Params) override;
 
   std::vector<clang::tooling::Replacement>
   getFixIts(StringRef File, const clangd::Diagnostic &D);
 
   /// Function that will be called on a separate thread when diagnostics are
   /// ready. Sends the Dianostics to LSP client via Out.writeMessage and caches
   /// corresponding fixits in the FixItsMap.
   void consumeDiagnostics(PathRef File,

clangd/ClangdLSPServer.cpp

for (Diagnostic &D : Params.context.diagnostics) {
     if (!Edits.empty())
       Commands +=
           R"({"title":"Apply FixIt ')" + llvm::yaml::escape(D.message) +
           R"('", "command": "clangd.applyFix", "arguments": [")" +
           llvm::yaml::escape(Params.textDocument.uri.uri) +
           R"(", [)" + Edits +
           R"(]]},)";
   }
+  std::vector<Command> EditorCommands =
+      Server.getCommands(Params.textDocument.uri.file, Params.range);
+  for (const auto &Command : EditorCommands) {
+    Commands +=
+        R"({"title":")" + Command.title + R"(", "command": "clangd.)" +
+        Command.command + R"(", "arguments": [)";
+    Commands += CommandArgument::unparse(
+        CommandArgument::makeDocumentID(Params.textDocument));
+    Commands += ",";
+    for (const auto &Arg : Command.arguments) {
+      Commands += CommandArgument::unparse(Arg);
+      Commands += ", ";
+    }
+    Commands += R"(]},)";
+  }
   if (!Commands.empty())
     Commands.pop_back();
   C.reply("[" + Commands + "]");
 }
 
 void ClangdLSPServer::onCompletion(Ctx C, TextDocumentPositionParams &Params) {
   auto Items = Server
                    .codeComplete(Params.textDocument.uri.file,

 
 void ClangdLSPServer::onSwitchSourceHeader(Ctx C,
                                            TextDocumentIdentifier &Params) {
   llvm::Optional<Path> Result = Server.switchSourceHeader(Params.uri.file);
   std::string ResultUri;
   C.reply(Result ? URI::unparse(URI::fromFile(*Result)) : R"("")");
 }
 
+void ClangdLSPServer::onWorkspaceExecuteCommand(Ctx C,
+                                                ExecuteCommandParams &Params) {
+  Optional<Range> SelectionRange;
+  Optional<TextDocumentIdentifier> DocID;
+  for (const auto &Arg : Params.arguments) {
+    switch (Arg.ArgumentKind) {
+    case CommandArgument::SelectionRangeKind:
+      SelectionRange = Arg.getSelectionRange();
+      break;
+    case CommandArgument::TextDocumentIdentifierKind:
+      DocID = Arg.getDocumentID();
+      break;
+    }
+  }
+  if (!SelectionRange || !DocID)
+    return;
+  std::string Code = Server.getDocument(DocID->uri.file);
+  std::string Edits = replacementsToEdits(
+      Code,
+      Server.executeCommand(Params.command, DocID->uri.file, *SelectionRange));
+  C.reply("[" + Edits + "]");
+}
+
 ClangdLSPServer::ClangdLSPServer(JSONOutput &Out, unsigned AsyncThreadsCount,
                                  bool SnippetCompletions,
                                  llvm::Optional<StringRef> ResourceDir,
                                  llvm::Optional<Path> CompileCommandsDir)
     : Out(Out), CDB(/*Logger=*/Out, std::move(CompileCommandsDir)),
       Server(CDB, /*DiagConsumer=*/*this, FSProvider, AsyncThreadsCount,
              SnippetCompletions, /*Logger=*/Out, ResourceDir) {}
 

clangd/ClangdServer.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
 
 #include "ClangdUnitStore.h"
 #include "DraftStore.h"
 #include "GlobalCompilationDatabase.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/Core/Replacement.h"
+#include "clang/Tooling/Refactoring/EditorClient.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 
 #include "ClangdUnit.h"
 #include "Function.h"
 #include "Protocol.h"
 
 #include <condition_variable>
 #include <functional>
 #include <mutex>
 #include <string>
 #include <thread>
 #include <type_traits>
 #include <utility>
 
 namespace clang {
 class PCHContainerOperations;
 
+namespace tooling {
+class RefactoringEditorClient;
+}
+
 namespace clangd {
 
 class Logger;
 
 /// Turn a [line, column] pair into an offset in Code.
 size_t positionToOffset(StringRef Code, Position P);
 
 /// Turn an offset in Code into a [line, column] pair.
public:
 
   /// Only for testing purposes.
   /// Waits until all requests to worker thread are finished and dumps AST for
   /// \p File. \p File must be in the list of added documents.
   std::string dumpAST(PathRef File);
   /// Called when an event occurs for a watched file in the workspace.
   void onFileEvent(const DidChangeWatchedFilesParams &Params);
 
+  /// Returns the list of available commands that can be performed in a file.
+  std::vector<Command> getCommands(PathRef File, Range SelectionRange);
+
+  /// Execute an editor command in the specified file and the range.
+  std::vector<tooling::Replacement>
+  executeCommand(StringRef CommandName, PathRef File, Range SelectionRange);
+
 private:
   std::future<void>
   scheduleReparseAndDiags(PathRef File, VersionedDraft Contents,
                           std::shared_ptr<CppFile> Resources,
                           Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> TaggedFS);
 
   std::future<void> scheduleCancelRebuild(std::shared_ptr<CppFile> Resources);
 
private:
   /// into CppFile.
   std::mutex DiagnosticsMutex;
   /// Maps from a filename to the latest version of reported diagnostics.
   llvm::StringMap<DocVersion> ReportedDiagnosticVersions;
   // WorkScheduler has to be the last member, because its destructor has to be
   // called before all other members to stop the worker thread that references
   // ClangdServer
   ClangdScheduler WorkScheduler;
+  /// The editor client that allows Clangd to use Clang's refactoring actions.
+  std::unique_ptr<tooling::RefactoringEditorClient> RefactoringClient;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/ClangdServer.cpp

WorkScheduler.addToFront(std::move(CancelReparses), std::move(DonePromise),
                            std::move(DeferredCancel));
   return DoneFuture;
 }
 
 void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
   // FIXME: Do nothing for now. This will be used for indexing and potentially
   // invalidating other caches.
 }
+
+std::vector<Command> ClangdServer::getCommands(PathRef File,
+                                               Range SelectionRange) {
+  auto FileContents = DraftMgr.getDraft(File);
+  assert(FileContents.Draft && "getCommands is called for non-added document");
+  std::shared_ptr<CppFile> Resources = Units.getFile(File);
+  assert(Resources && "Calling getCommands on non-added file");
+
+  std::vector<Command> Results;
+  Resources->getAST().get()->runUnderLock([SelectionRange, &Results,
+                                           this](ParsedAST *AST) {
+    if (!AST)
+      return;
+    if (!RefactoringClient)
+      RefactoringClient = llvm::make_unique<tooling::RefactoringEditorClient>();
+    Results = clangd::findAvailableRefactoringCommands(*RefactoringClient, *AST,
+                                                       SelectionRange, Logger);
+  });
+  return Results;
+}
+
+std::vector<tooling::Replacement>
+ClangdServer::executeCommand(StringRef CommandName, PathRef File,
+                             Range SelectionRange) {
+  auto FileContents = DraftMgr.getDraft(File);
+  assert(FileContents.Draft &&
+         "executeCommand is called for non-added document");
+  std::shared_ptr<CppFile> Resources = Units.getFile(File);
+  assert(Resources && "executeCommand getCommands on non-added file");
+
+  std::vector<tooling::Replacement> Results;
+  Resources->getAST().get()->runUnderLock([SelectionRange, CommandName,
+                                           &Results, this](ParsedAST *AST) {
+    if (!AST)
+      return;
+    assert(RefactoringClient && "no ref client?");
+    if (!RefactoringClient)
+      RefactoringClient = llvm::make_unique<tooling::RefactoringEditorClient>();
+    Results =
+        clangd::performRefactoringCommand(*RefactoringClient, CommandName, *AST,
+
+                                          SelectionRange, Logger);
+  });
+  return Results;
+}

clangd/ClangdUnit.h

 #include "Function.h"
 #include "Path.h"
 #include "Protocol.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/PrecompiledPreamble.h"
 #include "clang/Serialization/ASTBitCodes.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/Core/Replacement.h"
+#include "clang/Tooling/Refactoring/AtomicChange.h"
 #include <atomic>
 #include <future>
 #include <memory>
 #include <mutex>
 
 namespace llvm {
 class raw_ostream;
 }
 
 namespace clang {
 class PCHContainerOperations;
 
 namespace vfs {
 class FileSystem;
 }
 
 namespace tooling {
 struct CompileCommand;
+class RefactoringEditorClient;
 }
 
 namespace clangd {
 
 class Logger;
 
 /// A diagnostic with its FixIts.
 struct DiagWithFixIts {

 /// 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);
 
+/// Get the list of available refactoring actions for the given range \p
+/// SelectionRange.
+std::vector<Command>
+findAvailableRefactoringCommands(tooling::RefactoringEditorClient &Client,
+                                 ParsedAST &AST, Range SelectionRange,
+                                 clangd::Logger &Logger);
+
+/// Performs the specified refactoring command and returns the source changes.
+std::vector<tooling::Replacement>
+performRefactoringCommand(tooling::RefactoringEditorClient &Client,
+                          StringRef CommandName, ParsedAST &AST,
+                          Range SelectionRange, clangd::Logger &Logger);
+
 } // namespace clangd
 } // namespace clang
 #endif

clangd/ClangdUnit.cpp

 #include "clang/Index/IndexingAction.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Serialization/ASTWriter.h"
 #include "clang/Tooling/CompilationDatabase.h"
+#include "clang/Tooling/Refactoring/EditorClient.h"
+#include "clang/Tooling/Refactoring/EditorCommands.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Format.h"
 
 #include <algorithm>
 #include <chrono>
 
std::vector<Location> clangd::findDefinitions(ParsedAST &AST, Position Pos,
   IndexOpts.IndexFunctionLocals = true;
 
   indexTopLevelDecls(AST.getASTContext(), AST.getTopLevelDecls(),
                      DeclLocationsFinder, IndexOpts);
 
   return DeclLocationsFinder->takeLocations();
 }
 
+std::vector<Command> clangd::findAvailableRefactoringCommands(
+    tooling::RefactoringEditorClient &Client, ParsedAST &AST,
+    Range SelectionRange, clangd::Logger &Logger) {
+  const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
+  const FileEntry *FE = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
+  if (!FE)
+    return {};
+  SourceLocation Begin =
+      getMacroArgExpandedLocation(SourceMgr, FE, SelectionRange.start);
+  SourceLocation End =
+      getMacroArgExpandedLocation(SourceMgr, FE, SelectionRange.end);
+  std::vector<const tooling::EditorCommand *> EditorCommands =
+      Client.getAvailableRefactorings(AST.getASTContext(),
+                                      SourceRange(Begin, End));
+  std::vector<Command> Results;
+  for (const tooling::EditorCommand *Cmd : EditorCommands) {
+    Command Result;
+    Result.title = Cmd->getTitle();
+    Result.command = (llvm::Twine("refactor.") + Cmd->getName()).str();
+    Result.arguments = {CommandArgument::makeSelectionRange(SelectionRange)};
+    Results.push_back(std::move(Result));
+  }
+  return Results;
+}
+
+std::vector<tooling::Replacement> clangd::performRefactoringCommand(
+    tooling::RefactoringEditorClient &Client, StringRef CommandName,
+    ParsedAST &AST, Range SelectionRange, clangd::Logger &Logger) {
+  const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
+  const FileEntry *FE = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
+  if (!FE)
+    return {};
+  SourceLocation Begin =
+      getMacroArgExpandedLocation(SourceMgr, FE, SelectionRange.start);
+  SourceLocation End =
+      getMacroArgExpandedLocation(SourceMgr, FE, SelectionRange.end);
+  Expected<tooling::AtomicChanges> Changes = Client.performRefactoring(
+      AST.getASTContext(), CommandName.drop_front(strlen("clangd.refactor.")),
+      SourceRange(Begin, End));
+  if (!Changes) {
+    // FIXME: Propage the errors to the user.
+    llvm::consumeError(Changes.takeError());
+    return {};
+  }
+  std::vector<tooling::Replacement> Replacements;
+  for (const tooling::AtomicChange &Change : *Changes) {
+    tooling::Replacements ChangeReps = Change.getReplacements();
+    for (const auto &Rep : ChangeReps)
+      Replacements.push_back(Rep);
+  }
+  return Replacements;
+}
+
 void ParsedAST::ensurePreambleDeclsDeserialized() {
   if (PendingTopLevelDecls.empty())
     return;
 
   std::vector<const Decl *> Resolved;
   Resolved.reserve(PendingTopLevelDecls.size());
 
   ExternalASTSource &Source = *getASTContext().getExternalSource();

clangd/Protocol.h

struct SignatureHelp {
   int activeSignature = 0;
 
   /// The active parameter of the active signature.
   int activeParameter = 0;
 
   static std::string unparse(const SignatureHelp &);
 };
 
+/// Represents an editor command argument.
+struct CommandArgument {
+  union {
+    llvm::AlignedCharArrayUnion<Range> SelectionRange;
+    llvm::AlignedCharArrayUnion<TextDocumentIdentifier> DocumentID;
+  };
+  enum Kind { SelectionRangeKind, TextDocumentIdentifierKind };
+  Kind ArgumentKind;
+
+  CommandArgument() {}
+
+  static CommandArgument makeSelectionRange(Range R) {
+    CommandArgument Result;
+    *reinterpret_cast<Range *>(Result.SelectionRange.buffer) = R;
+    Result.ArgumentKind = SelectionRangeKind;
+    return Result;
+  }
+
+  const Range &getSelectionRange() const {
+    assert(ArgumentKind == SelectionRangeKind);
+    return *reinterpret_cast<const Range *>(SelectionRange.buffer);
+  }
+
+  static CommandArgument makeDocumentID(TextDocumentIdentifier ID) {
+    CommandArgument Result;
+    *reinterpret_cast<TextDocumentIdentifier *>(Result.DocumentID.buffer) = ID;
+    Result.ArgumentKind = TextDocumentIdentifierKind;
+    return Result;
+  }
+
+  const TextDocumentIdentifier &getDocumentID() const {
+    assert(ArgumentKind == TextDocumentIdentifierKind);
+    return *reinterpret_cast<const TextDocumentIdentifier *>(DocumentID.buffer);
+  }
+
+  static std::string unparse(const CommandArgument &);
+
+  static llvm::Optional<CommandArgument> parse(llvm::yaml::MappingNode *Params,
+                                               clangd::Logger &Logger);
+};
+
+/// Represents an editor command.
+struct Command {
+  /// The title of the command.
+  std::string title;
+
+  /// The identifier of the actual command handler.
+  std::string command;
+
+  /// The arguments that the command handler should be invoked with.
+  std::vector<CommandArgument> arguments;
+};
+
+/// Represents an editor command execution request.
+struct ExecuteCommandParams {
+  /// The identifier of the actual command handler.
+  std::string command;
+
+  /// Arguments that the command handler should be invoked with.
+  /// Not currently used by clangd.
+  std::vector<CommandArgument> arguments;
+
+  static llvm::Optional<ExecuteCommandParams>
+  parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger);
+};
+
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/Protocol.cpp

std::string SignatureHelp::unparse(const SignatureHelp &SH) {
   Os.flush();
   if (SH.signatures.empty())
     Result.push_back(']');
   else
     Result.back() = ']'; // Replace the last `,` with an `]`.
   Result.push_back('}');
   return Result;
 }
+
+std::string CommandArgument::unparse(const CommandArgument &Argument) {
+  switch (Argument.ArgumentKind) {
+  case SelectionRangeKind:
+    return std::string("{\"selection\":") +
+           Range::unparse(Argument.getSelectionRange()) + "}";
+  case TextDocumentIdentifierKind:
+    return std::string("{\"doc\":{\"uri\":") +
+           URI::unparse(Argument.getDocumentID().uri) + "}}";
+  }
+  llvm_unreachable("invalid kind");
+}
+
+llvm::Optional<CommandArgument>
+CommandArgument::parse(llvm::yaml::MappingNode *Params,
+                       clangd::Logger &Logger) {
+  CommandArgument Result;
+  for (auto &NextKeyValue : *Params) {
+    auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
+    if (!KeyString)
+      return None;
+
+    llvm::SmallString<10> KeyStorage;
+    StringRef KeyValue = KeyString->getValue(KeyStorage);
+
+    if (KeyValue == "range") {
+      auto *Value =
+          dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
+      if (!Value)
+        return None;
+      Optional<Range> SelectionRange = Range::parse(Value, Logger);
+      if (!SelectionRange)
+        return None;
+      Result = makeSelectionRange(std::move(*SelectionRange));
+    } else if (KeyValue == "doc") {
+      auto *Value =
+          dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
+      if (!Value)
+        return None;
+      Optional<TextDocumentIdentifier> ID =
+          TextDocumentIdentifier::parse(Value, Logger);
+      if (!ID)
+        return None;
+      Result = makeDocumentID(std::move(*ID));
+    } else {
+      logIgnoredField(KeyValue, Logger);
+      return None;
+    }
+  }
+  return Result;
+}
+
+Optional<ExecuteCommandParams>
+ExecuteCommandParams::parse(llvm::yaml::MappingNode *Params, Logger &Logger) {
+  ExecuteCommandParams 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 == "command") {
+      auto *Value =
+          dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
+      if (!Value)
+        return None;
+      llvm::SmallString<20> ValueStorage;
+      Result.command = Value->getValue(ValueStorage).str();
+    } else if (KeyValue == "arguments") {
+      auto *Seq =
+          dyn_cast_or_null<llvm::yaml::SequenceNode>(NextKeyValue.getValue());
+      if (!Seq)
+        return None;
+      std::vector<CommandArgument> Arguments;
+      for (auto &Item : *Seq) {
+        auto *Node = dyn_cast<llvm::yaml::MappingNode>(&Item);
+        if (!Node)
+          return None;
+        Optional<CommandArgument> Argument =
+            CommandArgument::parse(Node, Logger);
+        if (!Argument)
+          return None;
+        Arguments.push_back(std::move(*Argument));
+      }
+      Result.arguments = std::move(Arguments);
+    } else {
+      logIgnoredField(KeyValue, Logger);
+    }
+  }
+  return Result;
+}

clangd/ProtocolHandlers.h

public:
   virtual void
   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 onWorkspaceExecuteCommand(Ctx C,
+                                         ExecuteCommandParams &Params) = 0;
 };
 
 void registerCallbackHandlers(JSONRPCDispatcher &Dispatcher, JSONOutput &Out,
                               ProtocolCallbacks &Callbacks);
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/ProtocolHandlers.cpp

void clangd::registerCallbackHandlers(JSONRPCDispatcher &Dispatcher,
   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("workspace/didChangeWatchedFiles", &ProtocolCallbacks::onFileEvent);
+  Register("workspace/executeCommand",
+           &ProtocolCallbacks::onWorkspaceExecuteCommand);
 }

test/clangd/refactoring.test

+# RUN: clangd -run-synchronously < %s | FileCheck %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: 181
+
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///foo.c","languageId":"c","version":1,"text":"int main(int i, char **a) { if (i == 2) {}}"}}}
+#
+# CHECK: {"jsonrpc":"2.0","method":"textDocument/publishDiagnostics","params":{"uri":"file:///foo.c","diagnostics":[]}}
+#
+Content-Length: 214
+
+{"jsonrpc":"2.0","id":2,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///foo.c"},"range":{"start":{"line":0,"character":32},"end":{"line":0,"character":38}},"context":{"diagnostics":[]}}}
+#
+# CHECK: {"jsonrpc":"2.0","id":2,"result":[{"title":"Extract Function", "command": "clangd.refactor.ExtractFunction", "arguments": [{"doc":{"uri":"file:///foo.c"}},{"selection":{"start": {"line": 0, "character": 32}, "end": {"line": 0, "character": 38}}}, ]}]}
+#
+Content-Length: 243
+
+{"jsonrpc":"2.0","id":2,"method":"workspace/executeCommand","params":{"command":"clangd.refactor.ExtractFunction","arguments": [{"doc":{"uri":"file:///foo.c"}}, {"range":{"start":{"line":0,"character":32},"end":{"line":0,"character":38}}}]}}
+#
+# CHECK: {"jsonrpc":"2.0","id":2,"result":[{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 0}}, "newText": "static int extracted() {\nreturn i == 2;\n}\n\n"},{"range": {"start": {"line": 0, "character": 32}, "end": {"line": 0, "character": 38}}, "newText": "extracted()"}]}
+#
+Content-Length: 44
+
+{"jsonrpc":"2.0","id":3,"method":"shutdown"}