[clangd] Fix codeAction not decoded properly when sent from some clients

[malaperle]

Summary

Fix for bug https://bugs.llvm.org/show_bug.cgi?id=34559
Also log unknown fields instead of aborting the JSON parsing because it's
common that new optional fields are added either in new versions of the protocol
or extensions.

[malaperle]

Will have more changes, I was testing my git+svn+arc setup.

[ilya-biryukov]

Totally makes sense to recover by ignoring unknown fields.
Could you also add a test-case?

I couldn't find "code" : null in LSP, is that some kind of extension? What does it do?

clangd/Protocol.cpp

598 ↗

(On Diff #114873)

Let's add a FIXME: to log ignored fields. (We don't pass JSONOutput here, which is used for logging, so doing an actual logging peoperly requires some refactoring).

[malaperle]

In D37754#869258, @ilya-biryukov wrote:

Totally makes sense to recover by ignoring unknown fields.
Could you also add a test-case?

Sorry, this wasn't meant to be reviewed yet, I was testing git+svn

[ilya-biryukov]

Oh, sorry, I got an email from a Herald rule and confused it with a review.

[malaperle]

clangd/Protocol.cpp

598 ↗

(On Diff #114873)

I'd like to fix all occurrences of this problem since I've had this problem in other places too. I think it makes sense to log ignored fields. Do you think we should pass JSONOutput everywhere? It feels odd. How about passing the llvm::raw_ostream?

[malaperle]

clangd/Protocol.cpp

598 ↗

(On Diff #114873)

I guess since JSONOutput takes care of the thead-safety, we should use it.

[malaperle]

[clangd] Fix codeAction not decoded properly when sent from some clients

Summary: Fix for bug https://bugs.llvm.org/show_bug.cgi?id=34559
Also log unknown fields instead of aborting the JSON parsing because it's
common that new optional fields are added either in new versions of the protocol
or extensions.

Subscribers: ilya-biryukov

Differential Revision: https://reviews.llvm.org/D37754

[ilya-biryukov]

Could you please clang-format the code?
Overall looks good, just a few comments, mostly regarding code style.

clangd/Protocol.cpp

27 ↗

(On Diff #115280)

Maybe use llvm::StringRef instead of clang::StringRef for constistency with other parts of the file?

27 ↗

(On Diff #115280)

StringRef is cheap to copy and designed to be passed by value. Just use StringRef instead of const StringRef&.

29 ↗

(On Diff #115280)

KeyValue.str().c_str() can be replaced with simply KeyValue.

598 ↗

(On Diff #114873)

Sure, ideally we don't want to have access to JSONOutput::writeMessage, but we do want thread-safety for logging.
Using JSONOutput seems ok for now. I am going to change some logging logic in clangd to fix some FIXMEs I have from previous refactoring, will handle this case as well.

[malaperle]

Address comments.

[malaperle]

clangd/Protocol.cpp

27 ↗

(On Diff #115280)

I will blame CDT's extract method refactoring for this one :) Done.

[ilya-biryukov]

Looks good!

[malaperle]

Would you like to wait until https://reviews.llvm.org/D37972 has landed? Or is it OK to update this part with the new logger in a subsequent patch?

[ilya-biryukov]

In D37754#873740, @malaperle wrote:

Would you like to wait until https://reviews.llvm.org/D37972 has landed? Or is it OK to update this part with the new logger in a subsequent patch?

No need to, just submit your change. I'll update D37972 accordingly after your change lands.

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

 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/YAMLParser.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
+class JSONOutput;
+
 struct URI {
   std::string uri;
   std::string file;
 
   static URI fromUri(llvm::StringRef uri);
   static URI fromFile(llvm::StringRef file);
 
   static URI parse(llvm::yaml::ScalarNode *Param);
struct URI {
   }
 };
 
 struct TextDocumentIdentifier {
   /// The text document's URI.
   URI uri;
 
   static llvm::Optional<TextDocumentIdentifier>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 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 llvm::Optional<Position> parse(llvm::yaml::MappingNode *Params,
+                                        JSONOutput &Output);
   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 llvm::Optional<Range> parse(llvm::yaml::MappingNode *Params,
+                                     JSONOutput &Output);
   static std::string unparse(const Range &P);
 };
 
 struct Location {
   /// The text document's URI.
   URI uri;
   Range range;
 
struct Location {
   }
 
   static std::string unparse(const Location &P);
 };
 
 struct Metadata {
   std::vector<std::string> extraFlags;
 
-  static llvm::Optional<Metadata> parse(llvm::yaml::MappingNode *Params);
+  static llvm::Optional<Metadata> parse(llvm::yaml::MappingNode *Params,
+                                        JSONOutput &Output);
 };
 
 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;
 
   /// The string to be inserted. For delete operations use an
   /// empty string.
   std::string newText;
 
-  static llvm::Optional<TextEdit> parse(llvm::yaml::MappingNode *Params);
+  static llvm::Optional<TextEdit> parse(llvm::yaml::MappingNode *Params,
+                                        JSONOutput &Output);
   static std::string unparse(const TextEdit &P);
 };
 
 struct TextDocumentItem {
   /// The text document's URI.
   URI uri;
 
   /// The text document's language identifier.
   std::string languageId;
 
   /// The version number of this document (it will strictly increase after each
   int version;
 
   /// The content of the opened text document.
   std::string text;
 
-  static llvm::Optional<TextDocumentItem>
-  parse(llvm::yaml::MappingNode *Params);
+  static llvm::Optional<TextDocumentItem> parse(llvm::yaml::MappingNode *Params,
+                                                JSONOutput &Output);
 };
 
 struct DidOpenTextDocumentParams {
   /// The document that was opened.
   TextDocumentItem textDocument;
 
   /// Extension storing per-file metadata, such as compilation flags.
   llvm::Optional<Metadata> metadata;
 
   static llvm::Optional<DidOpenTextDocumentParams>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 struct DidCloseTextDocumentParams {
   /// The document that was closed.
   TextDocumentIdentifier textDocument;
 
   static llvm::Optional<DidCloseTextDocumentParams>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 struct TextDocumentContentChangeEvent {
   /// The new text of the document.
   std::string text;
 
   static llvm::Optional<TextDocumentContentChangeEvent>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 struct DidChangeTextDocumentParams {
   /// The document that did change. The version number points
   /// to the version after all provided content changes have
   /// been applied.
   TextDocumentIdentifier textDocument;
 
   /// The actual content changes.
   std::vector<TextDocumentContentChangeEvent> contentChanges;
 
   static llvm::Optional<DidChangeTextDocumentParams>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 struct FormattingOptions {
   /// Size of a tab in spaces.
   int tabSize;
 
   /// Prefer spaces over tabs.
   bool insertSpaces;
 
   static llvm::Optional<FormattingOptions>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
   static std::string unparse(const FormattingOptions &P);
 };
 
 struct DocumentRangeFormattingParams {
   /// The document to format.
   TextDocumentIdentifier textDocument;
 
   /// The range to format
   Range range;
 
   /// The format options
   FormattingOptions options;
 
   static llvm::Optional<DocumentRangeFormattingParams>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 struct DocumentOnTypeFormattingParams {
   /// The document to format.
   TextDocumentIdentifier textDocument;
 
   /// The position at which this request was sent.
   Position position;
 
   /// The character that has been typed.
   std::string ch;
 
   /// The format options.
   FormattingOptions options;
 
   static llvm::Optional<DocumentOnTypeFormattingParams>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 struct DocumentFormattingParams {
   /// The document to format.
   TextDocumentIdentifier textDocument;
 
   /// The format options
   FormattingOptions options;
 
   static llvm::Optional<DocumentFormattingParams>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 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 code. Can be omitted.
+  /// Note: Not currently used by clangd
+  // std::string code;
+
+  /// A human-readable string describing the source of this
+  /// diagnostic, e.g. 'typescript' or 'super lint'.
+  /// Note: Not currently used by clangd
+  // std::string source;
+
   /// 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);
+  static llvm::Optional<Diagnostic> parse(llvm::yaml::MappingNode *Params,
+                                          JSONOutput &Output);
 };
 
 struct CodeActionContext {
   /// An array of diagnostics.
   std::vector<Diagnostic> diagnostics;
 
   static llvm::Optional<CodeActionContext>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 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);
+  static llvm::Optional<CodeActionParams> parse(llvm::yaml::MappingNode *Params,
+                                                JSONOutput &Output);
 };
 
 struct TextDocumentPositionParams {
   /// The text document.
   TextDocumentIdentifier textDocument;
 
   /// The position inside the text document.
   Position position;
 
   static llvm::Optional<TextDocumentPositionParams>
-  parse(llvm::yaml::MappingNode *Params);
+  parse(llvm::yaml::MappingNode *Params, JSONOutput &Output);
 };
 
 /// The kind of a completion entry.
 enum class CompletionItemKind {
   Missing = 0,
   Text = 1,
   Method = 2,
   Function = 3,

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

 //===--- Protocol.cpp - Language Server Protocol Implementation -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the serialization code for the LSP structs.
 // FIXME: This is extremely repetetive and ugly. Is there a better way?
 //
 //===----------------------------------------------------------------------===//
 
 #include "Protocol.h"
+#include "JSONRPCDispatcher.h"
+
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace clang::clangd;
 
+namespace {
+void logIgnoredField(llvm::StringRef KeyValue, JSONOutput &Output) {
+  Output.log(llvm::formatv("Ignored unknown field \"{0}\"\n", KeyValue));
+}
+} // namespace
+
 URI URI::fromUri(llvm::StringRef uri) {
   URI Result;
   Result.uri = uri;
   uri.consume_front("file://");
   // Also trim authority-less URIs
   uri.consume_front("file:");
   // For Windows paths e.g. /X:
   if (uri.size() > 2 && uri[0] == '/' && uri[2] == ':')

 URI URI::parse(llvm::yaml::ScalarNode *Param) {
   llvm::SmallString<10> Storage;
   return URI::fromUri(Param->getValue(Storage));
 }
 
 std::string URI::unparse(const URI &U) { return "\"" + U.uri + "\""; }
 
 llvm::Optional<TextDocumentIdentifier>
-TextDocumentIdentifier::parse(llvm::yaml::MappingNode *Params) {
+TextDocumentIdentifier::parse(llvm::yaml::MappingNode *Params,
+                              JSONOutput &Output) {
   TextDocumentIdentifier 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;
 
     if (KeyValue == "uri") {
       Result.uri = URI::parse(Value);
     } else if (KeyValue == "version") {
       // FIXME: parse version, but only for VersionedTextDocumentIdentifiers.
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
-llvm::Optional<Position> Position::parse(llvm::yaml::MappingNode *Params) {
+llvm::Optional<Position> Position::parse(llvm::yaml::MappingNode *Params,
+                                         JSONOutput &Output) {
   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);
if (KeyValue == "line") {
         return llvm::None;
       Result.line = Val;
     } else if (KeyValue == "character") {
       long long Val;
       if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
         return llvm::None;
       Result.character = Val;
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 std::string Position::unparse(const Position &P) {
   std::string Result;
   llvm::raw_string_ostream(Result)
       << llvm::format(R"({"line": %d, "character": %d})", P.line, P.character);
   return Result;
 }
 
-llvm::Optional<Range> Range::parse(llvm::yaml::MappingNode *Params) {
+llvm::Optional<Range> Range::parse(llvm::yaml::MappingNode *Params,
+                                   JSONOutput &Output) {
   Range 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 == "start") {
-      auto Parsed = Position::parse(Value);
+      auto Parsed = Position::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.start = std::move(*Parsed);
     } else if (KeyValue == "end") {
-      auto Parsed = Position::parse(Value);
+      auto Parsed = Position::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.end = std::move(*Parsed);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 std::string Range::unparse(const Range &P) {
   std::string Result;
   llvm::raw_string_ostream(Result) << llvm::format(
       R"({"start": %s, "end": %s})", Position::unparse(P.start).c_str(),
       Position::unparse(P.end).c_str());
   return Result;
 }
 
 std::string Location::unparse(const Location &P) {
   std::string Result;
   llvm::raw_string_ostream(Result) << llvm::format(
       R"({"uri": %s, "range": %s})", URI::unparse(P.uri).c_str(),
       Range::unparse(P.range).c_str());
   return Result;
 }
 
 llvm::Optional<TextDocumentItem>
-TextDocumentItem::parse(llvm::yaml::MappingNode *Params) {
+TextDocumentItem::parse(llvm::yaml::MappingNode *Params, JSONOutput &Output) {
   TextDocumentItem 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);
for (auto &NextKeyValue : *Params) {
     } else if (KeyValue == "version") {
       long long Val;
       if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
         return llvm::None;
       Result.version = Val;
     } else if (KeyValue == "text") {
       Result.text = Value->getValue(Storage);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
-llvm::Optional<Metadata> Metadata::parse(llvm::yaml::MappingNode *Params) {
+llvm::Optional<Metadata> Metadata::parse(llvm::yaml::MappingNode *Params,
+                                         JSONOutput &Output) {
   Metadata 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 == "extraFlags") {
       auto *Seq = dyn_cast<llvm::yaml::SequenceNode>(Value);
       if (!Seq)
         return llvm::None;
       for (auto &Item : *Seq) {
         auto *Node = dyn_cast<llvm::yaml::ScalarNode>(&Item);
         if (!Node)
           return llvm::None;
         Result.extraFlags.push_back(Node->getValue(Storage));
       }
+    } else {
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
-llvm::Optional<TextEdit> TextEdit::parse(llvm::yaml::MappingNode *Params) {
+llvm::Optional<TextEdit> TextEdit::parse(llvm::yaml::MappingNode *Params,
+                                         JSONOutput &Output) {
   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;
     if (KeyValue == "range") {
       auto *Map = dyn_cast<llvm::yaml::MappingNode>(Value);
       if (!Map)
         return llvm::None;
-      auto Parsed = Range::parse(Map);
+      auto Parsed = Range::parse(Map, Output);
       if (!Parsed)
         return llvm::None;
       Result.range = std::move(*Parsed);
     } else if (KeyValue == "newText") {
       auto *Node = dyn_cast<llvm::yaml::ScalarNode>(Value);
       if (!Node)
         return llvm::None;
       Result.newText = Node->getValue(Storage);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 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;
 }
 
 llvm::Optional<DidOpenTextDocumentParams>
-DidOpenTextDocumentParams::parse(llvm::yaml::MappingNode *Params) {
+DidOpenTextDocumentParams::parse(llvm::yaml::MappingNode *Params,
+                                 JSONOutput &Output) {
   DidOpenTextDocumentParams 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 = TextDocumentItem::parse(Value);
+      auto Parsed = TextDocumentItem::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.textDocument = std::move(*Parsed);
     } else if (KeyValue == "metadata") {
-      auto Parsed = Metadata::parse(Value);
+      auto Parsed = Metadata::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.metadata = std::move(*Parsed);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 llvm::Optional<DidCloseTextDocumentParams>
-DidCloseTextDocumentParams::parse(llvm::yaml::MappingNode *Params) {
+DidCloseTextDocumentParams::parse(llvm::yaml::MappingNode *Params,
+                                  JSONOutput &Output) {
   DidCloseTextDocumentParams 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();
 
     if (KeyValue == "textDocument") {
       auto *Map = dyn_cast<llvm::yaml::MappingNode>(Value);
       if (!Map)
         return llvm::None;
-      auto Parsed = TextDocumentIdentifier::parse(Map);
+      auto Parsed = TextDocumentIdentifier::parse(Map, Output);
       if (!Parsed)
         return llvm::None;
       Result.textDocument = std::move(*Parsed);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 llvm::Optional<DidChangeTextDocumentParams>
-DidChangeTextDocumentParams::parse(llvm::yaml::MappingNode *Params) {
+DidChangeTextDocumentParams::parse(llvm::yaml::MappingNode *Params,
+                                   JSONOutput &Output) {
   DidChangeTextDocumentParams 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 == "textDocument") {
       auto *Map = dyn_cast<llvm::yaml::MappingNode>(Value);
       if (!Map)
         return llvm::None;
-      auto Parsed = TextDocumentIdentifier::parse(Map);
+      auto Parsed = TextDocumentIdentifier::parse(Map, Output);
       if (!Parsed)
         return llvm::None;
       Result.textDocument = std::move(*Parsed);
     } else if (KeyValue == "contentChanges") {
       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 = TextDocumentContentChangeEvent::parse(I);
+        auto Parsed = TextDocumentContentChangeEvent::parse(I, Output);
         if (!Parsed)
           return llvm::None;
         Result.contentChanges.push_back(std::move(*Parsed));
       }
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 llvm::Optional<TextDocumentContentChangeEvent>
-TextDocumentContentChangeEvent::parse(llvm::yaml::MappingNode *Params) {
+TextDocumentContentChangeEvent::parse(llvm::yaml::MappingNode *Params,
+                                      JSONOutput &Output) {
   TextDocumentContentChangeEvent 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 == "text") {
       Result.text = Value->getValue(Storage);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 llvm::Optional<FormattingOptions>
-FormattingOptions::parse(llvm::yaml::MappingNode *Params) {
+FormattingOptions::parse(llvm::yaml::MappingNode *Params, JSONOutput &Output) {
   FormattingOptions 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 == "tabSize") {
           Val = 1;
         else if (Str == "false")
           Val = 0;
         else
           return llvm::None;
       }
       Result.insertSpaces = Val;
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 std::string FormattingOptions::unparse(const FormattingOptions &P) {
   std::string Result;
   llvm::raw_string_ostream(Result) << llvm::format(
       R"({"tabSize": %d, "insertSpaces": %d})", P.tabSize, P.insertSpaces);
   return Result;
 }
 
 llvm::Optional<DocumentRangeFormattingParams>
-DocumentRangeFormattingParams::parse(llvm::yaml::MappingNode *Params) {
+DocumentRangeFormattingParams::parse(llvm::yaml::MappingNode *Params,
+                                     JSONOutput &Output) {
   DocumentRangeFormattingParams 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);
+      auto Parsed = TextDocumentIdentifier::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.textDocument = std::move(*Parsed);
     } else if (KeyValue == "range") {
-      auto Parsed = Range::parse(Value);
+      auto Parsed = Range::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.range = std::move(*Parsed);
     } else if (KeyValue == "options") {
-      auto Parsed = FormattingOptions::parse(Value);
+      auto Parsed = FormattingOptions::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.options = std::move(*Parsed);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 llvm::Optional<DocumentOnTypeFormattingParams>
-DocumentOnTypeFormattingParams::parse(llvm::yaml::MappingNode *Params) {
+DocumentOnTypeFormattingParams::parse(llvm::yaml::MappingNode *Params,
+                                      JSONOutput &Output) {
   DocumentOnTypeFormattingParams 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 == "ch") {
       auto *ScalarValue =
           dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
       if (!ScalarValue)
         return llvm::None;
       llvm::SmallString<10> Storage;
       Result.ch = ScalarValue->getValue(Storage);
       continue;
     }
 
     auto *Value =
         dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
     if (KeyValue == "textDocument") {
-      auto Parsed = TextDocumentIdentifier::parse(Value);
+      auto Parsed = TextDocumentIdentifier::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.textDocument = std::move(*Parsed);
     } else if (KeyValue == "position") {
-      auto Parsed = Position::parse(Value);
+      auto Parsed = Position::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.position = std::move(*Parsed);
     } else if (KeyValue == "options") {
-      auto Parsed = FormattingOptions::parse(Value);
+      auto Parsed = FormattingOptions::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.options = std::move(*Parsed);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 llvm::Optional<DocumentFormattingParams>
-DocumentFormattingParams::parse(llvm::yaml::MappingNode *Params) {
+DocumentFormattingParams::parse(llvm::yaml::MappingNode *Params,
+                                JSONOutput &Output) {
   DocumentFormattingParams 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);
+      auto Parsed = TextDocumentIdentifier::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.textDocument = std::move(*Parsed);
     } else if (KeyValue == "options") {
-      auto Parsed = FormattingOptions::parse(Value);
+      auto Parsed = FormattingOptions::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.options = std::move(*Parsed);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
-llvm::Optional<Diagnostic> Diagnostic::parse(llvm::yaml::MappingNode *Params) {
+llvm::Optional<Diagnostic> Diagnostic::parse(llvm::yaml::MappingNode *Params,
+                                             JSONOutput &Output) {
   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);
+      auto Parsed = Range::parse(Value, Output);
       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 == "code") {
+      // Not currently used
+    } else if (KeyValue == "source") {
+      // Not currently used
     } 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;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 llvm::Optional<CodeActionContext>
-CodeActionContext::parse(llvm::yaml::MappingNode *Params) {
+CodeActionContext::parse(llvm::yaml::MappingNode *Params, JSONOutput &Output) {
   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);
+        auto Parsed = Diagnostic::parse(I, Output);
         if (!Parsed)
           return llvm::None;
         Result.diagnostics.push_back(std::move(*Parsed));
       }
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 llvm::Optional<CodeActionParams>
-CodeActionParams::parse(llvm::yaml::MappingNode *Params) {
+CodeActionParams::parse(llvm::yaml::MappingNode *Params, JSONOutput &Output) {
   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);
+      auto Parsed = TextDocumentIdentifier::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.textDocument = std::move(*Parsed);
     } else if (KeyValue == "range") {
-      auto Parsed = Range::parse(Value);
+      auto Parsed = Range::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.range = std::move(*Parsed);
     } else if (KeyValue == "context") {
-      auto Parsed = CodeActionContext::parse(Value);
+      auto Parsed = CodeActionContext::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.context = std::move(*Parsed);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 llvm::Optional<TextDocumentPositionParams>
-TextDocumentPositionParams::parse(llvm::yaml::MappingNode *Params) {
+TextDocumentPositionParams::parse(llvm::yaml::MappingNode *Params,
+                                  JSONOutput &Output) {
   TextDocumentPositionParams 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)
       continue;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "textDocument") {
-      auto Parsed = TextDocumentIdentifier::parse(Value);
+      auto Parsed = TextDocumentIdentifier::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.textDocument = std::move(*Parsed);
     } else if (KeyValue == "position") {
-      auto Parsed = Position::parse(Value);
+      auto Parsed = Position::parse(Value, Output);
       if (!Parsed)
         return llvm::None;
       Result.position = std::move(*Parsed);
     } else {
-      return llvm::None;
+      logIgnoredField(KeyValue, Output);
     }
   }
   return Result;
 }
 
 std::string CompletionItem::unparse(const CompletionItem &CI) {
   std::string Result = "{";
   llvm::raw_string_ostream Os(Result);

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

private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct TextDocumentDidOpenHandler : Handler {
   TextDocumentDidOpenHandler(JSONOutput &Output, ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleNotification(llvm::yaml::MappingNode *Params) override {
-    auto DOTDP = DidOpenTextDocumentParams::parse(Params);
+    auto DOTDP = DidOpenTextDocumentParams::parse(Params, Output);
     if (!DOTDP) {
       Output.log("Failed to decode DidOpenTextDocumentParams!\n");
       return;
     }
     Callbacks.onDocumentDidOpen(*DOTDP, Output);
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct TextDocumentDidChangeHandler : Handler {
   TextDocumentDidChangeHandler(JSONOutput &Output, ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleNotification(llvm::yaml::MappingNode *Params) override {
-    auto DCTDP = DidChangeTextDocumentParams::parse(Params);
+    auto DCTDP = DidChangeTextDocumentParams::parse(Params, Output);
     if (!DCTDP || DCTDP->contentChanges.size() != 1) {
       Output.log("Failed to decode DidChangeTextDocumentParams!\n");
       return;
     }
 
     Callbacks.onDocumentDidChange(*DCTDP, Output);
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct TextDocumentDidCloseHandler : Handler {
   TextDocumentDidCloseHandler(JSONOutput &Output, ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleNotification(llvm::yaml::MappingNode *Params) override {
-    auto DCTDP = DidCloseTextDocumentParams::parse(Params);
+    auto DCTDP = DidCloseTextDocumentParams::parse(Params, Output);
     if (!DCTDP) {
       Output.log("Failed to decode DidCloseTextDocumentParams!\n");
       return;
     }
 
     Callbacks.onDocumentDidClose(*DCTDP, Output);
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct TextDocumentOnTypeFormattingHandler : Handler {
   TextDocumentOnTypeFormattingHandler(JSONOutput &Output,
                                       ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
-    auto DOTFP = DocumentOnTypeFormattingParams::parse(Params);
+    auto DOTFP = DocumentOnTypeFormattingParams::parse(Params, Output);
     if (!DOTFP) {
       Output.log("Failed to decode DocumentOnTypeFormattingParams!\n");
       return;
     }
 
     Callbacks.onDocumentOnTypeFormatting(*DOTFP, ID, Output);
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct TextDocumentRangeFormattingHandler : Handler {
   TextDocumentRangeFormattingHandler(JSONOutput &Output,
                                      ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
-    auto DRFP = DocumentRangeFormattingParams::parse(Params);
+    auto DRFP = DocumentRangeFormattingParams::parse(Params, Output);
     if (!DRFP) {
       Output.log("Failed to decode DocumentRangeFormattingParams!\n");
       return;
     }
 
     Callbacks.onDocumentRangeFormatting(*DRFP, ID, Output);
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct TextDocumentFormattingHandler : Handler {
   TextDocumentFormattingHandler(JSONOutput &Output,
                                 ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
-    auto DFP = DocumentFormattingParams::parse(Params);
+    auto DFP = DocumentFormattingParams::parse(Params, Output);
     if (!DFP) {
       Output.log("Failed to decode DocumentFormattingParams!\n");
       return;
     }
 
     Callbacks.onDocumentFormatting(*DFP, ID, Output);
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct CodeActionHandler : Handler {
   CodeActionHandler(JSONOutput &Output, ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
-    auto CAP = CodeActionParams::parse(Params);
+    auto CAP = CodeActionParams::parse(Params, Output);
     if (!CAP) {
       Output.log("Failed to decode CodeActionParams!\n");
       return;
     }
 
     Callbacks.onCodeAction(*CAP, ID, Output);
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct CompletionHandler : Handler {
   CompletionHandler(JSONOutput &Output, ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
-    auto TDPP = TextDocumentPositionParams::parse(Params);
+    auto TDPP = TextDocumentPositionParams::parse(Params, Output);
     if (!TDPP) {
       Output.log("Failed to decode TextDocumentPositionParams!\n");
       return;
     }
 
     Callbacks.onCompletion(*TDPP, ID, Output);
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct GotoDefinitionHandler : Handler {
   GotoDefinitionHandler(JSONOutput &Output, ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
-    auto TDPP = TextDocumentPositionParams::parse(Params);
+    auto TDPP = TextDocumentPositionParams::parse(Params, Output);
     if (!TDPP) {
       Output.log("Failed to decode TextDocumentPositionParams!\n");
       return;
     }
 
     Callbacks.onGoToDefinition(*TDPP, ID, Output);
   }
 

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

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