[clangd] Handle clangd.applyFix server-side

[malaperle]

Summary

When the user selects a fix-it (or any code action with commands), it is
possible to let the client forward the selected command to the server.
When the clangd.applyFix command is handled on the server, it can send a
workspace/applyEdit request to the client. This has the advantage that
the client doesn't explicitly have to know how to handle
clangd.applyFix. Therefore, the code to handle clangd.applyFix in the VS
Code extension (and any other Clangd client) is not required anymore.

[ilya-biryukov]

This patch intersects with D39057. (Specifically, LSP-specific parts related to executeCommand handling and argument parsing).
An approach taken in D39057 is somewhat more generic, allowing custom refactoring action to be run using workspace/executeCommand.
It doesn't tackle the problem of running the applyFix on the server, though and CommandArgument parsing is different.

Let's start a discussion on how to properly implement (and share the LSP handling/parsing bits between those two patches) there.

[ilya-biryukov]

It's definitely nice to move this into clangd, rather than have every client implement it on their own.

clangd/Protocol.cpp

105

While the standard JSON allows doubles, it seems really weird that doubles end up being used here. It is also weird to simply truncate the number to the nearest int, I would much rather expect the LSP server to fail when it sees non-integer numbers at those points.

Can't we fix Eclipse to send ints and not doubles instead?

Just as a side-note. @sammccall is working on a proper JSON parser in D39180 and this code wouldn't be necessary when it's ready.

253

Why do we even process messages that we can't parse without errors?

We should return an error, rather than trying to silently do something unexpected (e.g. forget to apply one of the edits)

929

I'd argue the proper place to define a list of known commands is ClangdLSPServer.h, not Protocol.h.
Let's keep Protocol.h a place that handles parsing/handling of general LSP without clangd-specific parts.

@sammccall, @bkramer , what are your thoughts on this?

[malaperle]

clangd/Protocol.cpp

105

I can see if Eclipse needs to be fixes. It might take a lot of time though depending on whether it's deep into a third-party dependency and whether or not I can contribute a fix. But we'll see.

253

It was logging that it failed to parse a TextEdit, so it's not completely silent. I was trying to make it more lenient, but perhaps that's not necessary. I'll remove this.

929

I'm not sure what would be the best way to go about this. I need Protocol.cpp to know about the existence of the Clangd-specific command in order to parse (or fail to parse) the params.

[sammccall]

Cool!

I haven't reviewed the whole implementation (but I can if Ilya would like some help!)

And yeah, I'd like to have a JSON parser so some of this is less painful (and maybe prettyprint the lit-tests)

clangd/Protocol.cpp

105

As far as JSON is concerned, there's one number type: 4 and 4.0 are the same number. For us to care about how it's serialized on the wire is pretty bad layering violation.

Integers >53 bit are basically non-portable in JSON (called out in the RFC), so I think it's fine to *only* parse as double.

All that said, we can and should reject non-integer numbers (just as we can reject strings with 'Q' in them), so I'd add a check for that: double should be in range and int(D) == D, else return false.

106

casting double to int is UB if out-of-range, I think

253

+1, I like leniency in general, but it seems dangerous here: won't subsequent edits will be applied against the wrong text if we've dropped some edits?

929

Given the protocol says "any" here, I think our options are to *not* parse here (and just capture the JSON for later parsing), or to call ClangdLSPServer from here to do the parsing, or the approach given here.

Already this file de facto parses the subset of LSP that we actually support, so having it know enough about the extensions to parse them seems like the least-worst option to me.

[ilya-biryukov]

In D39276#906571, @sammccall wrote:

I haven't reviewed the whole implementation (but I can if Ilya would like some help!)

That would be very helpful, I'll be back on vacation tomorrow and won't be of much help reviewing this. Many thanks!

PS Before I go, wanted to advocate for extracting common parts of this change and D39057 (Command and workspace/executeAction handling) into a separate review. It would probably lead to a nicer history and more focused reviews. On the other hand, it may not be worth the hassle, of course, but I still wanted to mention this approach here.

clangd/Protocol.cpp

105

Well, forget what I said then. Given that JSON defines numbers as double, we're obliged to parse them correctly, even if I find the fact that Eclipse adds fractional part weird

+1 to @sammccall's comments on how we should properly parse numbers and do the range/integer checks.

929

Yeah, I also agree that putting various clangd-specific CommandArguments here is ok.

On the other hand, I think it's perfectly fine if code inside Protocol.cpp properly parses even commands without looking at its names and ClangdLSPServer will validate the commands later when processing the request. (Approach taken in D39057). That way we'd move the list of clangd-specific command names into ClangdLSPServer (or even into ClangdServer or refactorings engine for other commands)

[sammccall]

OK, a bunch more mostly-nit comments, but this looks pretty good to me.

I don't think we should wait on D39057:

• that's stacked on top of two other patches that have nontrivial work/review to go
• it takes a broader frameworky approach to editor commands, and its design will benefit from needing to deal with this case
• they overlap in arg parsing, where there are differences (whether to use a full discriminated union for args, and whether parsing depends on the command) I think this patch makes robust choices

But I'll post a comment on the other review, let's wait a day or two to land in case I'm wrong.

clangd/ClangdLSPServer.cpp

88

This could use a high-level comment describing the flow (either here or where the constant is defined, but I think here is better).
At first read, it was unclear why we're just echoing the edit back to the client. Then I saw the patch description which is really good :-)

Something like:
The flow for "apply-fix" :
1. We publish a diagnostic, including fixits
2. The user clicks on the diagnostic, the editor asks us for code actions
3. We send code actions, with the fixit embedded as context
4. The user selects the fixit, the editor asks us to apply it
5. We unwrap the changes and send them back to the editor
// 6. The editor applies the changes, and sends us a reply (but we ignore it)

92

"Fix applied" since we know what the command is!

Ultimately, I think a better thing to do here would be send the applyEdit, wait for the response, and then reply success/failure to the original RPC.
But we're not there yet in terms of infrastructure, and I'm not sure whether it's actually important. I think it's worth a comment though.

94

Rather than writing JSON here directly, could you add a method e.g. C.call (like C.reply)?

For now, it's fine just to note that results of calls can't be handled. In future we could do something like:

C.call("workspace/ApplyEdit", ApplyWorkspaceEditParams::unparse(ApplyEdit),
  [](Expected<ApplyEditResult> R) { ... });

and Call would associate the callback with the ID of the call so that we can actually handle the response.

102

nit: "Unsupported command" or similar would be more specific

clangd/Protocol.cpp

929

@ilya-biryukov: I'm not sure that approach is better.
LSP defines CommandArguments as any[], validity depends on the command name. D39057 pokes around at the argument and tries to guess what type it is, exploiting the fact that the two currently-supported arg types are easy to tell apart.

• that gets harder if for some reason we end up with two commands that have args {"foo": []} and {"foo": {}} (contrived example, but name conflicts aren't *that* unlikely)
• unsupported commands take totally different codepaths depending on the shape of their args

I like the approach from this patch better.

956

So there's some unfortunate duplication/logic spread here between validating the command name and switching on it to parse the args.

I think you could group the command validation and arg parsing more naturally like this:

parse() {
  function<bool(MappingNode*)> ArgParser == nullptr;
  foreach (params) {
     if ("command") {
        Result.command = value;
        if (value == APPLY_FIX) 
         ArgParser = [&](MappingNode*) {
            ...
          };
       else if // other cases
       else // fail: unknown command
     } else if ("arguments" && ArgParser != nullptr) {
        foreach (args) 
          if !ArgParser(arg) // fail: bad arg
     }
  }
  if (Result.command.empty)  // fail: no command
}

966

so uh, what if "arguments" appears before "command"? :-(

I don't have a good answer to this, it's one of the things I dislike about YAMLParser, and the same thing applies at the top level of our LSP parser. But leave a comment!

(If I manage to get a DOM-flavored JSON parser into LLVM, it will fix this!)

clangd/Protocol.h

387

can you just make changes a map<string, vector<TextEdit>>, and hide the parse/unparse for individual entries in the CC file?

401

I'd prefer to leave this out until it's used.

409

This doesn't directly mirror the structure of the protocol, I think it's the right option but it deserves a comment.

If I understand right, the protocol says this is any[], but in practice the order doesn't matter, there's going to be 0-1 param of each type, and there will likely be overlap between the types of params used by different commands.

The obvious alternative is to make this a discriminated union of the different commands, but this seems simpler to me.

412

nit: This is a bit too vague to explain much.
/// The command identifier, e.g. CLANGD_APPLY_FIX_COMMAND

415

nit: just workspaceEdit?

test/clangd/execute-command.test

2

So I don't say this often, but I'm not sure this testcase is that useful.

I don't think testing every way a message can be malformed scales well, particularly if it involves adding log messages to expose unexpected conditions.
The LSP-based lit tests tend to be pretty brittle and hard to read - having lots of negative tests multiplies this.

There are some more scalable ways we could address it:

• use a schema-driven parser that's tested (e.g. when I use protobufs I don't need to test with unknown fields). But LSP doesn't have a schema that's easily amenable to this.
• fuzzing: this is pretty nice to make sure we don't crash - bkramer is experimenting with this.
• write unit-tests: this only really scales to cases we know are interesting, but is still nicer than lit tests as it can be more targeted and doesn't require logspam. A JSON lib would make this much more feasible I think.

We're not really in a position to do any of those in this patch though - honestly I think just removing this test is the best option for now. (It makes me uncomfortable though!)

test/clangd/fixits.test

18

This test on the other hand is fantastic :-)

[malaperle]

clangd/Protocol.cpp

105

I actually think we should just leave out this part of the patch and address the double parsing everywhere in a separate patch. I can live with Eclipse being broken for Fixits until then. Does that sound good?

test/clangd/execute-command.test

2

The value is not so much testing the error messages but exercising the various code paths. While writing the tests I have found and fixed numerous crashes. Our team is also aiming at >= 80% code coverage (a combination of line+branch) which I admit brings sometimes tests that are more theoretical and quite unlikely. I do think that doing this testing method for everything in Protocol.cpp would not scale well and I don't think at this point we should go back and add more tests to existing handled protocols. I see this test as an interim until we have a better JSON parser in which case I think much of this logic will be simplified and the tests unnecessary. I also like the fuzzing approach from bkramer but it doesn't ensure that we cover all the cases we can deduce just by looking at the code coverage data.

[sammccall]

clangd/Protocol.cpp

105

Sure, that sounds fine to me.

test/clangd/execute-command.test

2

Sure, I'm not going to object to this going in, especially if we can reduce it later.
If you do have code coverage as a way of verifying that these cases get hit, do we need the log messages?

[malaperle]

Address comments.

[malaperle]

clangd/ClangdLSPServer.cpp

88

Sold!

94

I moved the writeMessage to a new call() method but we'll probably want to revisit this because we'll need to generate proper IDs and handle replies like you mentioned.

clangd/Protocol.cpp

105

Removed

253

Removed support for skipping malformed edits.

929

I kept it as is for now. I think I prefer failing early when parsing the ExecuteCommandParams and not have ClangdLSPServer also parse JSON or try to guess (possibly wrongly) which type the arguments are. It seems safer to me at the expense of Protocol.h/cpp not being pure LSP. But there is not that much consequence for now in making Protocol handle extensions and we can also refactor this without too much problem later.

966

If arguments is set before, it will log in onCommand. I changed it so that it fails to parse instead. Not ideal but I don't think in practice this is likely to happen and with a better JSON parser we should be able to improve this. Let me know if you think this is a blocker though.
A JSON parser with DOM with be really great!!! I'm definitely keeping an eye on this.

clangd/Protocol.h

387

there's only one uri + edits so I'll make this a pair instead.

test/clangd/execute-command.test

2

do you mean removing the STDERR lines from the test or the actual logging in Protocol.cpp? I removed one in Protocol.cpp.

[sammccall]

LG, thanks!

test/clangd/execute-command.test

2

Yeah I like removing the log entirely.
(I guess you need to remove it from the test too?)

[malaperle]

Remove logging in code and tests.

[malaperle]

test/clangd/execute-command.test

2

Alright, I removed the "Unknown command" one and removed the checks in the test.

[hokein]

clangd/Protocol.h

386

In the latest LSP (https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md#workspaceedit), WorkspaceEdit has one more optional field documentChanges. I think it is worth a comment describing we don't support it currently?

387

I agree with Sam here, the changes of WorkspaceEdit should be a map<string, vector<TextEdit>> -- because WorkspaceEdit can contain changes of multiple files.

[malaperle]

clangd/Protocol.h

386

I had a line about it before but Sam preferred not keeping it. I don't mind either way.

387

In the protocol:
changes?: { [uri: string]: TextEdit[]; };
Sorry, I though the left-most [ ] was to disambiguate the colons. But I just read about indexable types. I'll change this.

[sammccall]

clangd/Protocol.h

386

Doh, sorry about this.

Re-adding a comment here saying that we support currently versioned edits seems fine. Up to you.

[malaperle]

Added comment, changed pair to map.

[malaperle]

Renamed a variable

[hokein]

Thanks for the updates, looks good. Let's check in it :)

[malaperle]

Thanks for the reviews!

[arphaman]

Please remember to CC cfe-commits for such patches.

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 onCommand(Ctx C, ExecuteCommandParams &Params) 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

 //===--- ClangdLSPServer.cpp - LSP server ------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "JSONRPCDispatcher.h"
 
+#include "llvm/Support/FormatVariadic.h"
+
 using namespace clang::clangd;
 using namespace clang;
 
 namespace {
 
-std::string
+std::vector<TextEdit>
 replacementsToEdits(StringRef Code,
                     const std::vector<tooling::Replacement> &Replacements) {
+  std::vector<TextEdit> Edits;
   // Turn the replacements into the format specified by the Language Server
-  // Protocol. Fuse them into one big JSON array.
-  std::string Edits;
+  // Protocol.
   for (auto &R : Replacements) {
     Range ReplacementRange = {
         offsetToPosition(Code, R.getOffset()),
         offsetToPosition(Code, R.getOffset() + R.getLength())};
-    TextEdit TE = {ReplacementRange, R.getReplacementText()};
-    Edits += TextEdit::unparse(TE);
-    Edits += ',';
+    Edits.push_back({ReplacementRange, R.getReplacementText()});
   }
-  if (!Edits.empty())
-    Edits.pop_back();
 
   return Edits;
 }
 
 } // namespace
 
 void ClangdLSPServer::onInitialize(Ctx C, InitializeParams &Params) {
   C.reply(
       R"({"capabilities":{
           "textDocumentSync": 1,
           "documentFormattingProvider": true,
           "documentRangeFormattingProvider": true,
           "documentOnTypeFormattingProvider": {"firstTriggerCharacter":"}","moreTriggerCharacter":[]},
           "codeActionProvider": true,
           "completionProvider": {"resolveProvider": false, "triggerCharacters": [".",">",":"]},
           "signatureHelpProvider": {"triggerCharacters": ["(",","]},
-          "definitionProvider": true
+          "definitionProvider": true,
+          "executeCommandProvider": {"commands": [")" +
+      ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND + R"("]}
         }})");
   if (Params.rootUri && !Params.rootUri->file.empty())
     Server.setRootPath(Params.rootUri->file);
   else if (Params.rootPath && !Params.rootPath->empty())
     Server.setRootPath(*Params.rootPath);
 }
 
 void ClangdLSPServer::onShutdown(Ctx C, ShutdownParams &Params) {
void ClangdLSPServer::onDocumentDidChange(Ctx C,
   Server.addDocument(Params.textDocument.uri.file,
                      Params.contentChanges[0].text);
 }
 
 void ClangdLSPServer::onFileEvent(Ctx C, DidChangeWatchedFilesParams &Params) {
   Server.onFileEvent(Params);
 }
 
+void ClangdLSPServer::onCommand(Ctx C, ExecuteCommandParams &Params) {
+  if (Params.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND &&
+      Params.workspaceEdit) {
+    // The flow for "apply-fix" :
+    // 1. We publish a diagnostic, including fixits
+    // 2. The user clicks on the diagnostic, the editor asks us for code actions
+    // 3. We send code actions, with the fixit embedded as context
+    // 4. The user selects the fixit, the editor asks us to apply it
+    // 5. We unwrap the changes and send them back to the editor
+    // 6. The editor applies the changes (applyEdit), and sends us a reply (but
+    // we ignore it)
+
+    ApplyWorkspaceEditParams ApplyEdit;
+    ApplyEdit.edit = *Params.workspaceEdit;
+    C.reply("\"Fix applied.\"");
+    // We don't need the response so id == 1 is OK.
+    // Ideally, we would wait for the response and if there is no error, we
+    // would reply success/failure to the original RPC.
+    C.call("workspace/applyEdit", ApplyWorkspaceEditParams::unparse(ApplyEdit));
+  } else {
+    // We should not get here because ExecuteCommandParams would not have
+    // 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(
+        1, llvm::formatv("Unsupported command \"{0}\".", Params.command).str());
+  }
+}
+
 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;
   std::string Code = Server.getDocument(File);
-  std::string Edits =
-      replacementsToEdits(Code, Server.formatOnType(File, Params.position));
-  C.reply("[" + Edits + "]");
+  std::string Edits = TextEdit::unparse(
+      replacementsToEdits(Code, Server.formatOnType(File, Params.position)));
+  C.reply(Edits);
 }
 
 void ClangdLSPServer::onDocumentRangeFormatting(
     Ctx C, DocumentRangeFormattingParams &Params) {
   auto File = Params.textDocument.uri.file;
   std::string Code = Server.getDocument(File);
-  std::string Edits =
-      replacementsToEdits(Code, Server.formatRange(File, Params.range));
-  C.reply("[" + Edits + "]");
+  std::string Edits = TextEdit::unparse(
+      replacementsToEdits(Code, Server.formatRange(File, Params.range)));
+  C.reply(Edits);
 }
 
 void ClangdLSPServer::onDocumentFormatting(Ctx C,
                                            DocumentFormattingParams &Params) {
   auto File = Params.textDocument.uri.file;
   std::string Code = Server.getDocument(File);
-  std::string Edits = replacementsToEdits(Code, Server.formatFile(File));
-  C.reply("[" + Edits + "]");
+  std::string Edits =
+      TextEdit::unparse(replacementsToEdits(Code, Server.formatFile(File)));
+  C.reply(Edits);
 }
 
 void ClangdLSPServer::onCodeAction(Ctx C, CodeActionParams &Params) {
   // We provide a code action for each diagnostic at the requested location
   // which has FixIts available.
   std::string Code = Server.getDocument(Params.textDocument.uri.file);
   std::string Commands;
   for (Diagnostic &D : Params.context.diagnostics) {
     std::vector<clang::tooling::Replacement> Fixes =
         getFixIts(Params.textDocument.uri.file, D);
-    std::string Edits = replacementsToEdits(Code, Fixes);
+    auto Edits = replacementsToEdits(Code, Fixes);
+    WorkspaceEdit WE;
+    WE.changes = {llvm::yaml::escape(Params.textDocument.uri.uri), Edits};
 
     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"(]]},)";
+          R"('", "command": ")" +
+          ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND +
+          R"(", "arguments": [)" + WorkspaceEdit::unparse(WE) + R"(]},)";
   }
   if (!Commands.empty())
     Commands.pop_back();
   C.reply("[" + Commands + "]");
 }
 
 void ClangdLSPServer::onCompletion(Ctx C, TextDocumentPositionParams &Params) {
   auto Items = Server

clangd/JSONRPCDispatcher.h

 class RequestContext {
 public:
   RequestContext(JSONOutput &Out, StringRef ID) : Out(Out), ID(ID) {}
 
   /// Sends a successful reply. Result should be well-formed JSON.
   void reply(const Twine &Result);
   /// Sends an error response to the client, and logs it.
   void replyError(int code, const llvm::StringRef &Message);
+  /// Sends a request to the client.
+  void call(llvm::StringRef Method, StringRef Params);
 
 private:
   JSONOutput &Out;
   llvm::SmallString<64> ID; // Valid JSON, or empty for a notification.
 };
 
 /// Main JSONRPC entry point. This parses the JSONRPC "header" and calls the
 /// registered Handler for the method received.

clangd/JSONRPCDispatcher.cpp

void RequestContext::replyError(int code, const llvm::StringRef &Message) {
   if (!ID.empty()) {
     Out.writeMessage(llvm::Twine(R"({"jsonrpc":"2.0","id":)") + ID +
                      R"(,"error":{"code":)" + llvm::Twine(code) +
                      R"(,"message":")" + llvm::yaml::escape(Message) +
                      R"("}})");
   }
 }
 
+void RequestContext::call(StringRef Method, StringRef Params) {
+  // FIXME: Generate/Increment IDs for every request so that we can get proper
+  // replies once we need to.
+  Out.writeMessage(llvm::Twine(R"({"jsonrpc":"2.0","id":1,"method":")" +
+                               Method + R"(","params":)" + Params + R"(})"));
+}
+
 void JSONRPCDispatcher::registerHandler(StringRef Method, Handler H) {
   assert(!Handlers.count(Method) && "Handler already registered!");
   Handlers[Method] = std::move(H);
 }
 
 static void
 callHandler(const llvm::StringMap<JSONRPCDispatcher::Handler> &Handlers,
             llvm::yaml::ScalarNode *Method, llvm::yaml::ScalarNode *Id,

clangd/Protocol.h

struct TextEdit {
 
   /// The string to be inserted. For delete operations use an
   /// empty string.
   std::string newText;
 
   static llvm::Optional<TextEdit> parse(llvm::yaml::MappingNode *Params,
                                         clangd::Logger &Logger);
   static std::string unparse(const TextEdit &P);
+  static std::string unparse(const std::vector<TextEdit> &TextEdits);
 };
 
 struct TextDocumentItem {
   /// The text document's URI.
   URI uri;
 
   /// The text document's language identifier.
   std::string languageId;
struct CodeActionParams {
 
   /// Context carrying additional information.
   CodeActionContext context;
 
   static llvm::Optional<CodeActionParams> parse(llvm::yaml::MappingNode *Params,
                                                 clangd::Logger &Logger);
 };
 
+struct WorkspaceEdit {
+  /// Holds changes to existing resources.
+  llvm::Optional<std::pair<std::string, std::vector<TextEdit>>> changes;
+
+  static llvm::Optional<WorkspaceEdit> parse(llvm::yaml::MappingNode *Params,
+                                             clangd::Logger &Logger);
+  static std::string unparse(const WorkspaceEdit &WE);
+};
+
+/// Exact commands are not specified in the protocol so we define the
+/// ones supported by Clangd here. The protocol specifies the command arguments
+/// to be "any[]" but to make this safer and more manageable, each command we
+/// handle maps to a certain llvm::Optional of some struct to contain its
+/// arguments. Different commands could reuse the same llvm::Optional as
+/// arguments but a command that needs different arguments would simply add a
+/// new llvm::Optional and not use any other ones. In practice this means only
+/// one argument type will be parsed and set.
+struct ExecuteCommandParams {
+  // Command to apply fix-its. Uses WorkspaceEdit as argument.
+  const static std::string CLANGD_APPLY_FIX_COMMAND;
+
+  /// The command identifier, e.g. CLANGD_APPLY_FIX_COMMAND
+  std::string command;
+
+  // Arguments
+
+  llvm::Optional<WorkspaceEdit> workspaceEdit;
+
+  static llvm::Optional<ExecuteCommandParams>
+  parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger);
+};
+
+struct ApplyWorkspaceEditParams {
+  WorkspaceEdit edit;
+  static std::string unparse(const ApplyWorkspaceEditParams &Params);
+};
+
 struct TextDocumentPositionParams {
   /// The text document.
   TextDocumentIdentifier textDocument;
 
   /// The position inside the text document.
   Position position;
 
   static llvm::Optional<TextDocumentPositionParams>

clangd/Protocol.cpp

llvm::Optional<Position> Position::parse(llvm::yaml::MappingNode *Params,
   Position 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);
     auto *Value =
         dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "line") {
       long long Val;
       if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
         return llvm::None;
llvm::Optional<Metadata> Metadata::parse(llvm::yaml::MappingNode *Params,
   }
   return Result;
 }
 
 llvm::Optional<TextEdit> TextEdit::parse(llvm::yaml::MappingNode *Params,
                                          clangd::Logger &Logger) {
   TextEdit 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);
     auto *Value = NextKeyValue.getValue();
 
     llvm::SmallString<10> Storage;

 std::string TextEdit::unparse(const TextEdit &P) {
   std::string Result;
   llvm::raw_string_ostream(Result) << llvm::format(
       R"({"range": %s, "newText": "%s"})", Range::unparse(P.range).c_str(),
       llvm::yaml::escape(P.newText).c_str());
   return Result;
 }
 
+std::string TextEdit::unparse(const std::vector<TextEdit> &TextEdits) {
+  // Fuse all edits into one big JSON array.
+  std::string Edits;
+  for (auto &TE : TextEdits) {
+    Edits += TextEdit::unparse(TE);
+    Edits += ',';
+  }
+  if (!Edits.empty())
+    Edits.pop_back();
+
+  return "[" + Edits + "]";
+}
+
 namespace {
 TraceLevel getTraceLevel(llvm::StringRef TraceLevelStr,
                          clangd::Logger &Logger) {
   if (TraceLevelStr == "off")
     return TraceLevel::Off;
   else if (TraceLevelStr == "messages")
     return TraceLevel::Messages;
   else if (TraceLevelStr == "verbose")
if (KeyValue == "textDocument") {
       Result.context = std::move(*Parsed);
     } else {
       logIgnoredField(KeyValue, Logger);
     }
   }
   return Result;
 }
 
+llvm::Optional<std::pair<std::string, std::vector<TextEdit>>>
+parseWorkspaceEditChange(llvm::yaml::MappingNode *Params,
+                         clangd::Logger &Logger) {
+  std::pair<std::string, std::vector<TextEdit>> 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 (!Result.first.empty()) {
+      logIgnoredField(KeyValue, Logger);
+      continue;
+    }
+
+    Result.first = KeyValue;
+    auto *Value =
+        dyn_cast_or_null<llvm::yaml::SequenceNode>(NextKeyValue.getValue());
+    if (!Value)
+      return llvm::None;
+    for (auto &Item : *Value) {
+      auto *ItemValue = dyn_cast_or_null<llvm::yaml::MappingNode>(&Item);
+      if (!ItemValue)
+        return llvm::None;
+      auto Parsed = TextEdit::parse(ItemValue, Logger);
+      if (!Parsed)
+        return llvm::None;
+
+      Result.second.push_back(*Parsed);
+    }
+  }
+
+  return Result;
+}
+
+llvm::Optional<WorkspaceEdit>
+WorkspaceEdit::parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger) {
+  WorkspaceEdit 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);
+
+    llvm::SmallString<10> Storage;
+    if (KeyValue == "changes") {
+      auto *Value =
+          dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
+      if (!Value)
+        return llvm::None;
+      auto Parsed = parseWorkspaceEditChange(Value, Logger);
+      if (!Parsed)
+        return llvm::None;
+      Result.changes = std::move(*Parsed);
+    } else {
+      logIgnoredField(KeyValue, Logger);
+    }
+  }
+  return Result;
+}
+
+const std::string ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND =
+    "clangd.applyFix";
+
+llvm::Optional<ExecuteCommandParams>
+ExecuteCommandParams::parse(llvm::yaml::MappingNode *Params,
+                            clangd::Logger &Logger) {
+  ExecuteCommandParams Result;
+  // Depending on which "command" we parse, we will use this function to parse
+  // the command "arguments".
+  std::function<bool(llvm::yaml::MappingNode * Params)> ArgParser = nullptr;
+
+  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);
+
+    // Note that "commands" has to be parsed before "arguments" for this to
+    // work properly.
+    if (KeyValue == "command") {
+      auto *ScalarValue =
+          dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
+      if (!ScalarValue)
+        return llvm::None;
+      llvm::SmallString<10> Storage;
+      Result.command = ScalarValue->getValue(Storage);
+      if (Result.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND) {
+        ArgParser = [&Result, &Logger](llvm::yaml::MappingNode *Params) {
+          auto WE = WorkspaceEdit::parse(Params, Logger);
+          if (WE)
+            Result.workspaceEdit = WE;
+          return WE.hasValue();
+        };
+      } else {
+        Logger.log(llvm::formatv("Unknown command \"{0}\".\n", Result.command));
+        return llvm::None;
+      }
+    } else if (KeyValue == "arguments") {
+      auto *Value = NextKeyValue.getValue();
+      auto *Seq = dyn_cast<llvm::yaml::SequenceNode>(Value);
+      if (!Seq)
+        return llvm::None;
+      for (auto &Item : *Seq) {
+        auto *ItemValue = dyn_cast_or_null<llvm::yaml::MappingNode>(&Item);
+        if (!ItemValue || !ArgParser)
+          return llvm::None;
+        if (!ArgParser(ItemValue))
+          return llvm::None;
+      }
+    } else {
+      logIgnoredField(KeyValue, Logger);
+    }
+  }
+  if (Result.command.empty())
+    return llvm::None;
+
+  return Result;
+}
+
+std::string WorkspaceEdit::unparse(const WorkspaceEdit &WE) {
+  std::string Result;
+  llvm::raw_string_ostream(Result)
+      << llvm::format(R"({"changes": {"%s": %s}})", WE.changes->first.c_str(),
+                      TextEdit::unparse(WE.changes->second).c_str());
+  return Result;
+}
+
+std::string
+ApplyWorkspaceEditParams::unparse(const ApplyWorkspaceEditParams &Params) {
+  std::string Result;
+  llvm::raw_string_ostream(Result) << llvm::format(
+      R"({"edit": %s})", WorkspaceEdit::unparse(Params.edit).c_str());
+  return Result;
+}
+
 llvm::Optional<TextDocumentPositionParams>
 TextDocumentPositionParams::parse(llvm::yaml::MappingNode *Params,
                                   clangd::Logger &Logger) {
   TextDocumentPositionParams Result;
   for (auto &NextKeyValue : *Params) {
     auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
     if (!KeyString)
       return llvm::None;

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 onCommand(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::onCommand);
 }

clangd/clients/clangd-vscode/src/extension.ts

const clientOptions: vscodelc.LanguageClientOptions = {
             protocol2Code: (uri: string) : vscode.Uri => vscode.Uri.parse(uri)
         },
         synchronize: !syncFileEvents ? undefined : {
             fileEvents: vscode.workspace.createFileSystemWatcher('**/*.{' + cppFileExtensionsPattern + '}')
         }
     };
 
     const clangdClient = new vscodelc.LanguageClient('Clang Language Server', serverOptions, clientOptions);
-
-    function applyTextEdits(uri: string, edits: vscodelc.TextEdit[]) {
-        let textEditor = vscode.window.activeTextEditor;
-
-        // FIXME: vscode expects that uri will be percent encoded
-        if (textEditor && textEditor.document.uri.toString(true) === uri) {
-            textEditor.edit(mutator => {
-                for (const edit of edits) {
-                    mutator.replace(clangdClient.protocol2CodeConverter.asRange(edit.range), edit.newText);
-                }
-            }).then((success) => {
-                if (!success) {
-                    vscode.window.showErrorMessage('Failed to apply fixes to the document.');
-                }
-            });
-        }
-    }
-
     console.log('Clang Language Server is now active!');
 
     const disposable = clangdClient.start();
-
-    context.subscriptions.push(disposable, vscode.commands.registerCommand('clangd.applyFix', applyTextEdits));
 }

test/clangd/execute-command.test

+# RUN: clangd -run-synchronously < %s | FileCheck %s
+# RUN: clangd -run-synchronously < %s 2>&1 | FileCheck -check-prefix=STDERR %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: 180
+
+{"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":[{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":2,"message":"using the result of an assignment as a condition without parentheses"},{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":3,"message":"place parentheses around the assignment to silence this warning"},{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":3,"message":"use '==' to turn this assignment into an equality comparison"}]}}
+#
+Content-Length: 72
+
+{"jsonrpc":"2.0","id":3,"method":"workspace/executeCommand","params":{}}
+# No command name
+# STDERR: Failed to decode workspace/executeCommand request.
+Content-Length: 85
+
+{"jsonrpc":"2.0","id":4,"method":"workspace/executeCommand","params":{"command": {}}}
+# Invalid, non-scalar command name
+# STDERR: Failed to decode workspace/executeCommand request.
+Content-Length: 345
+
+{"jsonrpc":"2.0","id":5,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","custom":"foo", "arguments":[{"changes":{"file:///foo.c":[{"range":{"start":{"line":0,"character":32},"end":{"line":0,"character":32}},"newText":"("},{"range":{"start":{"line":0,"character":37},"end":{"line":0,"character":37}},"newText":")"}]}}]}}
+# STDERR: Ignored unknown field "custom"
+Content-Length: 117
+
+{"jsonrpc":"2.0","id":6,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","arguments":"foo"}}
+# Arguments not a sequence.
+# STDERR: Failed to decode workspace/executeCommand request.
+Content-Length: 93
+
+{"jsonrpc":"2.0","id":7,"method":"workspace/executeCommand","params":{"command":"mycommand"}}
+# Unknown command.
+# STDERR: Unknown command "mycommand".
+Content-Length: 132
+
+{"jsonrpc":"2.0","id":8,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","custom":"foo", "arguments":[""]}}
+# ApplyFix argument not a mapping node.
+# STDERR: Failed to decode workspace/executeCommand request.
+Content-Length: 345
+
+{"jsonrpc":"2.0","id":9,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","arguments":[{"custom":"foo", "changes":{"file:///foo.c":[{"range":{"start":{"line":0,"character":32},"end":{"line":0,"character":32}},"newText":"("},{"range":{"start":{"line":0,"character":37},"end":{"line":0,"character":37}},"newText":")"}]}}]}}
+# Custom field in WorkspaceEdit
+# STDERR: Ignored unknown field "custom"
+Content-Length: 132
+
+{"jsonrpc":"2.0","id":10,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","arguments":[{"changes":"foo"}]}}
+# changes in WorkspaceEdit with no mapping node
+# STDERR: Failed to decode workspace/executeCommand request.
+Content-Length: 346
+
+{"jsonrpc":"2.0","id":11,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","arguments":[{"changes":{"file:///foo.c":[{"range":{"start":{"line":0,"character":32},"end":{"line":0,"character":32}},"newText":"("},{"range":{"start":{"line":0,"character":37},"end":{"line":0,"character":37}},"newText":")"}], "custom":"foo"}}]}}
+# Custom field in WorkspaceEditChange
+# STDERR: Ignored unknown field "custom"
+Content-Length: 150
+
+{"jsonrpc":"2.0","id":12,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","arguments":[{"changes":{"file:///foo.c":"bar"}}]}}
+# No sequence node for TextEdits
+# STDERR: Failed to decode workspace/executeCommand request.
+Content-Length: 149
+
+{"jsonrpc":"2.0","id":13,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","arguments":[{"changes":{"file:///foo.c":[""]}}]}}
+# No mapping node for TextEdit
+# STDERR: Failed to decode workspace/executeCommand request.
+Content-Length: 265
+
+{"jsonrpc":"2.0","id":14,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","arguments":[{"changes":{"file:///foo.c":[{"range":{"start":{"line":0,"character":32},"end":{"line":0,"character":32}},"newText":"("},{"range":"","newText":")"}]}}]}}
+# TextEdit not decoded
+# STDERR: Failed to decode workspace/executeCommand request.
+Content-Length: 345
+
+{"jsonrpc":"2.0","id":9,"method":"workspace/executeCommand","params":{"arguments":[{"custom":"foo", "changes":{"file:///foo.c":[{"range":{"start":{"line":0,"character":32},"end":{"line":0,"character":32}},"newText":"("},{"range":{"start":{"line":0,"character":37},"end":{"line":0,"character":37}},"newText":")"}]}}],"command":"clangd.applyFix"}}
+# Command name after arguments
+# STDERR: Failed to decode workspace/executeCommand request.
+Content-Length: 44
+
+{"jsonrpc":"2.0","id":3,"method":"shutdown"}

test/clangd/fixits.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: 180
 
 {"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":[{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":2,"message":"using the result of an assignment as a condition without parentheses"},{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":3,"message":"place parentheses around the assignment to silence this warning"},{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":3,"message":"use '==' to turn this assignment into an equality comparison"}]}}
 #
 Content-Length: 746
 
- {"jsonrpc":"2.0","id":2,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///foo.c"},"range":{"start":{"line":104,"character":13},"end":{"line":0,"character":35}},"context":{"diagnostics":[{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":2,"message":"using the result of an assignment as a condition without parentheses"},{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":3,"message":"place parentheses around the assignment to silence this warning"},{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":3,"message":"use '==' to turn this assignment into an equality comparison"}]}}}
 #
-# CHECK: {"jsonrpc":"2.0","id":2,"result":[{"title":"Apply FixIt 'place parentheses around the assignment to silence this warning'", "command": "clangd.applyFix", "arguments": ["file:///foo.c", [{"range": {"start": {"line": 0, "character": 32}, "end": {"line": 0, "character": 32}}, "newText": "("},{"range": {"start": {"line": 0, "character": 37}, "end": {"line": 0, "character": 37}}, "newText": ")"}]]},{"title":"Apply FixIt 'use '==' to turn this assignment into an equality comparison'", "command": "clangd.applyFix", "arguments": ["file:///foo.c", [{"range": {"start": {"line": 0, "character": 34}, "end": {"line": 0, "character": 35}}, "newText": "=="}]]}]
+# CHECK: {"jsonrpc":"2.0","id":2,"result":[{"title":"Apply FixIt 'place parentheses around the assignment to silence this warning'", "command": "clangd.applyFix", "arguments": [{"changes": {"file:///foo.c": [{"range": {"start": {"line": 0, "character": 32}, "end": {"line": 0, "character": 32}}, "newText": "("},{"range": {"start": {"line": 0, "character": 37}, "end": {"line": 0, "character": 37}}, "newText": ")"}]}}]},{"title":"Apply FixIt 'use '==' to turn this assignment into an equality comparison'", "command": "clangd.applyFix", "arguments": [{"changes": {"file:///foo.c": [{"range": {"start": {"line": 0, "character": 34}, "end": {"line": 0, "character": 35}}, "newText": "=="}]}}]}]}
 #
 Content-Length: 771
 
 {"jsonrpc":"2.0","id":2,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"file:///foo.c"},"range":{"start":{"line":104,"character":13},"end":{"line":0,"character":35}},"context":{"diagnostics":[{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":2,"code":"1","source":"foo","message":"using the result of an assignment as a condition without parentheses"},{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":3,"message":"place parentheses around the assignment to silence this warning"},{"range":{"start": {"line": 0, "character": 35}, "end": {"line": 0, "character": 35}},"severity":3,"message":"use '==' to turn this assignment into an equality comparison"}]}}}
 # Make sure unused "code" and "source" fields ignored gracefully
-# CHECK: {"jsonrpc":"2.0","id":2,"result":[{"title":"Apply FixIt 'place parentheses around the assignment to silence this warning'", "command": "clangd.applyFix", "arguments": ["file:///foo.c", [{"range": {"start": {"line": 0, "character": 32}, "end": {"line": 0, "character": 32}}, "newText": "("},{"range": {"start": {"line": 0, "character": 37}, "end": {"line": 0, "character": 37}}, "newText": ")"}]]},{"title":"Apply FixIt 'use '==' to turn this assignment into an equality comparison'", "command": "clangd.applyFix", "arguments": ["file:///foo.c", [{"range": {"start": {"line": 0, "character": 34}, "end": {"line": 0, "character": 35}}, "newText": "=="}]]}]
+# CHECK: {"jsonrpc":"2.0","id":2,"result":[{"title":"Apply FixIt 'place parentheses around the assignment to silence this warning'", "command": "clangd.applyFix", "arguments": [{"changes": {"file:///foo.c": [{"range": {"start": {"line": 0, "character": 32}, "end": {"line": 0, "character": 32}}, "newText": "("},{"range": {"start": {"line": 0, "character": 37}, "end": {"line": 0, "character": 37}}, "newText": ")"}]}}]},{"title":"Apply FixIt 'use '==' to turn this assignment into an equality comparison'", "command": "clangd.applyFix", "arguments": [{"changes": {"file:///foo.c": [{"range": {"start": {"line": 0, "character": 34}, "end": {"line": 0, "character": 35}}, "newText": "=="}]}}]}]}
 #
+Content-Length: 329
+
+{"jsonrpc":"2.0","id":3,"method":"workspace/executeCommand","params":{"command":"clangd.applyFix","arguments":[{"changes":{"file:///foo.c":[{"range":{"start":{"line":0,"character":32},"end":{"line":0,"character":32}},"newText":"("},{"range":{"start":{"line":0,"character":37},"end":{"line":0,"character":37}},"newText":")"}]}}]}}
+# CHECK: {"jsonrpc":"2.0","id":3,"result":"Fix applied."}
+# CHECK: {"jsonrpc":"2.0","id":1,"method":"workspace/applyEdit","params":{"edit": {"changes": {"file:///foo.c": [{"range": {"start": {"line": 0, "character": 32}, "end": {"line": 0, "character": 32}}, "newText": "("},{"range": {"start": {"line": 0, "character": 37}, "end": {"line": 0, "character": 37}}, "newText": ")"}]}}}}
 Content-Length: 44
 
 {"jsonrpc":"2.0","id":3,"method":"shutdown"}
 # CHECK: {"jsonrpc":"2.0","id":3,"result":null}
 Content-Length: 33
 
 {"jsonrpc":"2.0":"method":"exit"}

test/clangd/initialize-params-invalid.test

 # RUN: clangd -run-synchronously < %s | FileCheck %s
 # It is absolutely vital that this file has CRLF line endings.
 #
 # Test with invalid initialize request parameters
 Content-Length: 142
 
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":"","rootUri":"file:///path/to/workspace","capabilities":{},"trace":"off"}}
-# CHECK: Content-Length: 535
+# CHECK: Content-Length: 606
 # CHECK: {"jsonrpc":"2.0","id":0,"result":{"capabilities":{
 # CHECK:   "textDocumentSync": 1,
 # CHECK:   "documentFormattingProvider": true,
 # CHECK:   "documentRangeFormattingProvider": true,
 # CHECK:   "documentOnTypeFormattingProvider": {"firstTriggerCharacter":"}","moreTriggerCharacter":[]},
 # CHECK:   "codeActionProvider": true,
 # CHECK:   "completionProvider": {"resolveProvider": false, "triggerCharacters": [".",">",":"]},
 # CHECK:   "signatureHelpProvider": {"triggerCharacters": ["(",","]},
-# CHECK:   "definitionProvider": true
+# CHECK:   "definitionProvider": true,
+# CHECK:   "executeCommandProvider": {"commands": ["clangd.applyFix"]}
 # CHECK: }}}
 #
 Content-Length: 44
 
 {"jsonrpc":"2.0","id":3,"method":"shutdown"}
 # CHECK: {"jsonrpc":"2.0","id":3,"result":null}
 Content-Length: 33
 
 {"jsonrpc":"2.0":"method":"exit"}

test/clangd/initialize-params.test

 # RUN: clangd -run-synchronously < %s | FileCheck %s
 # It is absolutely vital that this file has CRLF line endings.
 #
 # Test initialize request parameters with rootUri
 Content-Length: 143
 
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootUri":"file:///path/to/workspace","capabilities":{},"trace":"off"}}
-# CHECK: Content-Length: 535
+# CHECK: Content-Length: 606
 # CHECK: {"jsonrpc":"2.0","id":0,"result":{"capabilities":{
 # CHECK:   "textDocumentSync": 1,
 # CHECK:   "documentFormattingProvider": true,
 # CHECK:   "documentRangeFormattingProvider": true,
 # CHECK:   "documentOnTypeFormattingProvider": {"firstTriggerCharacter":"}","moreTriggerCharacter":[]},
 # CHECK:   "codeActionProvider": true,
 # CHECK:   "completionProvider": {"resolveProvider": false, "triggerCharacters": [".",">",":"]},
 # CHECK:   "signatureHelpProvider": {"triggerCharacters": ["(",","]},
-# CHECK:   "definitionProvider": true
+# CHECK:   "definitionProvider": true,
+# CHECK:   "executeCommandProvider": {"commands": ["clangd.applyFix"]}
 # CHECK: }}}
 #
 Content-Length: 44
 
 {"jsonrpc":"2.0","id":3,"method":"shutdown"}
 # CHECK: {"jsonrpc":"2.0","id":3,"result":null}
 Content-Length: 33
 
 {"jsonrpc":"2.0":"method":"exit"}