[clangd] Switch from YAMLParser to JSONExpr

[sammccall]

Summary

• Converted Protocol.h parse() functions to take JSON::Expr. These no longer detect and log unknown fields, as this is not that useful and no longer free. I haven't changed the error handling too much: fields that were treated as optional before are still optional, even when it's wrong. Exception: object properties with the wrong type are now ignored.
• Made JSONRPCDispatcher parse using json::parse
• The bug where 'method' must come before 'params' in the stream is fixed as a side-effect. (And the same bug in executeCommand).
• Some parser crashers fixed as a side effect. e.g. https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=3890
• The debug stream now prettyprints the input messages with --pretty.
• Request params are attached to traces when tracing is enabled.
• Fixed some bugs in tests (errors tolerated by YAMLParser, and off-by-ones in Content-Length that our null-termination was masking)
• Fixed a random double-escape bug in ClangdLSPServer (it was our last use of YAMLParser!)

[sammccall]

Oops, Eric is most likely to have this stuff in cache :-)
Sorry this is huge and ugly, -500 lines though!

I think the Protocol code could be a lot tighter (there's still a lot of repeated "is this an object", and "if this property exists parse it as type X and store it in field Y, else fail". (The kind of stuff YamlIO is good at).
I wanted to stick to a pretty literal translation first, and maybe later find a way to clean it up further. Hope that's OK!

[ioeric]

clangd/JSONRPCDispatcher.cpp

221

Use llvm::toString?

clangd/JSONRPCDispatcher.h

47

It seems that we are piggybacking a state of clangd with JSONOutput. It might make sense to store the option in clangd (or the dispatcher?) and pass it via writeMessage, but what you have is also fine if it saves trouble :)

[sammccall]

Use llvm::toString

[sammccall]

clangd/JSONRPCDispatcher.h

47

Yeah, this isn't great. In the short term I don't think it does much harm. Longer-term we'll revisit logging organization as part of RequestContext that Ilya's working on.

[ioeric]

lg

clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onRename(Ctx C, RenameParams &Params) {
   if (!Replacements) {
     C.replyError(ErrorCode::InternalError,
                  llvm::toString(Replacements.takeError()));
     return;
   }
   std::string Code = Server.getDocument(File);
   std::vector<TextEdit> Edits = replacementsToEdits(Code, *Replacements);
   WorkspaceEdit WE;
-  WE.changes = {{llvm::yaml::escape(Params.textDocument.uri.uri), Edits}};
+  WE.changes = {{Params.textDocument.uri.uri, Edits}};
   C.reply(WorkspaceEdit::unparse(WE));
 }
 
 void ClangdLSPServer::onDocumentDidClose(Ctx C,
                                          DidCloseTextDocumentParams &Params) {
   Server.removeDocument(Params.textDocument.uri.file);
 }
 
: Out(Out), CDB(/*Logger=*/Out, std::move(CompileCommandsDir)),
              StorePreamblesInMemory, CCOpts,
              /*Logger=*/Out, ResourceDir) {}
 
 bool ClangdLSPServer::run(std::istream &In) {
   assert(!IsDone && "Run was called before");
 
   // Set up JSONRPCDispatcher.
   JSONRPCDispatcher Dispatcher(
-      [](RequestContext Ctx, llvm::yaml::MappingNode *Params) {
+      [](RequestContext Ctx, const json::Expr &Params) {
         Ctx.replyError(ErrorCode::MethodNotFound, "method not found");
       });
   registerCallbackHandlers(Dispatcher, Out, /*Callbacks=*/*this);
 
   // Run the Language Server loop.
   runLanguageServerLoop(In, Out, Dispatcher, IsDone);
 
   // Make sure IsDone is set to true after this method exits to ensure assertion

clangd/JSONExpr.h

if (LLVM_LIKELY(Type == T_Boolean))
       return as<bool>();
     return llvm::None;
   }
   llvm::Optional<double> asNumber() const {
     if (LLVM_LIKELY(Type == T_Number))
       return as<double>();
     return llvm::None;
   }
+  llvm::Optional<int64_t> asInteger() const {
+    if (LLVM_LIKELY(Type == T_Number)) {
+      double D = as<double>();
+      if (LLVM_LIKELY(std::modf(D, &D) == 0 &&
+                      D >= std::numeric_limits<int64_t>::min() &&
+                      D <= std::numeric_limits<int64_t>::max()))
+        return D;
+    }
+    return llvm::None;
+  }
   llvm::Optional<llvm::StringRef> asString() const {
     if (Type == T_String)
       return llvm::StringRef(as<std::string>());
     if (LLVM_LIKELY(Type == T_StringRef))
       return as<llvm::StringRef>();
     return llvm::None;
   }
   const ObjectExpr *asObject() const {
llvm::Optional<bool> getBoolean(const ObjectKey &K) const {
         return V->asBoolean();
       return llvm::None;
     }
     llvm::Optional<double> getNumber(const ObjectKey &K) const {
       if (auto *V = get(K))
         return V->asNumber();
       return llvm::None;
     }
+    llvm::Optional<int64_t> getInteger(const ObjectKey &K) const {
+      if (auto *V = get(K))
+        return V->asInteger();
+      return llvm::None;
+    }
     llvm::Optional<llvm::StringRef> getString(const ObjectKey &K) const {
       if (auto *V = get(K))
         return V->asString();
       return llvm::None;
     }
     const ObjectExpr *getObject(const ObjectKey &K) const {
       if (auto *V = get(K))
         return V->asObject();
llvm::Optional<std::nullptr_t> getNull(size_t I) const {
       return (*this)[I].asNull();
     }
     llvm::Optional<bool> getBoolean(size_t I) const {
       return (*this)[I].asBoolean();
     }
     llvm::Optional<double> getNumber(size_t I) const {
       return (*this)[I].asNumber();
     }
+    llvm::Optional<int64_t> getInteger(size_t I) const {
+      return (*this)[I].asInteger();
+    }
     llvm::Optional<llvm::StringRef> getString(size_t I) const {
       return (*this)[I].asString();
     }
     const ObjectExpr *getObject(size_t I) const {
       return (*this)[I].asObject();
     }
     ObjectExpr *getObject(size_t I) { return (*this)[I].asObject(); }
     const ArrayExpr *getArray(size_t I) const { return (*this)[I].asArray(); }

clangd/JSONRPCDispatcher.h

 
 #include "JSONExpr.h"
 #include "Logger.h"
 #include "Protocol.h"
 #include "Trace.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
-#include "llvm/Support/YAMLParser.h"
 #include <iosfwd>
 #include <mutex>
 
 namespace clang {
 namespace clangd {
 
 /// Encapsulates output and logs streams and provides thread-safe access to
 /// them.
 class JSONOutput : public Logger {
 public:
   JSONOutput(llvm::raw_ostream &Outs, llvm::raw_ostream &Logs,
              llvm::raw_ostream *InputMirror = nullptr, bool Pretty = false)
-      : Outs(Outs), Logs(Logs), InputMirror(InputMirror), Pretty(Pretty) {}
+      : Pretty(Pretty), Outs(Outs), Logs(Logs), InputMirror(InputMirror) {}
 
   /// Emit a JSONRPC message.
   void writeMessage(const json::Expr &Result);
 
   /// Write to the logging stream.
   /// No newline is implicitly added. (TODO: we should fix this!)
   void log(const Twine &Message) override;
 
   /// Mirror \p Message into InputMirror stream. Does nothing if InputMirror is
   /// null.
   /// Unlike other methods of JSONOutput, mirrorInput is not thread-safe.
   void mirrorInput(const Twine &Message);
 
+  // Whether output should be pretty-printed.
+  const bool Pretty;
+
 private:
   llvm::raw_ostream &Outs;
   llvm::raw_ostream &Logs;
   llvm::raw_ostream *InputMirror;
-  bool Pretty;
 
   std::mutex StreamMutex;
 };
 
 /// Context object passed to handlers to allow replies.
 class RequestContext {
 public:
   RequestContext(JSONOutput &Out, StringRef Method,
private:
   std::unique_ptr<trace::Span> Tracer;
 };
 
 /// Main JSONRPC entry point. This parses the JSONRPC "header" and calls the
 /// registered Handler for the method received.
 class JSONRPCDispatcher {
 public:
   // A handler responds to requests for a particular method name.
-  using Handler =
-      std::function<void(RequestContext, llvm::yaml::MappingNode *)>;
+  using Handler = std::function<void(RequestContext, const json::Expr &)>;
 
   /// Create a new JSONRPCDispatcher. UnknownHandler is called when an unknown
   /// method is received.
   JSONRPCDispatcher(Handler UnknownHandler)
       : UnknownHandler(std::move(UnknownHandler)) {}
 
   /// Registers a Handler for the specified Method.
   void registerHandler(StringRef Method, Handler H);
 
   /// Parses a JSONRPC message and calls the Handler for it.
-  bool call(StringRef Content, JSONOutput &Out) const;
+  bool call(const json::Expr &Message, JSONOutput &Out) const;
 
 private:
   llvm::StringMap<Handler> Handlers;
   Handler UnknownHandler;
 };
 
 /// Parses input queries from LSP client (coming from \p In) and runs call
 /// method of \p Dispatcher for each query.

clangd/JSONRPCDispatcher.cpp

 //===--- JSONRPCDispatcher.cpp - Main JSON parser entry point -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "JSONRPCDispatcher.h"
 #include "JSONExpr.h"
 #include "ProtocolHandlers.h"
 #include "Trace.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/YAMLParser.h"
 #include <istream>
 
 using namespace clang;
 using namespace clangd;
 
 void JSONOutput::writeMessage(const json::Expr &Message) {
   std::string S;
   llvm::raw_string_ostream OS(S);
void RequestContext::call(StringRef Method, json::Expr &&Params) {
   });
 }
 
 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::Optional<json::Expr> ID,
-            llvm::yaml::MappingNode *Params,
-            const JSONRPCDispatcher::Handler &UnknownHandler, JSONOutput &Out) {
-  llvm::SmallString<64> MethodStorage;
-  llvm::StringRef MethodStr = Method->getValue(MethodStorage);
-  auto I = Handlers.find(MethodStr);
-  auto &Handler = I != Handlers.end() ? I->second : UnknownHandler;
-  Handler(RequestContext(Out, MethodStr, std::move(ID)), Params);
-}
-
-bool JSONRPCDispatcher::call(StringRef Content, JSONOutput &Out) const {
-  llvm::SourceMgr SM;
-  llvm::yaml::Stream YAMLStream(Content, SM);
-
-  auto Doc = YAMLStream.begin();
-  if (Doc == YAMLStream.end())
+bool JSONRPCDispatcher::call(const json::Expr &Message, JSONOutput &Out) const {
+  // Message must be an object with "jsonrpc":"2.0".
+  auto *Object = Message.asObject();
+  if (!Object || Object->getString("jsonrpc") != Optional<StringRef>("2.0"))
     return false;
-
-  auto *Object = dyn_cast_or_null<llvm::yaml::MappingNode>(Doc->getRoot());
-  if (!Object)
-    return false;
-
-  llvm::yaml::ScalarNode *Version = nullptr;
-  llvm::yaml::ScalarNode *Method = nullptr;
-  llvm::yaml::MappingNode *Params = nullptr;
+  // ID may be any JSON value. If absent, this is a notification.
   llvm::Optional<json::Expr> ID;
-  for (auto &NextKeyValue : *Object) {
-    auto *KeyString =
-        dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
-    if (!KeyString)
-      return false;
-
-    llvm::SmallString<10> KeyStorage;
-    StringRef KeyValue = KeyString->getValue(KeyStorage);
-    llvm::yaml::Node *Value = NextKeyValue.getValue();
-    if (!Value)
-      return false;
-
-    if (KeyValue == "jsonrpc") {
-      // This should be "2.0". Always.
-      Version = dyn_cast<llvm::yaml::ScalarNode>(Value);
-      if (!Version || Version->getRawValue() != "\"2.0\"")
-        return false;
-    } else if (KeyValue == "method") {
-      Method = dyn_cast<llvm::yaml::ScalarNode>(Value);
-    } else if (KeyValue == "id") {
-      // ID may be either a string or a number.
-      if (auto *IdNode = dyn_cast<llvm::yaml::ScalarNode>(Value)) {
-        llvm::SmallString<32> S;
-        llvm::StringRef V = IdNode->getValue(S);
-        if (IdNode->getRawValue().startswith("\"")) {
-          ID.emplace(V.str());
-        } else {
-          double D;
-          // FIXME: this is locale-sensitive.
-          if (llvm::to_float(V, D))
-            ID.emplace(D);
-        }
-      }
-    } else if (KeyValue == "params") {
-      if (!Method)
-        return false;
-      // We have to interleave the call of the function here, otherwise the
-      // YAMLParser will die because it can't go backwards. This is unfortunate
-      // because it will break clients that put the id after params. A possible
-      // fix would be to split the parsing and execution phases.
-      Params = dyn_cast<llvm::yaml::MappingNode>(Value);
-      callHandler(Handlers, Method, std::move(ID), Params, UnknownHandler, Out);
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  // In case there was a request with no params, call the handler on the
-  // leftovers.
-  if (!Method)
-    return false;
-  callHandler(Handlers, Method, std::move(ID), nullptr, UnknownHandler, Out);
+  if (auto *I = Object->get("id"))
+    ID = std::move(*I);
+  // Method must be given.
+  auto Method = Object->getString("method");
+  // Params should be given, use null if not.
+  json::Expr Params = nullptr;
+  if (auto *P = Object->get("params"))
+    Params = std::move(*P);
 
+  auto I = Handlers.find(*Method);
+  auto &Handler = I != Handlers.end() ? I->second : UnknownHandler;
+  RequestContext Ctx(Out, *Method, std::move(ID));
+  SPAN_ATTACH(Ctx.tracer(), "Params", Params);
+  Handler(std::move(Ctx), std::move(Params));
   return true;
 }
 
 void clangd::runLanguageServerLoop(std::istream &In, JSONOutput &Out,
                                    JSONRPCDispatcher &Dispatcher,
                                    bool &IsDone) {
   while (In.good()) {
     // A Language Server Protocol message starts with a set of HTTP headers,
while (In.good()) {
       // the resulting Line.
       // Note that '\r' is part of Line, so we don't need to mirror it
       // separately.
       if (!In.eof())
         Out.mirrorInput("\n");
 
       llvm::StringRef LineRef(Line);
 
-      // We allow YAML-style comments in headers. Technically this isn't part
+      // We allow comments in headers. Technically this isn't part
       // of the LSP specification, but makes writing tests easier.
       if (LineRef.startswith("#"))
         continue;
 
       // Content-Type is a specified header, but does nothing.
       // Content-Length is a mandatory header. It specifies the length of the
       // following JSON.
       // It is unspecified what sequence headers must be supplied in, so we
while (In.good()) {
     if (ContentLength > 1 << 30) { // 1024M
       In.ignore(ContentLength);
       Out.log("Skipped overly large message of " + Twine(ContentLength) +
               " bytes.\n");
       continue;
     }
 
     if (ContentLength > 0) {
-      std::vector<char> JSON(ContentLength + 1, '\0');
+      std::vector<char> JSON(ContentLength);
       llvm::StringRef JSONRef;
       {
-        // Now read the JSON. Insert a trailing null byte as required by the
-        // YAML parser.
         In.read(JSON.data(), ContentLength);
         Out.mirrorInput(StringRef(JSON.data(), In.gcount()));
 
         // If the stream is aborted before we read ContentLength bytes, In
         // will have eofbit and failbit set.
         if (!In) {
           Out.log("Input was aborted. Read only " +
                   std::to_string(In.gcount()) + " bytes of expected " +
                   std::to_string(ContentLength) + ".\n");
           break;
         }
 
         JSONRef = StringRef(JSON.data(), ContentLength);
       }
 
-      // Log the message.
-      Out.log("<-- " + JSONRef + "\n");
-
+      if (auto Doc = json::parse(JSONRef)) {
+        // Log the formatted message.
+        Out.log(llvm::formatv(Out.Pretty ? "<-- {0:2}\n" : "<-- {0}\n", *Doc));
         // Finally, execute the action for this JSON message.
-      if (!Dispatcher.call(JSONRef, Out))
+        if (!Dispatcher.call(*Doc, Out))
           Out.log("JSON dispatch failed!\n");
+      } else {
+        // Parse error. Log the raw message.
+        Out.log("<-- " + JSONRef + "\n");
+        Out.log(llvm::Twine("JSON parse error: ") +
+                llvm::toString(Doc.takeError()) + "\n");
+      }
 
       // If we're done, exit the loop.
       if (IsDone)
         break;
     } else {
       Out.log("Warning: Missing Content-Length header, or message has zero "
               "length.\n");
     }
   }
 }

clangd/Protocol.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
 
 #include "JSONExpr.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/Support/YAMLParser.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
-class Logger;
-
 enum class ErrorCode {
   // Defined by JSON RPC.
   ParseError = -32700,
   InvalidRequest = -32600,
   MethodNotFound = -32601,
   InvalidParams = -32602,
   InternalError = -32603,
 
   ServerNotInitialized = -32002,
   UnknownErrorCode = -32001,
 
   // Defined by the protocol.
   RequestCancelled = -32800,
 };
 
 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);
+  static URI parse(llvm::StringRef U) { return fromUri(U); }
   static json::Expr unparse(const URI &U);
 
   friend bool operator==(const URI &LHS, const URI &RHS) {
     return LHS.uri == RHS.uri;
   }
 
   friend bool operator!=(const URI &LHS, const URI &RHS) {
     return !(LHS == RHS);
   }
 
   friend bool operator<(const URI &LHS, const URI &RHS) {
     return LHS.uri < RHS.uri;
   }
 };
 
 struct TextDocumentIdentifier {
   /// The text document's URI.
   URI uri;
 
-  static llvm::Optional<TextDocumentIdentifier>
-  parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger);
+  static llvm::Optional<TextDocumentIdentifier> parse(const json::Expr &Params);
 };
 
 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,
-                                        clangd::Logger &Logger);
+  static llvm::Optional<Position> parse(const json::Expr &Params);
   static json::Expr 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,
-                                     clangd::Logger &Logger);
+  static llvm::Optional<Range> parse(const json::Expr &Params);
   static json::Expr unparse(const Range &P);
 };
 
 struct Location {
   /// The text document's URI.
   URI uri;
   Range range;
 
struct Location {
   }
 
   static json::Expr unparse(const Location &P);
 };
 
 struct Metadata {
   std::vector<std::string> extraFlags;
 
-  static llvm::Optional<Metadata> parse(llvm::yaml::MappingNode *Params,
-                                        clangd::Logger &Logger);
+  static llvm::Optional<Metadata> parse(const json::Expr &Params);
 };
 
 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,
-                                        clangd::Logger &Logger);
+  static llvm::Optional<TextEdit> parse(const json::Expr &Params);
   static json::Expr 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,
-                                                clangd::Logger &Logger);
+  static llvm::Optional<TextDocumentItem> parse(const json::Expr &Params);
 };
 
 enum class TraceLevel {
   Off = 0,
   Messages = 1,
   Verbose = 2,
 };
 
 struct NoParams {
-  static llvm::Optional<NoParams> parse(llvm::yaml::MappingNode *Params,
-                                        Logger &Logger) {
+  static llvm::Optional<NoParams> parse(const json::Expr &Params) {
     return NoParams{};
   }
 };
 using ShutdownParams = NoParams;
 using ExitParams = NoParams;
 
 struct InitializeParams {
   /// The process Id of the parent process that started
struct InitializeParams {
   // initializationOptions?: any;
 
   /// The capabilities provided by the client (editor or tool)
   /// Note: Not currently used by clangd
   // ClientCapabilities capabilities;
 
   /// The initial trace setting. If omitted trace is disabled ('off').
   llvm::Optional<TraceLevel> trace;
-  static llvm::Optional<InitializeParams> parse(llvm::yaml::MappingNode *Params,
-                                                clangd::Logger &Logger);
+  static llvm::Optional<InitializeParams> parse(const json::Expr &Params);
 };
 
 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, clangd::Logger &Logger);
+  parse(const json::Expr &Params);
 };
 
 struct DidCloseTextDocumentParams {
   /// The document that was closed.
   TextDocumentIdentifier textDocument;
 
   static llvm::Optional<DidCloseTextDocumentParams>
-  parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger);
+  parse(const json::Expr &Params);
 };
 
 struct TextDocumentContentChangeEvent {
   /// The new text of the document.
   std::string text;
 
   static llvm::Optional<TextDocumentContentChangeEvent>
-  parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger);
+  parse(const json::Expr &Params);
 };
 
 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, clangd::Logger &Logger);
+  parse(const json::Expr &Params);
 };
 
 enum class FileChangeType {
   /// The file got created.
   Created = 1,
   /// The file got changed.
   Changed = 2,
   /// The file got deleted.
   Deleted = 3
 };
 
 struct FileEvent {
   /// The file's URI.
   URI uri;
   /// The change type.
   FileChangeType type;
 
-  static llvm::Optional<FileEvent> parse(llvm::yaml::MappingNode *Params,
-                                         clangd::Logger &Logger);
+  static llvm::Optional<FileEvent> parse(const json::Expr &Params);
 };
 
 struct DidChangeWatchedFilesParams {
   /// The actual file events.
   std::vector<FileEvent> changes;
 
   static llvm::Optional<DidChangeWatchedFilesParams>
-  parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger);
+  parse(const json::Expr &Params);
 };
 
 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, clangd::Logger &Logger);
+  static llvm::Optional<FormattingOptions> parse(const json::Expr &Params);
   static json::Expr 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, clangd::Logger &Logger);
+  parse(const json::Expr &Params);
 };
 
 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, clangd::Logger &Logger);
+  parse(const json::Expr &Params);
 };
 
 struct DocumentFormattingParams {
   /// The document to format.
   TextDocumentIdentifier textDocument;
 
   /// The format options
   FormattingOptions options;
 
   static llvm::Optional<DocumentFormattingParams>
-  parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger);
+  parse(const json::Expr &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.
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,
-                                          clangd::Logger &Logger);
+  static llvm::Optional<Diagnostic> parse(const json::Expr &Params);
 };
 
 struct CodeActionContext {
   /// An array of diagnostics.
   std::vector<Diagnostic> diagnostics;
 
-  static llvm::Optional<CodeActionContext>
-  parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger);
+  static llvm::Optional<CodeActionContext> parse(const json::Expr &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,
-                                                clangd::Logger &Logger);
+  static llvm::Optional<CodeActionParams> parse(const json::Expr &Params);
 };
 
 struct WorkspaceEdit {
   /// Holds changes to existing resources.
   llvm::Optional<std::map<std::string, std::vector<TextEdit>>> changes;
 
   /// Note: "documentChanges" is not currently used because currently there is
   /// no support for versioned edits.
 
-  static llvm::Optional<WorkspaceEdit> parse(llvm::yaml::MappingNode *Params,
-                                             clangd::Logger &Logger);
+  static llvm::Optional<WorkspaceEdit> parse(const json::Expr &Params);
   static json::Expr 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);
+  static llvm::Optional<ExecuteCommandParams> parse(const json::Expr &Params);
 };
 
 struct ApplyWorkspaceEditParams {
   WorkspaceEdit edit;
   static json::Expr unparse(const ApplyWorkspaceEditParams &Params);
 };
 
 struct TextDocumentPositionParams {
   /// The text document.
   TextDocumentIdentifier textDocument;
 
   /// The position inside the text document.
   Position position;
 
   static llvm::Optional<TextDocumentPositionParams>
-  parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger);
+  parse(const json::Expr &Params);
 };
 
 /// The kind of a completion entry.
 enum class CompletionItemKind {
   Missing = 0,
   Text = 1,
   Method = 2,
   Function = 3,
struct RenameParams {
   TextDocumentIdentifier textDocument;
 
   /// The position at which this request was sent.
   Position position;
 
   /// The new name of the symbol.
   std::string newName;
 
-  static llvm::Optional<RenameParams> parse(llvm::yaml::MappingNode *Params,
-                                            clangd::Logger &Logger);
+  static llvm::Optional<RenameParams> parse(const json::Expr &Params);
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

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 "Logger.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;
 using namespace clang::clangd;
 
-namespace {
-void logIgnoredField(llvm::StringRef KeyValue, clangd::Logger &Logger) {
-  Logger.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::fromFile(llvm::StringRef file) {
   // For Windows paths e.g. X:
   if (file.size() > 1 && file[1] == ':')
     Result.uri += "/";
   // Make sure that uri paths are with posix separators
   Result.uri += path::convert_to_slash(file, path::Style::posix);
   return Result;
 }
 
-URI URI::parse(llvm::yaml::ScalarNode *Param) {
-  llvm::SmallString<10> Storage;
-  return URI::fromUri(Param->getValue(Storage));
-}
-
 json::Expr URI::unparse(const URI &U) { return U.uri; }
 
 llvm::Optional<TextDocumentIdentifier>
-TextDocumentIdentifier::parse(llvm::yaml::MappingNode *Params,
-                              clangd::Logger &Logger) {
-  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;
+TextDocumentIdentifier::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
 
-    if (KeyValue == "uri") {
-      Result.uri = URI::parse(Value);
-    } else if (KeyValue == "version") {
-      // FIXME: parse version, but only for VersionedTextDocumentIdentifiers.
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
-  }
+  TextDocumentIdentifier Result;
+  if (auto U = O->getString("uri"))
+    Result.uri = URI::parse(*U);
+  // FIXME: parse 'version', but only for VersionedTextDocumentIdentifiers.
   return Result;
 }
 
-llvm::Optional<Position> Position::parse(llvm::yaml::MappingNode *Params,
-                                         clangd::Logger &Logger) {
+llvm::Optional<Position> Position::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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;
-      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 {
-      logIgnoredField(KeyValue, Logger);
-    }
-  }
+  if (auto L = O->getInteger("line"))
+    Result.line = *L;
+  if (auto C = O->getInteger("character"))
+    Result.character = *C;
   return Result;
 }
 
 json::Expr Position::unparse(const Position &P) {
   return json::obj{
       {"line", P.line},
       {"character", P.character},
   };
 }
 
-llvm::Optional<Range> Range::parse(llvm::yaml::MappingNode *Params,
-                                   clangd::Logger &Logger) {
+llvm::Optional<Range> Range::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-      if (!Parsed)
-        return llvm::None;
-      Result.start = std::move(*Parsed);
-    } else if (KeyValue == "end") {
-      auto Parsed = Position::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
-      Result.end = std::move(*Parsed);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+  if (auto *S = O->get("start")) {
+    if (auto P = Position::parse(*S))
+      Result.start = std::move(*P);
+    else
+      return None;
+  if (auto *E = O->get("end")) {
+    if (auto P = Position::parse(*E))
+      Result.end = std::move(*P);
+    else
+      return None;
   }
   return Result;
 }
 
 json::Expr Range::unparse(const Range &P) {
   return json::obj{
       {"start", P.start},
       {"end", P.end},
   };
 }
 
 json::Expr Location::unparse(const Location &P) {
   return json::obj{
       {"uri", P.uri},
       {"range", P.range},
   };
 }
 
 llvm::Optional<TextDocumentItem>
-TextDocumentItem::parse(llvm::yaml::MappingNode *Params,
-                        clangd::Logger &Logger) {
-  TextDocumentItem Result;
-  for (auto &NextKeyValue : *Params) {
-    auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
-    if (!KeyString)
-      return llvm::None;
+TextDocumentItem::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return 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 == "uri") {
-      Result.uri = URI::parse(Value);
-    } else if (KeyValue == "languageId") {
-      Result.languageId = Value->getValue(Storage);
-    } 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 {
-      logIgnoredField(KeyValue, Logger);
-    }
-  }
+  TextDocumentItem Result;
+  if (auto U = O->getString("uri"))
+    Result.uri = URI::parse(*U);
+  if (auto L = O->getString("languageId"))
+    Result.languageId = *L;
+  if (auto V = O->getInteger("version"))
+    Result.version = *V;
+  if (auto T = O->getString("text"))
+    Result.text = *T;
   return Result;
 }
 
-llvm::Optional<Metadata> Metadata::parse(llvm::yaml::MappingNode *Params,
-                                         clangd::Logger &Logger) {
-  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::Optional<Metadata> Metadata::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
 
-    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, Logger);
-    }
+  Metadata Result;
+  if (auto *Flags = O->getArray("extraFlags"))
+    for (auto &F : *Flags) {
+      if (auto S = F.asString())
+        Result.extraFlags.push_back(*S);
+      else
     }
   return Result;
 }
 
-llvm::Optional<TextEdit> TextEdit::parse(llvm::yaml::MappingNode *Params,
-                                         clangd::Logger &Logger) {
+llvm::Optional<TextEdit> TextEdit::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-      if (!Parsed)
-        return llvm::None;
+  if (auto *R = O->get("range")) {
+    if (auto Parsed = Range::parse(*R))
       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 {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+      return llvm::None;
   }
+  if (auto T = O->getString("newText"))
+    Result.newText = *T;
   return Result;
 }
 
 json::Expr TextEdit::unparse(const TextEdit &P) {
   return json::obj{
       {"range", P.range},
       {"newText", P.newText},
   };
 }
 
 namespace {
-TraceLevel getTraceLevel(llvm::StringRef TraceLevelStr,
-                         clangd::Logger &Logger) {
+TraceLevel getTraceLevel(llvm::StringRef TraceLevelStr) {
   if (TraceLevelStr == "off")
     return TraceLevel::Off;
   else if (TraceLevelStr == "messages")
     return TraceLevel::Messages;
   else if (TraceLevelStr == "verbose")
     return TraceLevel::Verbose;
-
-  Logger.log(llvm::formatv("Unknown trace level \"{0}\"\n", TraceLevelStr));
   return TraceLevel::Off;
 }
 } // namespace
 
 llvm::Optional<InitializeParams>
-InitializeParams::parse(llvm::yaml::MappingNode *Params,
-                        clangd::Logger &Logger) {
-  // If we don't understand the params, proceed with default parameters.
-  auto ParseFailure = [&] {
-    Logger.log("Failed to decode InitializeParams\n");
-    return InitializeParams();
-  };
+InitializeParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   InitializeParams Result;
-  for (auto &NextKeyValue : *Params) {
-    auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
-    if (!KeyString)
-      return ParseFailure();
-
-    llvm::SmallString<10> KeyStorage;
-    StringRef KeyValue = KeyString->getValue(KeyStorage);
-    auto *Value =
-        dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
-    if (!Value)
-      continue;
-
-    if (KeyValue == "processId") {
-      auto *Value =
-          dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
-      if (!Value)
-        return ParseFailure();
-      long long Val;
-      if (llvm::getAsSignedInteger(Value->getValue(KeyStorage), 0, Val))
-        return ParseFailure();
-      Result.processId = Val;
-    } else if (KeyValue == "rootPath") {
-      Result.rootPath = Value->getValue(KeyStorage);
-    } else if (KeyValue == "rootUri") {
-      Result.rootUri = URI::parse(Value);
-    } else if (KeyValue == "initializationOptions") {
-      // Not used
-    } else if (KeyValue == "capabilities") {
-      // Not used
-    } else if (KeyValue == "trace") {
-      Result.trace = getTraceLevel(Value->getValue(KeyStorage), Logger);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
-  }
+  if (auto P = O->getInteger("processId"))
+    Result.processId = *P;
+  if (auto R = O->getString("rootPath"))
+    Result.rootPath = *R;
+  if (auto R = O->getString("rootUri"))
+    Result.rootUri = URI::parse(*R);
+  if (auto T = O->getString("trace"))
+    Result.trace = getTraceLevel(*T);
+  // initializationOptions, capabilities unused
   return Result;
 }
 
 llvm::Optional<DidOpenTextDocumentParams>
-DidOpenTextDocumentParams::parse(llvm::yaml::MappingNode *Params,
-                                 clangd::Logger &Logger) {
+DidOpenTextDocumentParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-      if (!Parsed)
-        return llvm::None;
+  if (auto *D = O->get("textDocument")) {
+    if (auto Parsed = TextDocumentItem::parse(*D))
       Result.textDocument = std::move(*Parsed);
-    } else if (KeyValue == "metadata") {
-      auto Parsed = Metadata::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
-      Result.metadata = std::move(*Parsed);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+  if (auto *M = O->get("metadata")) {
+    if (auto Parsed = Metadata::parse(*M))
+      Result.metadata = std::move(*Parsed);
+    else
+      return llvm::None;
   }
   return Result;
 }
 
 llvm::Optional<DidCloseTextDocumentParams>
-DidCloseTextDocumentParams::parse(llvm::yaml::MappingNode *Params,
-                                  clangd::Logger &Logger) {
-  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();
+DidCloseTextDocumentParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
 
-    if (KeyValue == "textDocument") {
-      auto *Map = dyn_cast<llvm::yaml::MappingNode>(Value);
-      if (!Map)
-        return llvm::None;
-      auto Parsed = TextDocumentIdentifier::parse(Map, Logger);
-      if (!Parsed)
-        return llvm::None;
+  DidCloseTextDocumentParams Result;
+  if (auto *D = O->get("textDocument")) {
+    if (auto Parsed = TextDocumentIdentifier::parse(*D))
       Result.textDocument = std::move(*Parsed);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+      return llvm::None;
   }
   return Result;
 }
 
 llvm::Optional<DidChangeTextDocumentParams>
-DidChangeTextDocumentParams::parse(llvm::yaml::MappingNode *Params,
-                                   clangd::Logger &Logger) {
+DidChangeTextDocumentParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-      if (!Parsed)
-        return llvm::None;
+  if (auto *D = O->get("textDocument")) {
+    if (auto Parsed = TextDocumentIdentifier::parse(*D))
       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, Logger);
-        if (!Parsed)
-          return llvm::None;
-        Result.contentChanges.push_back(std::move(*Parsed));
-      }
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+  if (auto *A = O->getArray("contentChanges"))
+    for (auto &E : *A) {
+      if (auto Parsed = TextDocumentContentChangeEvent::parse(E))
+        Result.contentChanges.push_back(std::move(*Parsed));
+      else
+        return llvm::None;
     }
   return Result;
 }
 
-llvm::Optional<FileEvent> FileEvent::parse(llvm::yaml::MappingNode *Params,
-                                           clangd::Logger &Logger) {
-  llvm::Optional<FileEvent> Result = FileEvent();
-  for (auto &NextKeyValue : *Params) {
-    // We have to consume the whole MappingNode because it doesn't support
-    // skipping and we want to be able to parse further valid events.
-    if (!Result)
-      continue;
-
-    auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
-    if (!KeyString) {
-      Result.reset();
-      continue;
-    }
-
-    llvm::SmallString<10> KeyStorage;
-    StringRef KeyValue = KeyString->getValue(KeyStorage);
-    auto *Value =
-        dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
-    if (!Value) {
-      Result.reset();
-      continue;
-    }
-    llvm::SmallString<10> Storage;
-    if (KeyValue == "uri") {
-      Result->uri = URI::parse(Value);
-    } else if (KeyValue == "type") {
-      long long Val;
-      if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val)) {
-        Result.reset();
-        continue;
-      }
-      Result->type = static_cast<FileChangeType>(Val);
-      if (Result->type < FileChangeType::Created ||
-          Result->type > FileChangeType::Deleted)
-        Result.reset();
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+llvm::Optional<FileEvent> FileEvent::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
+  FileEvent Result;
+  if (auto U = O->getString("uri"))
+    Result.uri = URI::parse(*U);
+  if (auto T = O->getInteger("type")) {
+    if (*T < static_cast<int>(FileChangeType::Created) ||
+        *T > static_cast<int>(FileChangeType::Deleted))
+      return llvm::None;
+    Result.type = static_cast<FileChangeType>(*T);
   }
   return Result;
 }
 
 llvm::Optional<DidChangeWatchedFilesParams>
-DidChangeWatchedFilesParams::parse(llvm::yaml::MappingNode *Params,
-                                   clangd::Logger &Logger) {
+DidChangeWatchedFilesParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   DidChangeWatchedFilesParams 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 == "changes") {
-      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 = FileEvent::parse(I, Logger);
-        if (Parsed)
-          Result.changes.push_back(std::move(*Parsed));
-        else
-          Logger.log("Failed to decode a FileEvent.\n");
-      }
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+  if (auto *C = O->getArray("changes"))
+    for (auto &E : *C) {
+      if (auto Parsed = FileEvent::parse(E))
+        return llvm::None;
     }
   return Result;
 }
 
 llvm::Optional<TextDocumentContentChangeEvent>
-TextDocumentContentChangeEvent::parse(llvm::yaml::MappingNode *Params,
-                                      clangd::Logger &Logger) {
+TextDocumentContentChangeEvent::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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 {
-      logIgnoredField(KeyValue, Logger);
-    }
-  }
+  if (auto T = O->getString("text"))
+    Result.text = *T;
   return Result;
 }
 
 llvm::Optional<FormattingOptions>
-FormattingOptions::parse(llvm::yaml::MappingNode *Params,
-                         clangd::Logger &Logger) {
+FormattingOptions::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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);
-    auto *Value =
-        dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
-    if (!Value)
-      return llvm::None;
-
-    llvm::SmallString<10> Storage;
-    if (KeyValue == "tabSize") {
-      long long Val;
-      if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
-        return llvm::None;
-      Result.tabSize = Val;
-    } else if (KeyValue == "insertSpaces") {
-      long long Val;
-      StringRef Str = Value->getValue(Storage);
-      if (llvm::getAsSignedInteger(Str, 0, Val)) {
-        if (Str == "true")
-          Val = 1;
-        else if (Str == "false")
-          Val = 0;
-        else
-          return llvm::None;
-      }
-      Result.insertSpaces = Val;
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
-  }
+  if (auto T = O->getInteger("tabSize"))
+    Result.tabSize = *T;
+  if (auto I = O->getBoolean("insertSpaces"))
+    Result.insertSpaces = *I;
   return Result;
 }
 
 json::Expr FormattingOptions::unparse(const FormattingOptions &P) {
   return json::obj{
       {"tabSize", P.tabSize},
       {"insertSpaces", P.insertSpaces},
   };
 }
 
 llvm::Optional<DocumentRangeFormattingParams>
-DocumentRangeFormattingParams::parse(llvm::yaml::MappingNode *Params,
-                                     clangd::Logger &Logger) {
+DocumentRangeFormattingParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-      if (!Parsed)
-        return llvm::None;
+  if (auto *D = O->get("textDocument")) {
+    if (auto Parsed = TextDocumentIdentifier::parse(*D))
       Result.textDocument = std::move(*Parsed);
-    } else if (KeyValue == "range") {
-      auto Parsed = Range::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
+    else
+  }
+  if (auto *R = O->get("range")) {
+    if (auto Parsed = Range::parse(*R))
       Result.range = std::move(*Parsed);
-    } else if (KeyValue == "options") {
-      auto Parsed = FormattingOptions::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
-      Result.options = std::move(*Parsed);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+  if (auto *F = O->get("options")) {
+    if (auto Parsed = FormattingOptions::parse(*F))
+      Result.options = std::move(*Parsed);
+    else
+      return llvm::None;
   }
   return Result;
 }
 
 llvm::Optional<DocumentOnTypeFormattingParams>
-DocumentOnTypeFormattingParams::parse(llvm::yaml::MappingNode *Params,
-                                      clangd::Logger &Logger) {
-  DocumentOnTypeFormattingParams Result;
-  for (auto &NextKeyValue : *Params) {
-    auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
-    if (!KeyString)
-      return llvm::None;
+DocumentOnTypeFormattingParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return 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, Logger);
-      if (!Parsed)
-        return llvm::None;
+  DocumentOnTypeFormattingParams Result;
+  if (auto Ch = O->getString("ch"))
+    Result.ch = *Ch;
+  if (auto *D = O->get("textDocument")) {
+    if (auto Parsed = TextDocumentIdentifier::parse(*D))
       Result.textDocument = std::move(*Parsed);
-    } else if (KeyValue == "position") {
-      auto Parsed = Position::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
+    else
+  }
+  if (auto *P = O->get("position")) {
+    if (auto Parsed = Position::parse(*P))
       Result.position = std::move(*Parsed);
-    } else if (KeyValue == "options") {
-      auto Parsed = FormattingOptions::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
-      Result.options = std::move(*Parsed);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+  if (auto *F = O->get("options")) {
+    if (auto Parsed = FormattingOptions::parse(*F))
+      Result.options = std::move(*Parsed);
+    else
+      return llvm::None;
   }
   return Result;
 }
 
 llvm::Optional<DocumentFormattingParams>
-DocumentFormattingParams::parse(llvm::yaml::MappingNode *Params,
-                                clangd::Logger &Logger) {
+DocumentFormattingParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-      if (!Parsed)
-        return llvm::None;
+  if (auto *D = O->get("textDocument")) {
+    if (auto Parsed = TextDocumentIdentifier::parse(*D))
       Result.textDocument = std::move(*Parsed);
-    } else if (KeyValue == "options") {
-      auto Parsed = FormattingOptions::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
-      Result.options = std::move(*Parsed);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+  if (auto *F = O->get("options")) {
+    if (auto Parsed = FormattingOptions::parse(*F))
+      Result.options = std::move(*Parsed);
+    else
+      return llvm::None;
   }
   return Result;
 }
 
-llvm::Optional<Diagnostic> Diagnostic::parse(llvm::yaml::MappingNode *Params,
-                                             clangd::Logger &Logger) {
+llvm::Optional<Diagnostic> Diagnostic::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-      if (!Parsed)
-        return llvm::None;
+  if (auto *R = O->get("range")) {
+    if (auto Parsed = Range::parse(*R))
       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 {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+      return llvm::None;
   }
+  if (auto S = O->getInteger("severity"))
+    Result.severity = *S;
+  if (auto M = O->getString("message"))
+    Result.message = *M;
   return Result;
 }
 
 llvm::Optional<CodeActionContext>
-CodeActionContext::parse(llvm::yaml::MappingNode *Params,
-                         clangd::Logger &Logger) {
+CodeActionContext::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-        if (!Parsed)
-          return llvm::None;
+  if (auto *D = O->getArray("diagnostics"))
+    for (auto &E : *D) {
+      if (auto Parsed = Diagnostic::parse(E))
         Result.diagnostics.push_back(std::move(*Parsed));
-      }
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+      else
+        return llvm::None;
     }
   return Result;
 }
 
 llvm::Optional<CodeActionParams>
-CodeActionParams::parse(llvm::yaml::MappingNode *Params,
-                        clangd::Logger &Logger) {
+CodeActionParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-      if (!Parsed)
-        return llvm::None;
+  if (auto *D = O->get("textDocument")) {
+    if (auto Parsed = TextDocumentIdentifier::parse(*D))
       Result.textDocument = std::move(*Parsed);
-    } else if (KeyValue == "range") {
-      auto Parsed = Range::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
+    else
+  }
+  if (auto *R = O->get("range")) {
+    if (auto Parsed = Range::parse(*R))
       Result.range = std::move(*Parsed);
-    } else if (KeyValue == "context") {
-      auto Parsed = CodeActionContext::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
-      Result.context = std::move(*Parsed);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+  if (auto *R = O->get("context")) {
+    if (auto Parsed = CodeActionContext::parse(*R))
+      Result.context = std::move(*Parsed);
+    else
+      return llvm::None;
   }
   return Result;
 }
 
-static llvm::Optional<std::map<std::string, std::vector<TextEdit>>>
-parseWorkspaceEditChange(llvm::yaml::MappingNode *Params,
-                         clangd::Logger &Logger) {
+llvm::Optional<std::map<std::string, std::vector<TextEdit>>>
+parseWorkspaceEditChange(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   std::map<std::string, std::vector<TextEdit>> Result;
-  for (auto &NextKeyValue : *Params) {
-    auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
-    if (!KeyString)
+  for (const auto &KV : *O) {
+    auto &Values = Result[StringRef(KV.first)];
+    if (auto *Edits = KV.second.asArray())
+      for (auto &Edit : *Edits) {
+        if (auto Parsed = TextEdit::parse(Edit))
+          Values.push_back(std::move(*Parsed));
+        else
           return llvm::None;
-
-    llvm::SmallString<10> KeyStorage;
-    StringRef KeyValue = KeyString->getValue(KeyStorage);
-    if (Result.count(KeyValue)) {
-      logIgnoredField(KeyValue, Logger);
-      continue;
       }
-
-    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[KeyValue].push_back(*Parsed);
-    }
+    else
   }
-
   return Result;
 }
 
-llvm::Optional<WorkspaceEdit>
-WorkspaceEdit::parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger) {
+llvm::Optional<WorkspaceEdit> WorkspaceEdit::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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;
+  if (auto *C = O->get("changes")) {
+    if (auto Parsed = parseWorkspaceEditChange(*C))
       Result.changes = std::move(*Parsed);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+      return llvm::None;
   }
   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::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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 {
-        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())
+  if (auto Command = O->getString("command"))
+    Result.command = *Command;
+  auto Args = O->getArray("arguments");
+
+    if (!Args || Args->size() != 1)
+    if (auto Parsed = WorkspaceEdit::parse(Args->front()))
+      Result.workspaceEdit = std::move(*Parsed);
+    else
       return llvm::None;
-
+  } else
+    return llvm::None; // Unrecognized command.
   return Result;
 }
 
 json::Expr WorkspaceEdit::unparse(const WorkspaceEdit &WE) {
   if (!WE.changes)
     return json::obj{};
   json::obj FileChanges;
   for (auto &Change : *WE.changes)
     FileChanges[Change.first] = json::ary(Change.second);
   return json::obj{{"changes", std::move(FileChanges)}};
 }
 
 json::Expr
 ApplyWorkspaceEditParams::unparse(const ApplyWorkspaceEditParams &Params) {
   return json::obj{{"edit", Params.edit}};
 }
 
 llvm::Optional<TextDocumentPositionParams>
-TextDocumentPositionParams::parse(llvm::yaml::MappingNode *Params,
-                                  clangd::Logger &Logger) {
+TextDocumentPositionParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   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, Logger);
-      if (!Parsed)
-        return llvm::None;
+  if (auto *D = O->get("textDocument")) {
+    if (auto Parsed = TextDocumentIdentifier::parse(*D))
       Result.textDocument = std::move(*Parsed);
-    } else if (KeyValue == "position") {
-      auto Parsed = Position::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
-      Result.position = std::move(*Parsed);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+  if (auto *P = O->get("position")) {
+    if (auto Parsed = Position::parse(*P))
+      Result.position = std::move(*Parsed);
+    else
+      return llvm::None;
   }
   return Result;
 }
 
 json::Expr CompletionItem::unparse(const CompletionItem &CI) {
   assert(!CI.label.empty() && "completion item label is required");
   json::obj Result{{"label", CI.label}};
   if (CI.kind != CompletionItemKind::Missing)
assert(SH.activeParameter >= 0 &&
          "Unexpected negative value for active parameter index");
   return json::obj{
       {"activeSignature", SH.activeSignature},
       {"activeParameter", SH.activeParameter},
       {"signatures", json::ary(SH.signatures)},
   };
 }
 
-llvm::Optional<RenameParams>
-RenameParams::parse(llvm::yaml::MappingNode *Params, clangd::Logger &Logger) {
+llvm::Optional<RenameParams> RenameParams::parse(const json::Expr &Params) {
+  const json::obj *O = Params.asObject();
+  if (!O)
+    return None;
+
   RenameParams Result;
-  for (auto &NextKeyValue : *Params) {
-    auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
-    if (!KeyString)
-      return llvm::None;
-
-    llvm::SmallString<10> KeyStorage;
-    StringRef KeyValue = KeyString->getValue(KeyStorage);
-
-    if (KeyValue == "textDocument") {
-      auto *Value =
-          dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
-      if (!Value)
-        continue;
-      auto *Map = dyn_cast<llvm::yaml::MappingNode>(Value);
-      if (!Map)
-        return llvm::None;
-      auto Parsed = TextDocumentIdentifier::parse(Map, Logger);
-      if (!Parsed)
-        return llvm::None;
+  if (auto *D = O->get("textDocument")) {
+    if (auto Parsed = TextDocumentIdentifier::parse(*D))
       Result.textDocument = std::move(*Parsed);
-    } else if (KeyValue == "position") {
-      auto *Value =
-          dyn_cast_or_null<llvm::yaml::MappingNode>(NextKeyValue.getValue());
-      if (!Value)
-        continue;
-      auto Parsed = Position::parse(Value, Logger);
-      if (!Parsed)
-        return llvm::None;
-      Result.position = std::move(*Parsed);
-    } else if (KeyValue == "newName") {
-      auto *Value = NextKeyValue.getValue();
-      if (!Value)
-        continue;
-      auto *Node = dyn_cast<llvm::yaml::ScalarNode>(Value);
-      if (!Node)
-        return llvm::None;
-      llvm::SmallString<10> Storage;
-      Result.newName = Node->getValue(Storage);
-    } else {
-      logIgnoredField(KeyValue, Logger);
-    }
+    else
+  if (auto *P = O->get("position")) {
+    if (auto Parsed = Position::parse(*P))
+      Result.position = std::move(*Parsed);
+    else
+      return llvm::None;
   }
+  if (auto N = O->getString("newName"))
+    Result.newName = *N;
   return Result;
 }

clangd/ProtocolHandlers.cpp

 using namespace clang;
 using namespace clang::clangd;
 
 namespace {
 
 // Helper for attaching ProtocolCallbacks methods to a JSONRPCDispatcher.
 // Invoke like: Registerer("foo", &ProtocolCallbacks::onFoo)
 // onFoo should be: void onFoo(Ctx &C, FooParams &Params)
-// FooParams should have a static factory method: parse(yaml::MappingNode*).
+// FooParams should have a static factory method: parse(const json::Expr&).
 struct HandlerRegisterer {
   template <typename Param>
   void operator()(StringRef Method,
                   void (ProtocolCallbacks::*Handler)(RequestContext, Param)) {
     // Capture pointers by value, as the lambda will outlive this object.
     auto *Out = this->Out;
     auto *Callbacks = this->Callbacks;
     Dispatcher.registerHandler(
-        Method, [=](RequestContext C, llvm::yaml::MappingNode *RawParams) {
+        Method, [=](RequestContext C, const json::Expr &RawParams) {
           if (auto P = [&] {
                 trace::Span Tracer("Parse");
-                return std::decay<Param>::type::parse(RawParams, *Out);
+                return std::decay<Param>::type::parse(RawParams);
               }()) {
             (Callbacks->*Handler)(std::move(C), *P);
           } else {
             Out->log("Failed to decode " + Method + " request.\n");
           }
         });
   }
 

clangd/Trace.cpp

 //===--- Trace.cpp - Performance tracing facilities -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Trace.h"
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/FormatProviders.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Threading.h"
-#include "llvm/Support/YAMLParser.h"
 #include <mutex>
 
 namespace clang {
 namespace clangd {
 namespace trace {
 using namespace llvm;
 
 namespace {

test/clangd/authority-less-uri.test

 #      CHECK:        "filterText": "fake",
 # CHECK-NEXT:        "insertText": "fake",
 # CHECK-NEXT:        "insertTextFormat": 1,
 # CHECK-NEXT:        "kind": 7,
 # CHECK-NEXT:        "label": "fake::",
 # CHECK-NEXT:        "sortText": "{{.*}}fake"
 #      CHECK:    ]
 # CHECK-NEXT:  }
-Content-Length: 172
+Content-Length: 173
 
 {"jsonrpc":"2.0","id":2,"method":"textDocument/completion","params":{"textDocument":{"uri":"file:///main.cpp"},"uri":"file:///main.cpp","position":{"line":3,"character":5}}}
 # Test params parsing in the presence of a 1.x-compatible client (inlined "uri")
 #
 #      CHECK:  "id": 2,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": {
 # CHECK-NEXT:    "isIncomplete": false,
 # CHECK-NEXT:    "items": [
 #      CHECK:        "filterText": "fake",
 # CHECK-NEXT:        "insertText": "fake",
 # CHECK-NEXT:        "insertTextFormat": 1,
 # CHECK-NEXT:        "kind": 7,
 # CHECK-NEXT:        "label": "fake::",
 # CHECK-NEXT:        "sortText": "{{.*}}fake"
 #      CHECK:    ]
 # CHECK-NEXT:  }
 Content-Length: 44
 
 {"jsonrpc":"2.0","id":3,"method":"shutdown"}
 Content-Length: 33
 
-{"jsonrpc":"2.0":"method":"exit"}
+{"jsonrpc":"2.0","method":"exit"}

test/clangd/definitions.test

 # CHECK-NEXT:        "start": {
 # CHECK-NEXT:          "character": 0,
 # CHECK-NEXT:          "line": 1
 # CHECK-NEXT:        }
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "uri": "file:///{{([A-Z]:/)?}}main.cpp"
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
-Content-Length: 187
+Content-Length: 188
 
 {"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":"file:///main.cpp","version":4},"contentChanges":[{"text":"int main() {\n   main();\n   return 0;\n}"}]}}
 
 Content-Length: 148
 
 {"jsonrpc":"2.0","id":1,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":1,"character":3}}}
 # Go to function declaration, function call 
 #      CHECK:  "id": 1,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": [
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "range": {
 # CHECK-NEXT:        "end": {
 # CHECK-NEXT:          "character": 1,
 # CHECK-NEXT:          "line": 3
 # CHECK-NEXT:        },
 # CHECK-NEXT:        "start": {
 # CHECK-NEXT:          "character": 0,
 # CHECK-NEXT:          "line": 0
 # CHECK-NEXT:        }
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "uri": "file:///{{([A-Z]:/)?}}main.cpp"
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
-Content-Length: 208
+Content-Length: 209
 
 {"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":"file:///main.cpp","version":5},"contentChanges":[{"text":"struct Foo {\n};\nint main() {\n   Foo bar;\n   return 0;\n}\n"}]}}
 
 Content-Length: 148
 
 {"jsonrpc":"2.0","id":1,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":3,"character":3}}}
 # Go to struct declaration, new struct instance 
 #      CHECK:  "id": 1,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": [
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "range": {
 # CHECK-NEXT:        "end": {
 # CHECK-NEXT:          "character": 1,
 # CHECK-NEXT:          "line": 1
 # CHECK-NEXT:        },
 # CHECK-NEXT:        "start": {
 # CHECK-NEXT:          "character": 0,
 # CHECK-NEXT:          "line": 0
 # CHECK-NEXT:        }
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "uri": "file:///{{([A-Z]:/)?}}main.cpp"
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
-Content-Length: 231
+Content-Length: 232
 
 {"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":"file:///main.cpp","version":5},"contentChanges":[{"text":"namespace n1 {\nstruct Foo {\n};\n}\nint main() {\n   n1::Foo bar;\n   return 0;\n}\n"}]}}
 
 Content-Length: 148
 
 {"jsonrpc":"2.0","id":1,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":5,"character":4}}}
 # Go to struct declaration, new struct instance, qualified name 
 #      CHECK:  "id": 1,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": [
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "range": {
 # CHECK-NEXT:        "end": {
 # CHECK-NEXT:          "character": 1,
 # CHECK-NEXT:          "line": 3
 # CHECK-NEXT:        },
 # CHECK-NEXT:        "start": {
 # CHECK-NEXT:          "character": 0,
 # CHECK-NEXT:          "line": 0
 # CHECK-NEXT:        }
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "uri": "file:///{{([A-Z]:/)?}}main.cpp"
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
-Content-Length: 215
+Content-Length: 216
 
 {"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":"file:///main.cpp","version":6},"contentChanges":[{"text":"struct Foo {\n  int x;\n};\nint main() {\n   Foo bar;\n   bar.x;\n}\n"}]}}
 
 Content-Length: 148
 
 {"jsonrpc":"2.0","id":1,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":5,"character":7}}}
 # Go to field declaration, field reference 
 #      CHECK:  "id": 1,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": [
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "range": {
 # CHECK-NEXT:        "end": {
 # CHECK-NEXT:          "character": 7,
 # CHECK-NEXT:          "line": 1
 # CHECK-NEXT:        },
 # CHECK-NEXT:        "start": {
 # CHECK-NEXT:          "character": 2,
 # CHECK-NEXT:          "line": 1
 # CHECK-NEXT:        }
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "uri": "file:///{{([A-Z]:/)?}}main.cpp"
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
-Content-Length: 220
+Content-Length: 221
 
 {"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":"file:///main.cpp","version":7},"contentChanges":[{"text":"struct Foo {\n  void x();\n};\nint main() {\n   Foo bar;\n   bar.x();\n}\n"}]}}
 
 Content-Length: 148
 
 {"jsonrpc":"2.0","id":1,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":5,"character":7}}}
 # Go to method declaration, method call 
 #      CHECK:  "id": 1,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": [
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "range": {
 # CHECK-NEXT:        "end": {
 # CHECK-NEXT:          "character": 10,
 # CHECK-NEXT:          "line": 1
 # CHECK-NEXT:        },
 # CHECK-NEXT:        "start": {
 # CHECK-NEXT:          "character": 2,
 # CHECK-NEXT:          "line": 1
 # CHECK-NEXT:        }
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "uri": "file:///{{([A-Z]:/)?}}main.cpp"
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
-Content-Length: 240
+Content-Length: 241
 
 {"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":"file:///main.cpp","version":7},"contentChanges":[{"text":"struct Foo {\n};\ntypedef Foo TypedefFoo;\nint main() {\n   TypedefFoo bar;\n   return 0;\n}\n"}]}}
 
 Content-Length: 149
 
 {"jsonrpc":"2.0","id":1,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":4,"character":10}}}
 # Go to typedef 
 #      CHECK:  "id": 1,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": [
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "range": {
 # CHECK-NEXT:        "end": {
 # CHECK-NEXT:          "character": 22,
 # CHECK-NEXT:          "line": 2
 # CHECK-NEXT:        },
 # CHECK-NEXT:        "start": {
 # CHECK-NEXT:          "character": 0,
 # CHECK-NEXT:          "line": 2
 # CHECK-NEXT:        }
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "uri": "file:///{{([A-Z]:/)?}}main.cpp"
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
-Content-Length: 254
+Content-Length: 253
 
 {"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":"file:///main.cpp","version":7},"contentChanges":[{"text":"template <typename MyTemplateParam>\nvoid foo() {\n MyTemplateParam a;\n}\nint main() {\n   return 0;\n}\n"}]}}
 
 Content-Length: 149
 
 {"jsonrpc":"2.0","id":1,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":2,"character":13}}}
 # Go to template type parameter. Fails until clangIndex is modified to handle those.
 #      CHECK:  "id": 1,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": []
-Content-Length: 256
+Content-Length: 257
 
 {"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":"file:///main.cpp","version":7},"contentChanges":[{"text":"namespace ns {\nstruct Foo {\nstatic void bar() {}\n};\n}\nint main() {\n   ns::Foo::bar();\n   return 0;\n}\n"}]}}
 
 Content-Length: 148
 
 {"jsonrpc":"2.0","id":1,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///main.cpp"},"position":{"line":6,"character":4}}}
 # Go to namespace, static method call 
 #      CHECK:  "id": 1,

 # CHECK-NEXT:  },
 # CHECK-NEXT:  "id": 2,
 # CHECK-NEXT:  "jsonrpc": "2.0"
 Content-Length: 48
 
 {"jsonrpc":"2.0","id":10000,"method":"shutdown"}
 Content-Length: 33
 
-{"jsonrpc":"2.0":"method":"exit"}
+{"jsonrpc":"2.0","method":"exit"}

test/clangd/diagnostics.test

 # CHECK-NEXT:    ],
 # CHECK-NEXT:    "uri": "file:///foo.c"
 # CHECK-NEXT:  }
 Content-Length: 44
 
 {"jsonrpc":"2.0","id":5,"method":"shutdown"}
 Content-Length: 33
 
-{"jsonrpc":"2.0":"method":"exit"}
+{"jsonrpc":"2.0","method":"exit"}

test/clangd/did-change-watch-files.test

-# RUN: clangd -run-synchronously < %s 2>&1 | FileCheck -check-prefix=STDERR %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"}}
-# Normal case.
-Content-Length: 217
-
-{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///path/to/file.cpp","type":1},{"uri":"file:///path/to/file2.cpp","type":2},{"uri":"file:///path/to/file3.cpp","type":3}]}}
-
-# Wrong event type, integer
-Content-Length: 173
-
-{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///path/to/file2.cpp","type":0},{"uri":"file:///path/to/file3.cpp","type":4}]}}
-# STDERR: Failed to decode a FileEvent.
-# Wrong event type, string
-Content-Length: 132
-
-{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///path/to/file2.cpp","type":"foo"}]}}
-# STDERR: Failed to decode a FileEvent.
-#Custom event field
-Content-Length: 143
-
-{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///path/to/file2.cpp","type":1,"custom":"foo"}]}}
-# STDERR: Failed to decode a FileEvent.
-#Event field with object
-Content-Length: 140
-
-{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[{"uri":"file:///path/to/file2.cpp","type":{"foo":"bar"}}]}}
-# STDERR: Failed to decode a FileEvent.
-# Changes field with sequence but no object
-Content-Length: 86
-
-{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":[""]}}
-# STDERR: Failed to decode workspace/didChangeWatchedFiles request.
-# Changes field with no sequence
-Content-Length: 84
-
-{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"changes":""}}
-# STDERR: Failed to decode workspace/didChangeWatchedFiles request.
-# Custom field
-Content-Length: 86
-
-{"jsonrpc":"2.0","method":"workspace/didChangeWatchedFiles","params":{"custom":"foo"}}
-# STDERR: Ignored unknown field "custom"
-Content-Length: 44
-
-{"jsonrpc":"2.0","id":3,"method":"shutdown"}
-Content-Length: 33
-
-{"jsonrpc":"2.0":"method":"exit"}

test/clangd/protocol.test

 # STDERR: Warning: Duplicate Content-Length header received. The previous value for this message (10) was ignored.
 
 Content-Type: application/vscode-jsonrpc; charset-utf-8
 Content-Length: 10
 
 {"jsonrpc":"2.0","id":4,"method":"textDocument/completion","params":{"textDocument":{"uri":"file:/main.cpp"},"position":{"line":3,"character":5}}}
 # Test message with malformed Content-Length
 #
-# STDERR: JSON dispatch failed!
+# STDERR: JSON parse error
 # Ensure we recover by sending another (valid) message
 
 Content-Length: 146
 
 {"jsonrpc":"2.0","id":5,"method":"textDocument/completion","params":{"textDocument":{"uri":"file:/main.cpp"},"position":{"line":3,"character":5}}}
 # Test message with Content-Type before Content-Length
 #
 #      CHECK:  "id": 5,

unittests/clangd/JSONExprTests.cpp

TEST(JSONTest, Inspection) {
   obj *O = Doc->asObject();
   ASSERT_TRUE(O);
 
   EXPECT_FALSE(O->getNull("missing"));
   EXPECT_FALSE(O->getNull("boolean"));
   EXPECT_TRUE(O->getNull("null"));
 
   EXPECT_EQ(O->getNumber("number"), llvm::Optional<double>(2.78));
+  EXPECT_FALSE(O->getInteger("number"));
   EXPECT_EQ(O->getString("string"), llvm::Optional<llvm::StringRef>("json"));
   ASSERT_FALSE(O->getObject("missing"));
   ASSERT_FALSE(O->getObject("array"));
   ASSERT_TRUE(O->getObject("object"));
   EXPECT_EQ(*O->getObject("object"), (obj{{"fruit", "banana"}}));
 
   ary *A = O->getArray("array");
   ASSERT_TRUE(A);
   EXPECT_EQ(A->getBoolean(1), llvm::Optional<bool>(true));
   ASSERT_TRUE(A->getArray(4));
   EXPECT_EQ(*A->getArray(4), (ary{1, 2, 3}));
+  EXPECT_EQ(A->getArray(4)->getInteger(1), llvm::Optional<int64_t>(2));
   int I = 0;
   for (Expr &E : *A) {
     if (I++ == 5) {
       ASSERT_TRUE(E.asObject());
       EXPECT_EQ(E.asObject()->getString("time"),
                 llvm::Optional<llvm::StringRef>("arrow"));
     } else
       EXPECT_FALSE(E.asObject());
   }
 }
 
 } // namespace
 } // namespace json
 } // namespace clangd
 } // namespace clang