[clangd] Add support for FixIts.

[bkramer]

Summary

This uses CodeActions to show 'apply fix' actions when code actions are
requested for a location. The actions themselves make use of a
clangd.applyFix command which has to be implemented on the editor side. I
included an implementation for vscode.

This also adds a -run-synchronously flag which runs everything on the main
thread. This is useful for testing.

[krasimir]

clangd/ASTManager.cpp

105 ↗

(On Diff #90175)

Why not typedef the type of the FixIts map?

124 ↗

(On Diff #90175)

I prefer this local variable to have a different name.

134 ↗

(On Diff #90175)

Consider the following situation:

1. worker thread is at line 130 just before the critical section with full info about file A in LocalFixits; main thread takes the lock at line 159 in onDocumentAdd(file B)
2. main thread finishes the critical section, calling CV.notify_one(), which has no effect and releases RequestLock.
3. worker thread then gets RequestLock and enters the critical section at line 133, which outputs essentially stale diagnostics.

Arguably this seems OK, but maybe we want a separate mutex controlling access to the FixIts, which also might be more logical.
I can't find a real issue with the code as-is, you can leave it like this, I'm just wondering.

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

26 ↗

(On Diff #90175)

Consider using const instead of let.

[bkramer]

• Use typedef instead of decltype()
• Rename local variable not to shadow member.
• Give FixIts their own mutex
• Use const instead of let in typescript

[krasimir]

Looks Great!

clang-tools-extra/trunk/clangd/ASTManager.h

 //===--- ASTManager.h - Clang AST manager -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_ASTMANAGER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_ASTMANAGER_H
 
 #include "DocumentStore.h"
 #include "JSONRPCDispatcher.h"
+#include "Protocol.h"
+#include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include <condition_variable>
 #include <deque>
 #include <thread>
 
 namespace clang {
 class ASTUnit;
 class DiagnosticsEngine;
 class PCHContainerOperations;
 namespace tooling {
 class CompilationDatabase;
 } // namespace tooling
 
 namespace clangd {
 
 class ASTManager : public DocumentStoreListener {
 public:
-  ASTManager(JSONOutput &Output, DocumentStore &Store);
+  ASTManager(JSONOutput &Output, DocumentStore &Store, bool RunSynchronously);
   ~ASTManager() override;
 
   void onDocumentAdd(StringRef Uri) override;
   // FIXME: Implement onDocumentRemove
   // FIXME: Implement codeComplete
 
+  /// Get the fixes associated with a certain diagnostic as replacements.
+  llvm::ArrayRef<clang::tooling::Replacement>
+  getFixIts(const clangd::Diagnostic &D);
+
+  DocumentStore &getStore() const { return Store; }
+
 private:
   JSONOutput &Output;
   DocumentStore &Store;
 
+  // Set to true if requests should block instead of being processed
+  // asynchronously.
+  bool RunSynchronously;
+
   /// Loads a compilation database for URI. May return nullptr if it fails. The
   /// database is cached for subsequent accesses.
   clang::tooling::CompilationDatabase *
   getOrCreateCompilationDatabaseForFile(StringRef Uri);
   // Craetes a new ASTUnit for the document at Uri.
   // FIXME: This calls chdir internally, which is thread unsafe.
   std::unique_ptr<clang::ASTUnit>
   createASTUnitForFile(StringRef Uri, const DocumentStore &Docs);
 
   void runWorker();
+  void parseFileAndPublishDiagnostics(StringRef File);
 
   /// Clang objects.
   llvm::StringMap<std::unique_ptr<clang::ASTUnit>> ASTs;
   llvm::StringMap<std::unique_ptr<clang::tooling::CompilationDatabase>>
       CompilationDatabases;
   std::shared_ptr<clang::PCHContainerOperations> PCHs;
 
+  typedef std::map<clangd::Diagnostic, std::vector<clang::tooling::Replacement>>
+      DiagnosticToReplacementMap;
+  DiagnosticToReplacementMap FixIts;
+  std::mutex FixItLock;
+
   /// Queue of requests.
   std::deque<std::string> RequestQueue;
   /// Setting Done to true will make the worker thread terminate.
   bool Done = false;
   /// Condition variable to wake up the worker thread.
   std::condition_variable ClangRequestCV;
   /// Lock for accesses to RequestQueue and Done.
   std::mutex RequestLock;

clang-tools-extra/trunk/clangd/ASTManager.cpp

static int getSeverity(DiagnosticsEngine::Level L) {
   case DiagnosticsEngine::Error:
     return 1;
   case DiagnosticsEngine::Ignored:
     return 0;
   }
   llvm_unreachable("Unknown diagnostic level!");
 }
 
-ASTManager::ASTManager(JSONOutput &Output, DocumentStore &Store)
-    : Output(Output), Store(Store),
+ASTManager::ASTManager(JSONOutput &Output, DocumentStore &Store,
+                       bool RunSynchronously)
+    : Output(Output), Store(Store), RunSynchronously(RunSynchronously),
       PCHs(std::make_shared<PCHContainerOperations>()),
       ClangWorker([this]() { runWorker(); }) {}
 
 void ASTManager::runWorker() {
   while (true) {
     std::string File;
 
     {
       std::unique_lock<std::mutex> Lock(RequestLock);
       // Check if there's another request pending. We keep parsing until
       // our one-element queue is empty.
-      ClangRequestCV.wait(Lock, [this] {
-        return !RequestQueue.empty() || Done;
-      });
+      ClangRequestCV.wait(Lock,
+                          [this] { return !RequestQueue.empty() || Done; });
 
       if (RequestQueue.empty() && Done)
         return;
 
       File = std::move(RequestQueue.back());
       RequestQueue.pop_back();
     } // unlock.
 
-    auto &Unit = ASTs[File]; // Only one thread can access this at a time.
+    parseFileAndPublishDiagnostics(File);
+  }
+}
+
+void ASTManager::parseFileAndPublishDiagnostics(StringRef File) {
 
-    if (!Unit) {
-      Unit = createASTUnitForFile(File, this->Store);
-    } else {
-      // Do a reparse if this wasn't the first parse.
-      // FIXME: This might have the wrong working directory if it changed in the
-      // meantime.
-      Unit->Reparse(PCHs, getRemappedFiles(this->Store));
-    }
 
-    if (!Unit)
-      continue;
+    return;
 
-    // Send the diagnotics to the editor.
-    // FIXME: If the diagnostic comes from a different file, do we want to
-    // show them all? Right now we drop everything not coming from the
-    // main file.
-    // FIXME: Send FixIts to the editor.
-    std::string Diagnostics;
-    for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(),
-                                       DEnd = Unit->stored_diag_end();
-         D != DEnd; ++D) {
-      if (!D->getLocation().isValid() ||
-          !D->getLocation().getManager().isInMainFile(D->getLocation()))
-        continue;
-      Position P;
-      P.line = D->getLocation().getSpellingLineNumber() - 1;
-      P.character = D->getLocation().getSpellingColumnNumber();
-      Range R = {P, P};
-      Diagnostics +=
-          R"({"range":)" + Range::unparse(R) +
-          R"(,"severity":)" + std::to_string(getSeverity(D->getLevel())) +
-          R"(,"message":")" + llvm::yaml::escape(D->getMessage()) +
-          R"("},)";
-    }
+  DiagnosticToReplacementMap LocalFixIts; // Temporary storage
+
+    // We convert to Replacements to become independent of the SourceManager.
+    clangd::Diagnostic Diag = {R, getSeverity(D->getLevel()), D->getMessage()};
+    auto &FixItsForDiagnostic = LocalFixIts[Diag];
+    for (const FixItHint &Fix : D->getFixIts()) {
+      FixItsForDiagnostic.push_back(clang::tooling::Replacement(
+          Unit->getSourceManager(), Fix.RemoveRange, Fix.CodeToInsert));
+    }
+  }
+
+  // Put FixIts into place.
+  {
+    std::lock_guard<std::mutex> Guard(FixItLock);
+    FixIts = std::move(LocalFixIts);
 
-    if (!Diagnostics.empty())
-      Diagnostics.pop_back(); // Drop trailing comma.
-    Output.writeMessage(
-        R"({"jsonrpc":"2.0","method":"textDocument/publishDiagnostics","params":{"uri":")" +
-        File + R"(","diagnostics":[)" + Diagnostics + R"(]}})");
-  }
-}
 
 ASTManager::~ASTManager() {
   {
     std::lock_guard<std::mutex> Guard(RequestLock);
     // Wake up the clang worker thread, then exit.
     Done = true;
     ClangRequestCV.notify_one();
   }
   ClangWorker.join();
 }
 
 void ASTManager::onDocumentAdd(StringRef Uri) {
+  if (RunSynchronously) {
+    parseFileAndPublishDiagnostics(Uri);
+    return;
+  }
   std::lock_guard<std::mutex> Guard(RequestLock);
   // Currently we discard all pending requests and just enqueue the latest one.
   RequestQueue.clear();
   RequestQueue.push_back(Uri);
   ClangRequestCV.notify_one();
 }
 
 tooling::CompilationDatabase *
return std::unique_ptr<clang::ASTUnit>(ASTUnit::LoadFromCommandLine(
       /*OnlyLocalDecls=*/false, /*CaptureDiagnostics=*/true,
       getRemappedFiles(Docs),
       /*RemappedFilesKeepOriginalName=*/true,
       /*PrecompilePreambleAfterNParses=*/1, /*TUKind=*/TU_Complete,
       /*CacheCodeCompletionResults=*/true,
       /*IncludeBriefCommentsInCodeCompletion=*/true,
       /*AllowPCHWithCompilerErrors=*/true));
 }
+
+llvm::ArrayRef<clang::tooling::Replacement>
+ASTManager::getFixIts(const clangd::Diagnostic &D) {
+  std::lock_guard<std::mutex> Guard(FixItLock);
+  auto I = FixIts.find(D);
+  if (I != FixIts.end())
+    return I->second;
+  return llvm::None;
+}

clang-tools-extra/trunk/clangd/ClangDMain.cpp

 //===--- ClangDMain.cpp - clangd server loop ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ASTManager.h"
 #include "DocumentStore.h"
 #include "JSONRPCDispatcher.h"
 #include "ProtocolHandlers.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Program.h"
 #include <iostream>
 #include <string>
 using namespace clang::clangd;
 
+static llvm::cl::opt<bool>
+    RunSynchronously("run-synchronously",
+                     llvm::cl::desc("parse on main thread"),
+                     llvm::cl::init(false), llvm::cl::Hidden);
+
 int main(int argc, char *argv[]) {
+  llvm::cl::ParseCommandLineOptions(argc, argv, "clangd");
   llvm::raw_ostream &Outs = llvm::outs();
   llvm::raw_ostream &Logs = llvm::errs();
   JSONOutput Out(Outs, Logs);
 
   // Change stdin to binary to not lose \r\n on windows.
   llvm::sys::ChangeStdinToBinary();
 
   // Set up a document store and intialize all the method handlers for JSONRPC
   // dispatching.
   DocumentStore Store;
-  ASTManager AST(Out, Store);
+  ASTManager AST(Out, Store, RunSynchronously);
   Store.addListener(&AST);
   JSONRPCDispatcher Dispatcher(llvm::make_unique<Handler>(Out));
   Dispatcher.registerHandler("initialize",
                              llvm::make_unique<InitializeHandler>(Out));
   auto ShutdownPtr = llvm::make_unique<ShutdownHandler>(Out);
   auto *ShutdownHandler = ShutdownPtr.get();
-  Dispatcher.registerHandler("shutdown",std::move(ShutdownPtr));
+  Dispatcher.registerHandler("shutdown", std::move(ShutdownPtr));
   Dispatcher.registerHandler(
       "textDocument/didOpen",
       llvm::make_unique<TextDocumentDidOpenHandler>(Out, Store));
   // FIXME: Implement textDocument/didClose.
   Dispatcher.registerHandler(
       "textDocument/didChange",
       llvm::make_unique<TextDocumentDidChangeHandler>(Out, Store));
   Dispatcher.registerHandler(
       "textDocument/rangeFormatting",
       llvm::make_unique<TextDocumentRangeFormattingHandler>(Out, Store));
   Dispatcher.registerHandler(
       "textDocument/onTypeFormatting",
       llvm::make_unique<TextDocumentOnTypeFormattingHandler>(Out, Store));
   Dispatcher.registerHandler(
       "textDocument/formatting",
       llvm::make_unique<TextDocumentFormattingHandler>(Out, Store));
+  Dispatcher.registerHandler("textDocument/codeAction",
+                             llvm::make_unique<CodeActionHandler>(Out, AST));
 
   while (std::cin.good()) {
     // A Language Server Protocol message starts with a HTTP header, delimited
     // by \r\n.
     std::string Line;
     std::getline(std::cin, Line);
 
     // Skip empty lines.

clang-tools-extra/trunk/clangd/Protocol.h

 
 struct Position {
   /// Line position in a document (zero-based).
   int line;
 
   /// Character offset on a line in a document (zero-based).
   int character;
 
+  friend bool operator==(const Position &LHS, const Position &RHS) {
+    return std::tie(LHS.line, LHS.character) ==
+           std::tie(RHS.line, RHS.character);
+  }
+  friend bool operator<(const Position &LHS, const Position &RHS) {
+    return std::tie(LHS.line, LHS.character) <
+           std::tie(RHS.line, RHS.character);
+  }
+
   static llvm::Optional<Position> parse(llvm::yaml::MappingNode *Params);
   static std::string unparse(const Position &P);
 };
 
 struct Range {
   /// The range's start position.
   Position start;
 
   /// The range's end position.
   Position end;
 
+  friend bool operator==(const Range &LHS, const Range &RHS) {
+    return std::tie(LHS.start, LHS.end) == std::tie(RHS.start, RHS.end);
+  }
+  friend bool operator<(const Range &LHS, const Range &RHS) {
+    return std::tie(LHS.start, LHS.end) < std::tie(RHS.start, RHS.end);
+  }
+
   static llvm::Optional<Range> parse(llvm::yaml::MappingNode *Params);
   static std::string unparse(const Range &P);
 };
 
 struct TextEdit {
   /// The range of the text document to be manipulated. To insert
   /// text into a document create a range where start === end.
   Range range;
struct DocumentFormattingParams {
 
   /// The format options
   FormattingOptions options;
 
   static llvm::Optional<DocumentFormattingParams>
   parse(llvm::yaml::MappingNode *Params);
 };
 
+struct Diagnostic {
+  /// The range at which the message applies.
+  Range range;
+
+  /// The diagnostic's severity. Can be omitted. If omitted it is up to the
+  /// client to interpret diagnostics as error, warning, info or hint.
+  int severity;
+
+  /// The diagnostic's message.
+  std::string message;
+
+  friend bool operator==(const Diagnostic &LHS, const Diagnostic &RHS) {
+    return std::tie(LHS.range, LHS.severity, LHS.message) ==
+           std::tie(RHS.range, RHS.severity, RHS.message);
+  }
+  friend bool operator<(const Diagnostic &LHS, const Diagnostic &RHS) {
+    return std::tie(LHS.range, LHS.severity, LHS.message) <
+           std::tie(RHS.range, RHS.severity, RHS.message);
+  }
+
+  static llvm::Optional<Diagnostic> parse(llvm::yaml::MappingNode *Params);
+};
+
+struct CodeActionContext {
+  /// An array of diagnostics.
+  std::vector<Diagnostic> diagnostics;
+
+  static llvm::Optional<CodeActionContext>
+  parse(llvm::yaml::MappingNode *Params);
+};
+
+struct CodeActionParams {
+  /// The document in which the command was invoked.
+  TextDocumentIdentifier textDocument;
+
+  /// The range for which the command was invoked.
+  Range range;
+
+  /// Context carrying additional information.
+  CodeActionContext context;
+
+  static llvm::Optional<CodeActionParams>
+  parse(llvm::yaml::MappingNode *Params);
+};
+
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/trunk/clangd/Protocol.cpp

if (KeyValue == "textDocument") {
         return llvm::None;
       Result.options = std::move(*Parsed);
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
+
+llvm::Optional<Diagnostic> Diagnostic::parse(llvm::yaml::MappingNode *Params) {
+  Diagnostic 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 == "range") {
+      auto *Value =
+          dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
+      if (!Value)
+        return llvm::None;
+      auto Parsed = Range::parse(Value);
+      if (!Parsed)
+        return llvm::None;
+      Result.range = std::move(*Parsed);
+    } else if (KeyValue == "severity") {
+      auto *Value =
+          dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
+      if (!Value)
+        return llvm::None;
+      long long Val;
+      if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
+        return llvm::None;
+      Result.severity = Val;
+    } else if (KeyValue == "message") {
+      auto *Value =
+          dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
+      if (!Value)
+        return llvm::None;
+      Result.message = Value->getValue(Storage);
+    } else {
+      return llvm::None;
+    }
+  }
+  return Result;
+}
+
+llvm::Optional<CodeActionContext>
+CodeActionContext::parse(llvm::yaml::MappingNode *Params) {
+  CodeActionContext 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;
+    if (KeyValue == "diagnostics") {
+      auto *Seq = dyn_cast<llvm::yaml::SequenceNode>(Value);
+      if (!Seq)
+        return llvm::None;
+      for (auto &Item : *Seq) {
+        auto *I = dyn_cast<llvm::yaml::MappingNode>(&Item);
+        if (!I)
+          return llvm::None;
+        auto Parsed = Diagnostic::parse(I);
+        if (!Parsed)
+          return llvm::None;
+        Result.diagnostics.push_back(std::move(*Parsed));
+      }
+    } else {
+      return llvm::None;
+    }
+  }
+  return Result;
+}
+
+llvm::Optional<CodeActionParams>
+CodeActionParams::parse(llvm::yaml::MappingNode *Params) {
+  CodeActionParams 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::MappingNode>(NextKeyValue.getValue());
+    if (!Value)
+      return llvm::None;
+
+    llvm::SmallString<10> Storage;
+    if (KeyValue == "textDocument") {
+      auto Parsed = TextDocumentIdentifier::parse(Value);
+      if (!Parsed)
+        return llvm::None;
+      Result.textDocument = std::move(*Parsed);
+    } else if (KeyValue == "range") {
+      auto Parsed = Range::parse(Value);
+      if (!Parsed)
+        return llvm::None;
+      Result.range = std::move(*Parsed);
+    } else if (KeyValue == "context") {
+      auto Parsed = CodeActionContext::parse(Value);
+      if (!Parsed)
+        return llvm::None;
+      Result.context = std::move(*Parsed);
+    } else {
+      return llvm::None;
+    }
+  }
+  return Result;
+}

clang-tools-extra/trunk/clangd/ProtocolHandlers.h

 
 #include "JSONRPCDispatcher.h"
 #include "Protocol.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace clangd {
+class ASTManager;
 class DocumentStore;
 
 struct InitializeHandler : Handler {
   InitializeHandler(JSONOutput &Output) : Handler(Output) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
     writeMessage(
         R"({"jsonrpc":"2.0","id":)" + ID +
         R"(,"result":{"capabilities":{
           "textDocumentSync": 1,
           "documentFormattingProvider": true,
           "documentRangeFormattingProvider": true,
-          "documentOnTypeFormattingProvider": {"firstTriggerCharacter":"}","moreTriggerCharacter":[]}
+          "documentOnTypeFormattingProvider": {"firstTriggerCharacter":"}","moreTriggerCharacter":[]},
+          "codeActionProvider": true
         }}})");
   }
 };
 
 struct ShutdownHandler : Handler {
   ShutdownHandler(JSONOutput &Output) : Handler(Output) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
TextDocumentFormattingHandler(JSONOutput &Output, DocumentStore &Store)
       : Handler(Output), Store(Store) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override;
 
 private:
   DocumentStore &Store;
 };
 
+struct CodeActionHandler : Handler {
+  CodeActionHandler(JSONOutput &Output, ASTManager &AST)
+      : Handler(Output), AST(AST) {}
+
+  void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override;
+
+private:
+  ASTManager *
+};
+
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/trunk/clangd/ProtocolHandlers.cpp

 //===--- ProtocolHandlers.cpp - LSP callbacks -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ProtocolHandlers.h"
+#include "ASTManager.h"
 #include "DocumentStore.h"
 #include "clang/Format/Format.h"
 using namespace clang;
 using namespace clangd;
 
 void TextDocumentDidOpenHandler::handleNotification(
     llvm::yaml::MappingNode *Params) {
   auto DOTDP = DidOpenTextDocumentParams::parse(Params);
static Position offsetToPosition(StringRef Code, size_t Offset) {
   StringRef JustBefore = Code.substr(0, Offset);
   // FIXME: \r\n
   // FIXME: UTF-8
   int Lines = JustBefore.count('\n');
   int Cols = JustBefore.size() - JustBefore.rfind('\n') - 1;
   return {Lines, Cols};
 }
 
-static std::string formatCode(StringRef Code, StringRef Filename,
-                              ArrayRef<tooling::Range> Ranges, StringRef ID) {
-  // Call clang-format.
-  // FIXME: Don't ignore style.
-  format::FormatStyle Style = format::getLLVMStyle();
-  // On windows FileManager doesn't like file://. Just strip it, clang-format
-  // doesn't need it.
-  Filename.consume_front("file://");
-  tooling::Replacements Replacements =
-      format::reformat(Style, Code, Ranges, Filename);
-
-  // Now turn the replacements into the format specified by the Language Server
+template <typename T>
+static std::string replacementsToEdits(StringRef Code, const T &Replacements) {
+  // Turn the replacements into the format specified by the Language Server
   // Protocol. Fuse them into one big JSON array.
   std::string Edits;
   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 += ',';
   }
   if (!Edits.empty())
     Edits.pop_back();
 
+  return Edits;
+}
+
+static std::string formatCode(StringRef Code, StringRef Filename,
+                              ArrayRef<tooling::Range> Ranges, StringRef ID) {
+  // Call clang-format.
+  // FIXME: Don't ignore style.
+  format::FormatStyle Style = format::getLLVMStyle();
+  // On windows FileManager doesn't like file://. Just strip it, clang-format
+  // doesn't need it.
+  Filename.consume_front("file://");
+  tooling::Replacements Replacements =
+      format::reformat(Style, Code, Ranges, Filename);
+
+  std::string Edits = replacementsToEdits(Code, Replacements);
   return R"({"jsonrpc":"2.0","id":)" + ID.str() +
          R"(,"result":[)" + Edits + R"(]})";
 }
 
 void TextDocumentRangeFormattingHandler::handleMethod(
     llvm::yaml::MappingNode *Params, StringRef ID) {
   auto DRFP = DocumentRangeFormattingParams::parse(Params);
   if (!DRFP) {
if (!DFP) {
     return;
   }
 
   // Format everything.
   std::string Code = Store.getDocument(DFP->textDocument.uri);
   writeMessage(formatCode(Code, DFP->textDocument.uri,
                           {clang::tooling::Range(0, Code.size())}, ID));
 }
+
+void CodeActionHandler::handleMethod(llvm::yaml::MappingNode *Params,
+                                     StringRef ID) {
+  auto CAP = CodeActionParams::parse(Params);
+  if (!CAP) {
+    Output.log("Failed to decode CodeActionParams!\n");
+    return;
+  }
+
+  // We provide a code action for each diagnostic at the requested location
+  // which has FixIts available.
+  std::string Code = AST.getStore().getDocument(CAP->textDocument.uri);
+  std::string Commands;
+  for (Diagnostic &D : CAP->context.diagnostics) {
+    std::vector<clang::tooling::Replacement> Fixes = AST.getFixIts(D);
+    std::string Edits = replacementsToEdits(Code, Fixes);
+
+    if (!Edits.empty())
+      Commands +=
+          R"({"title":"Apply FixIt ')" + llvm::yaml::escape(D.message) +
+          R"('", "command": "clangd.applyFix", "arguments": [")" +
+          llvm::yaml::escape(CAP->textDocument.uri) +
+          R"(", [)" + Edits +
+          R"(]]},)";
+  }
+  if (!Commands.empty())
+    Commands.pop_back();
+
+  writeMessage(
+      R"({"jsonrpc":"2.0","id":)" + ID.str() +
+      R"(, "result": [)" + Commands +
+      R"(]})");
+}

clang-tools-extra/trunk/clangd/clients/clangd-vscode/src/extension.ts

export function activate(context: vscode.ExtensionContext) {
 
     const clientOptions: vscodelc.LanguageClientOptions = {
         // Register the server for C/C++ files
         documentSelector: ['c', 'cc', 'cpp', 'h', 'hh', 'hpp']
     };
 
     const clangdClient = new vscodelc.LanguageClient('Clang Language Server', serverOptions, clientOptions);
 
+    function applyTextEdits(uri: string, edits: vscodelc.TextEdit[]) {
+        let textEditor = vscode.window.activeTextEditor;
+
+        if (textEditor && textEditor.document.uri.toString() === uri) {
+            textEditor.edit(mutator => {
+                for (const edit of edits) {
+                    mutator.replace(vscodelc.Protocol2Code.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);
+    context.subscriptions.push(disposable, vscode.commands.registerCommand('clangd.applyFix', applyTextEdits));
 }
 No newline at end of file

clang-tools-extra/trunk/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": "=="}]]}]
+#
+Content-Length: 44
+
+{"jsonrpc":"2.0","id":3,"method":"shutdown"}

clang-tools-extra/trunk/test/clangd/formatting.test

 # RUN: clangd < %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"}}
-# CHECK: Content-Length: 294
+# CHECK: Content-Length: 332
 # CHECK: {"jsonrpc":"2.0","id":0,"result":{"capabilities":{
 # CHECK:   "textDocumentSync": 1,
 # CHECK:   "documentFormattingProvider": true,
 # CHECK:   "documentRangeFormattingProvider": true,
-# CHECK:   "documentOnTypeFormattingProvider": {"firstTriggerCharacter":"}","moreTriggerCharacter":[]}
+# CHECK:   "documentOnTypeFormattingProvider": {"firstTriggerCharacter":"}","moreTriggerCharacter":[]},
+# CHECK:   "codeActionProvider": true
 # CHECK: }}}
 #
 Content-Length: 193
 
 {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///foo.c","languageId":"c","version":1,"text":"int foo ( int x ) {\n    x = x+1;\n    return x;\n    }"}}}
 #
 #
 Content-Length: 233