[clangd] New conventions for JSON-marshalling functions, centralize machinery

[sammccall]

Summary

• JSON<->Obj interface is now ADL functions, so they play nicely with enums
• recursive vector/map parsing and ObjectMapper moved to JSONExpr and tested
• renamed (un)parse to to/fromJSON, since text -> JSON is called parse
• Protocol.cpp gets a bit shorter

Sorry for the giant patch, it's prety mechanical though

[ilya-biryukov]

Thanks you very much for this patch, JSON parsing now looks better than ever!
LGTM. (Just a few minor NITs).

clangd/JSONExpr.h

71

The name deserialize may be a bit too general and prone to clashes with other code. Maybe choosing something a bit more specific like json_deserialize is a better option.
On the other hand, we do the SFINAE trick to check the types are correct in Expr constructor, so we should be fine either way.

512

Maybe also call Out.clear() to be consistent with deserialize(..., vector)?

547

Maybe make this field private?

[sammccall]

clangd/JSONExpr.h

71

Yeah, these are a bit generic. Renamed to toJSON/fromJSON - not perfect names but they're short and I find it easier to remember which direction they convert in.

clangd/ClangdLSPServer.cpp

if (Params.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND &&
     // we ignore it)
 
     ApplyWorkspaceEditParams ApplyEdit;
     ApplyEdit.edit = *Params.workspaceEdit;
     C.reply("Fix applied.");
     // We don't need the response so id == 1 is OK.
     // Ideally, we would wait for the response and if there is no error, we
     // would reply success/failure to the original RPC.
-    C.call("workspace/applyEdit", ApplyWorkspaceEditParams::unparse(ApplyEdit));
+    C.call("workspace/applyEdit", ApplyEdit);
   } else {
     // We should not get here because ExecuteCommandParams would not have
     // parsed in the first place and this handler should not be called. But if
     // more commands are added, this will be here has a safe guard.
     C.replyError(
         ErrorCode::InvalidParams,
         llvm::formatv("Unsupported command \"{0}\".", Params.command).str());
   }
 }
 
 void ClangdLSPServer::onRename(Ctx C, RenameParams &Params) {
   auto File = Params.textDocument.uri.file;
   auto Replacements = Server.rename(File, Params.position, Params.newName);
   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 = {{Params.textDocument.uri.uri, Edits}};
-  C.reply(WorkspaceEdit::unparse(WE));
+  C.reply(WE);
 }
 
 void ClangdLSPServer::onDocumentDidClose(Ctx C,
                                          DidCloseTextDocumentParams &Params) {
   Server.removeDocument(Params.textDocument.uri.file);
 }
 
 void ClangdLSPServer::onDocumentOnTypeFormatting(

clangd/JSONExpr.h

 //
 // You can implicitly construct Exprs from:
 //   - strings: std::string, SmallString, formatv, StringRef, char*
 //              (char*, and StringRef are references, not copies!)
 //   - numbers
 //   - booleans
 //   - null: nullptr
 //   - arrays: {"foo", 42.0, false}
-//   - serializable things: any T with a T::unparse(const T&) -> Expr
+//   - serializable things: types with serialize(const T&)->Expr, found by ADL
 //
 // They can also be constructed from object/array helpers:
 //   - json::obj is a type like map<StringExpr, Expr>
 //   - json::ary is a type like vector<Expr>
 // These can be list-initialized, or used to build up collections in a loop.
 // json::ary(Collection) converts all items in a collection to Exprs.
 //
 // === Inspecting expressions ===

 //
 // Array and Object also have typed indexing accessors for easy traversal:
 //   Expected<Expr> E = parse(R"( {"options": {"font": "sans-serif"}} )");
 //   if (json::obj* O = E->asObject())
 //     if (json::obj* Opts = O->getObject("options"))
 //       if (Optional<StringRef> Font = Opts->getString("font"))
 //         assert(Opts->at("font").kind() == Expr::String);
 //
+// === Converting expressions to objects ===
+//
+// The convention is to have a deserialize function findable via ADL:
+//     deserialize(const json::Expr&, T&)->bool
+// Deserializers are provided for:
+//   - bool
+//   - int
+//   - double
+//   - std::string
+//   - vector<T>, where T is deserializable
+//   - map<string, T>, where T is deserializable
+//   - Optional<T>, where T is deserializable
+//
+// ObjectMapper can help writing deserialize() functions for object types:
+//   bool deserialize(const Expr &E, MyStruct &R) {
+//     ObjectMapper O(E);
+//     if (!O || !O.map("mandatory_field", R.MandatoryField))
+//       return false;
+//     O.map("optional_field", R.OptionalField);
+//     return true;
+//   }
+//
 // === Serialization ===
 //
 // Exprs can be serialized to JSON:
 //   1) raw_ostream << Expr                    // Basic formatting.
 //   2) raw_ostream << formatv("{0}", Expr)    // Basic formatting.
 //   3) raw_ostream << formatv("{0:2}", Expr)  // Pretty-print with indent 2.
 //
 // And parsed:
public:
   template <
       typename T,
       typename = typename std::enable_if<std::is_arithmetic<T>::value>::type,
       typename = typename std::enable_if<std::integral_constant<
           bool, !std::is_same<T, bool>::value>::value>::type>
   Expr(T D) : Type(T_Number) {
     create<double>(D);
   }
-  // Types with a static T::unparse function returning an Expr.
-  // FIXME: should this be a free unparse() function found by ADL?
+  // Types with a serialize(const T&)->Expr function, found by ADL.
   template <typename T,
             typename = typename std::enable_if<std::is_same<
-                Expr, decltype(T::unparse(*(const T *)nullptr))>::value>>
-  Expr(const T &V) : Expr(T::unparse(V)) {}
+                Expr, decltype(serialize(*(const T *)nullptr))>::value>>
+  Expr(const T &V) : Expr(serialize(V)) {}
 
   Expr &operator=(const Expr &M) {
     destroy();
     copyFrom(M);
     return *this;
   }
   Expr &operator=(Expr &&M) {
     destroy();
inline Expr::ObjectExpr::ObjectExpr(std::initializer_list<KV> Properties) {
   for (const auto &P : Properties)
     emplace(std::move(P.K), std::move(P.V));
 }
 
 // Give Expr::{Object,Array} more convenient names for literal use.
 using obj = Expr::ObjectExpr;
 using ary = Expr::ArrayExpr;
 
+// Standard deserializers.
+inline bool deserialize(const json::Expr &E, std::string &Out) {
+  if (auto S = E.asString()) {
+    Out = *S;
+    return true;
+  }
+  return false;
+}
+inline bool deserialize(const json::Expr &E, int &Out) {
+  if (auto S = E.asInteger()) {
+    Out = *S;
+    return true;
+  }
+  return false;
+}
+inline bool deserialize(const json::Expr &E, double &Out) {
+  if (auto S = E.asNumber()) {
+    Out = *S;
+    return true;
+  }
+  return false;
+}
+inline bool deserialize(const json::Expr &E, bool &Out) {
+  if (auto S = E.asBoolean()) {
+    Out = *S;
+    return true;
+  }
+  return false;
+}
+template <typename T>
+bool deserialize(const json::Expr &E, llvm::Optional<T> &Out) {
+  if (E.asNull()) {
+    Out = llvm::None;
+    return true;
+  }
+  T Result;
+  if (!deserialize(E, Result))
+    return false;
+  Out = std::move(Result);
+  return true;
+}
+template <typename T>
+bool deserialize(const json::Expr &E, std::vector<T> &Out) {
+  if (auto *A = E.asArray()) {
+    Out.clear();
+    Out.resize(A->size());
+    for (size_t I = 0; I < A->size(); ++I)
+      if (!deserialize((*A)[I], Out[I]))
+        return false;
+    return true;
+  }
+  return false;
+}
+template <typename T>
+bool deserialize(const json::Expr &E, std::map<std::string, T> &Out) {
+  if (auto *O = E.asObject()) {
+    for (const auto &KV : *O)
+      if (!deserialize(KV.second, Out[llvm::StringRef(KV.first)]))
+        return false;
+    return true;
+  }
+  return false;
+}
+
+// Helper for mapping JSON objects onto protocol structs.
+// See file header for example.
+class ObjectMapper {
+public:
+  ObjectMapper(const json::Expr &E) : O(E.asObject()) {}
+
+  // True if the expression is an object.
+  // Must be checked before calling map().
+  operator bool() { return O; }
+
+  // Maps a property to a field, if it exists.
+  template <typename T> bool map(const char *Prop, T &Out) {
+    assert(*this && "Must check this is an object before calling map()");
+    if (const json::Expr *E = O->get(Prop))
+      return deserialize(*E, Out);
+    return false;
+  }
+
+  // Optional requires special handling, because missing keys are OK.
+  template <typename T> bool map(const char *Prop, llvm::Optional<T> &Out) {
+    assert(*this && "Must check this is an object before calling map()");
+    if (const json::Expr *E = O->get(Prop))
+      return deserialize(*E, Out);
+    Out = llvm::None;
+    return true;
+  }
+
+  const json::obj *O;
+};
+
 llvm::Expected<Expr> parse(llvm::StringRef JSON);
 
 class ParseError : public llvm::ErrorInfo<ParseError> {
   const char *Msg;
   unsigned Line, Column, Offset;
 
 public:
   static char ID;

clangd/Protocol.h

 //===--- Protocol.h - Language Server Protocol Implementation ---*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains structs based on the LSP specification at
 // https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md
 //
 // This is not meant to be a complete implementation, new interfaces are added
 // when they're needed.
 //
-// Each struct has a parse and unparse function, that converts back and forth
-// between the struct and a JSON representation.
+// Each struct has a serialize and deserialize function, that converts between
+// the struct and a JSON representation. (See JSONExpr.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"

 
 struct URI {
   std::string uri;
   std::string file;
 
   static URI fromUri(llvm::StringRef uri);
   static URI fromFile(llvm::StringRef file);
 
-  static llvm::Optional<URI> parse(const json::Expr &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;
   }
 };
+json::Expr serialize(const URI &U);
+bool deserialize(const json::Expr &, URI &);
 
 struct TextDocumentIdentifier {
   /// The text document's URI.
   URI uri;
-
-  static llvm::Optional<TextDocumentIdentifier> parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, TextDocumentIdentifier &);
 
 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(const json::Expr &Params);
-  static json::Expr unparse(const Position &P);
 };
+bool deserialize(const json::Expr &, Position &);
+json::Expr serialize(const Position &);
 
 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(const json::Expr &Params);
-  static json::Expr unparse(const Range &P);
 };
+bool deserialize(const json::Expr &, Range &);
+json::Expr serialize(const Range &);
 
 struct Location {
   /// The text document's URI.
   URI uri;
   Range range;
 
   friend bool operator==(const Location &LHS, const Location &RHS) {
     return LHS.uri == RHS.uri && LHS.range == RHS.range;
   }
 
   friend bool operator!=(const Location &LHS, const Location &RHS) {
     return !(LHS == RHS);
   }
 
   friend bool operator<(const Location &LHS, const Location &RHS) {
     return std::tie(LHS.uri, LHS.range) < std::tie(RHS.uri, RHS.range);
   }
-
-  static json::Expr unparse(const Location &P);
 };
+json::Expr serialize(const Location &);
 
 struct Metadata {
   std::vector<std::string> extraFlags;
-
-  static llvm::Optional<Metadata> parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, Metadata &);
 
 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(const json::Expr &Params);
-  static json::Expr unparse(const TextEdit &P);
 };
+bool deserialize(const json::Expr &, TextEdit &);
+json::Expr serialize(const TextEdit &);
 
 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(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, TextDocumentItem &);
 
 enum class TraceLevel {
   Off = 0,
   Messages = 1,
   Verbose = 2,
 };
+bool deserialize(const json::Expr &E, TraceLevel &Out);
 
-struct NoParams {
-  static llvm::Optional<NoParams> parse(const json::Expr &Params) {
-    return NoParams{};
-  }
-};
+struct NoParams {};
+inline bool deserialize(const json::Expr &, NoParams &) { return true; }
 using ShutdownParams = NoParams;
 using ExitParams = NoParams;
 
 struct InitializeParams {
   /// The process Id of the parent process that started
   /// the server. Is null if the process has not been started by another
   /// process. If the parent process is not alive then the server should exit
   /// (see exit notification) its process.
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(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, InitializeParams &);
 
 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(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, DidOpenTextDocumentParams &);
 
 struct DidCloseTextDocumentParams {
   /// The document that was closed.
   TextDocumentIdentifier textDocument;
-
-  static llvm::Optional<DidCloseTextDocumentParams>
-  parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, DidCloseTextDocumentParams &);
 
 struct TextDocumentContentChangeEvent {
   /// The new text of the document.
   std::string text;
-
-  static llvm::Optional<TextDocumentContentChangeEvent>
-  parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, TextDocumentContentChangeEvent &);
 
 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(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, DidChangeTextDocumentParams &);
 
 enum class FileChangeType {
   /// The file got created.
   Created = 1,
   /// The file got changed.
   Changed = 2,
   /// The file got deleted.
   Deleted = 3
 };
+bool deserialize(const json::Expr &E, FileChangeType &Out);
 
 struct FileEvent {
   /// The file's URI.
   URI uri;
   /// The change type.
   FileChangeType type;
-
-  static llvm::Optional<FileEvent> parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, FileEvent &);
 
 struct DidChangeWatchedFilesParams {
   /// The actual file events.
   std::vector<FileEvent> changes;
-
-  static llvm::Optional<DidChangeWatchedFilesParams>
-  parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, DidChangeWatchedFilesParams &);
 
 struct FormattingOptions {
   /// Size of a tab in spaces.
   int tabSize;
 
   /// Prefer spaces over tabs.
   bool insertSpaces;
-
-  static llvm::Optional<FormattingOptions> parse(const json::Expr &Params);
-  static json::Expr unparse(const FormattingOptions &P);
 };
+bool deserialize(const json::Expr &, FormattingOptions &);
+json::Expr serialize(const FormattingOptions &);
 
 struct DocumentRangeFormattingParams {
   /// The document to format.
   TextDocumentIdentifier textDocument;
 
   /// The range to format
   Range range;
 
   /// The format options
   FormattingOptions options;
-
-  static llvm::Optional<DocumentRangeFormattingParams>
-  parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, DocumentRangeFormattingParams &);
 
 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(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, DocumentOnTypeFormattingParams &);
 
 struct DocumentFormattingParams {
   /// The document to format.
   TextDocumentIdentifier textDocument;
 
   /// The format options
   FormattingOptions options;
-
-  static llvm::Optional<DocumentFormattingParams>
-  parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, DocumentFormattingParams &);
 
 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;
struct Diagnostic {
   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(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, Diagnostic &);
 
 struct CodeActionContext {
   /// An array of diagnostics.
   std::vector<Diagnostic> diagnostics;
-
-  static llvm::Optional<CodeActionContext> parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, CodeActionContext &);
 
 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(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, CodeActionParams &);
 
 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(const json::Expr &Params);
-  static json::Expr unparse(const WorkspaceEdit &WE);
 };
+bool deserialize(const json::Expr &, WorkspaceEdit &);
+json::Expr serialize(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(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, ExecuteCommandParams &);
 
 struct ApplyWorkspaceEditParams {
   WorkspaceEdit edit;
-  static json::Expr unparse(const ApplyWorkspaceEditParams &Params);
 };
+json::Expr serialize(const ApplyWorkspaceEditParams &);
 
 struct TextDocumentPositionParams {
   /// The text document.
   TextDocumentIdentifier textDocument;
 
   /// The position inside the text document.
   Position position;
-
-  static llvm::Optional<TextDocumentPositionParams>
-  parse(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, TextDocumentPositionParams &);
 
 /// The kind of a completion entry.
 enum class CompletionItemKind {
   Missing = 0,
   Text = 1,
   Method = 2,
   Function = 3,
   Constructor = 4,
struct CompletionItem {
   // TODO(krasimir): The following optional fields defined by the language
   // server protocol are unsupported:
   //
   // command?: Command - An optional command that is executed *after* inserting
   //                     this completion.
   //
   // data?: any - A data entry field that is preserved on a completion item
   //              between a completion and a completion resolve request.
-  static json::Expr unparse(const CompletionItem &P);
 };
+json::Expr serialize(const CompletionItem &);
 
 bool operator<(const CompletionItem &, const CompletionItem &);
 
 /// Represents a collection of completion items to be presented in the editor.
 struct CompletionList {
   /// The list is not complete. Further typing should result in recomputing the
   /// list.
   bool isIncomplete = false;
 
   /// The completion items.
   std::vector<CompletionItem> items;
-
-  static json::Expr unparse(const CompletionList &);
 };
+json::Expr serialize(const CompletionList &);
 
 /// A single parameter of a particular signature.
 struct ParameterInformation {
 
   /// The label of this parameter. Mandatory.
   std::string label;
 
   /// The documentation of this parameter. Optional.
   std::string documentation;
-
-  static json::Expr unparse(const ParameterInformation &);
 };
+json::Expr serialize(const ParameterInformation &);
 
 /// Represents the signature of something callable.
 struct SignatureInformation {
 
   /// The label of this signature. Mandatory.
   std::string label;
 
   /// The documentation of this signature. Optional.
   std::string documentation;
 
   /// The parameters of this signature.
   std::vector<ParameterInformation> parameters;
-
-  static json::Expr unparse(const SignatureInformation &);
 };
+json::Expr serialize(const SignatureInformation &);
 
 /// Represents the signature of a callable.
 struct SignatureHelp {
 
   /// The resulting signatures.
   std::vector<SignatureInformation> signatures;
 
   /// The active signature.
   int activeSignature = 0;
 
   /// The active parameter of the active signature.
   int activeParameter = 0;
-
-  static json::Expr unparse(const SignatureHelp &);
 };
+json::Expr serialize(const SignatureHelp &);
 
 struct RenameParams {
   /// The document that was opened.
   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(const json::Expr &Params);
 };
+bool deserialize(const json::Expr &, RenameParams &);
 
 } // 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 "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 {
-// Helper for mapping JSON objects onto our protocol structs. Intended use:
-// Optional<Result> parse(json::Expr E) {
-//   ObjectParser O(E);
-//   if (!O || !O.parse("mandatory_field", Result.MandatoryField))
-//     return None;
-//   O.parse("optional_field", Result.OptionalField);
-//   return Result;
-// }
-// FIXME: the static methods here should probably become the public parse()
-// extension point. Overloading free functions allows us to uniformly handle
-// enums, vectors, etc.
-class ObjectParser {
-public:
-  ObjectParser(const json::Expr &E) : O(E.asObject()) {}
-
-  // True if the expression is an object.
-  operator bool() { return O; }
-
-  template <typename T> bool parse(const char *Prop, T &Out) {
-    assert(*this && "Must check this is an object before calling parse()");
-    if (const json::Expr *E = O->get(Prop))
-      return parse(*E, Out);
-    return false;
-  }
-
-  // Optional requires special handling, because missing keys are OK.
-  template <typename T> bool parse(const char *Prop, llvm::Optional<T> &Out) {
-    assert(*this && "Must check this is an object before calling parse()");
-    if (const json::Expr *E = O->get(Prop))
-      return parse(*E, Out);
-    Out = None;
-    return true;
-  }
-
-private:
-  // Primitives.
-  static bool parse(const json::Expr &E, std::string &Out) {
-    if (auto S = E.asString()) {
-      Out = *S;
-      return true;
-    }
-    return false;
-  }
-
-  static bool parse(const json::Expr &E, int &Out) {
-    if (auto S = E.asInteger()) {
-      Out = *S;
-      return true;
-    }
-    return false;
-  }
-
-  static bool parse(const json::Expr &E, bool &Out) {
-    if (auto S = E.asBoolean()) {
-      Out = *S;
-      return true;
-    }
-    return false;
-  }
-
-  // Types with a parse() function.
-  template <typename T> static bool parse(const json::Expr &E, T &Out) {
-    if (auto Parsed = std::remove_reference<T>::type::parse(E)) {
-      Out = std::move(*Parsed);
-      return true;
-    }
-    return false;
-  }
-
-  // Nullable values as Optional<T>.
-  template <typename T>
-  static bool parse(const json::Expr &E, llvm::Optional<T> &Out) {
-    if (E.asNull()) {
-      Out = None;
-      return true;
-    }
-    T Result;
-    if (!parse(E, Result))
-      return false;
-    Out = std::move(Result);
-    return true;
-  }
-
-  // Array values with std::vector type.
-  template <typename T>
-  static bool parse(const json::Expr &E, std::vector<T> &Out) {
-    if (auto *A = E.asArray()) {
-      Out.clear();
-      Out.resize(A->size());
-      for (size_t I = 0; I < A->size(); ++I)
-        if (!parse((*A)[I], Out[I]))
-          return false;
-      return true;
-    }
-    return false;
-  }
-
-  // Object values with std::map<std::string, ?>
-  template <typename T>
-  static bool parse(const json::Expr &E, std::map<std::string, T> &Out) {
-    if (auto *O = E.asObject()) {
-      for (const auto &KV : *O)
-        if (!parse(KV.second, Out[StringRef(KV.first)]))
-          return false;
-      return true;
-    }
-    return false;
-  }
-
-  // Special cased enums, which can't have T::parse() functions.
-  // FIXME: make everything free functions so there's no special casing.
-  static bool parse(const json::Expr &E, TraceLevel &Out) {
-    if (auto S = E.asString()) {
-      if (*S == "off") {
-        Out = TraceLevel::Off;
-        return true;
-      } else if (*S == "messages") {
-        Out = TraceLevel::Messages;
-        return true;
-      } else if (*S == "verbose") {
-        Out = TraceLevel::Verbose;
-        return true;
-      }
-    }
-    return false;
-  }
-
-  static bool parse(const json::Expr &E, FileChangeType &Out) {
-    if (auto T = E.asInteger()) {
-      if (*T < static_cast<int>(FileChangeType::Created) ||
-          *T > static_cast<int>(FileChangeType::Deleted))
-        return false;
-      Out = static_cast<FileChangeType>(*T);
-      return true;
-    }
-    return false;
-  }
-
-  const json::obj *O;
-};
-} // namespace
+namespace clang {
+namespace clangd {
 
 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:
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;
 }
 
-llvm::Optional<URI> URI::parse(const json::Expr &E) {
-  if (auto S = E.asString())
-    return fromUri(*S);
-  return None;
+bool deserialize(const json::Expr &E, URI &R) {
+  if (auto S = E.asString()) {
+    R = URI::fromUri(*S);
+    return true;
+  }
+  return false;
 }
 
-json::Expr URI::unparse(const URI &U) { return U.uri; }
+json::Expr serialize(const URI &U) { return U.uri; }
 
-llvm::Optional<TextDocumentIdentifier>
-TextDocumentIdentifier::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  TextDocumentIdentifier R;
-  if (!O || !O.parse("uri", R.uri))
-    return None;
-  return R;
+bool deserialize(const json::Expr &Params, TextDocumentIdentifier &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("uri", R.uri);
 }
 
-llvm::Optional<Position> Position::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  Position R;
-  if (!O || !O.parse("line", R.line) || !O.parse("character", R.character))
-    return None;
-  return R;
+bool deserialize(const json::Expr &Params, Position &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("line", R.line) && O.map("character", R.character);
 }
 
-json::Expr Position::unparse(const Position &P) {
+json::Expr serialize(const Position &P) {
   return json::obj{
       {"line", P.line},
       {"character", P.character},
   };
 }
 
-llvm::Optional<Range> Range::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  Range R;
-  if (!O || !O.parse("start", R.start) || !O.parse("end", R.end))
-    return None;
-  return R;
+bool deserialize(const json::Expr &Params, Range &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("start", R.start) && O.map("end", R.end);
 }
 
-json::Expr Range::unparse(const Range &P) {
+json::Expr serialize(const Range &P) {
   return json::obj{
       {"start", P.start},
       {"end", P.end},
   };
 }
 
-json::Expr Location::unparse(const Location &P) {
+json::Expr serialize(const Location &P) {
   return json::obj{
       {"uri", P.uri},
       {"range", P.range},
   };
 }
 
-llvm::Optional<TextDocumentItem>
-TextDocumentItem::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  TextDocumentItem R;
-  if (!O || !O.parse("uri", R.uri) || !O.parse("languageId", R.languageId) ||
-      !O.parse("version", R.version) || !O.parse("text", R.text))
-    return None;
-  return R;
+bool deserialize(const json::Expr &Params, TextDocumentItem &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("uri", R.uri) && O.map("languageId", R.languageId) &&
+         O.map("version", R.version) && O.map("text", R.text);
 }
 
-llvm::Optional<Metadata> Metadata::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  Metadata R;
+bool deserialize(const json::Expr &Params, Metadata &R) {
+  json::ObjectMapper O(Params);
   if (!O)
-    return None;
-  O.parse("extraFlags", R.extraFlags);
-  return R;
+    return false;
+  O.map("extraFlags", R.extraFlags);
+  return true;
 }
 
-llvm::Optional<TextEdit> TextEdit::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  TextEdit R;
-  if (!O || !O.parse("range", R.range) || !O.parse("newText", R.newText))
-    return None;
-  return R;
+bool deserialize(const json::Expr &Params, TextEdit &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("range", R.range) && O.map("newText", R.newText);
 }
 
-json::Expr TextEdit::unparse(const TextEdit &P) {
+json::Expr serialize(const TextEdit &P) {
   return json::obj{
       {"range", P.range},
       {"newText", P.newText},
   };
 }
 
-llvm::Optional<InitializeParams>
-InitializeParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  InitializeParams R;
+bool deserialize(const json::Expr &E, TraceLevel &Out) {
+  if (auto S = E.asString()) {
+    if (*S == "off") {
+      Out = TraceLevel::Off;
+      return true;
+    } else if (*S == "messages") {
+      Out = TraceLevel::Messages;
+      return true;
+    } else if (*S == "verbose") {
+      Out = TraceLevel::Verbose;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool deserialize(const json::Expr &Params, InitializeParams &R) {
+  json::ObjectMapper O(Params);
   if (!O)
-    return None;
+    return false;
   // We deliberately don't fail if we can't parse individual fields.
   // Failing to handle a slightly malformed initialize would be a disaster.
-  O.parse("processId", R.processId);
-  O.parse("rootUri", R.rootUri);
-  O.parse("rootPath", R.rootPath);
-  O.parse("trace", R.trace);
+  O.map("processId", R.processId);
+  O.map("rootUri", R.rootUri);
+  O.map("rootPath", R.rootPath);
+  O.map("trace", R.trace);
   // initializationOptions, capabilities unused
-  return R;
+  return true;
+}
+
+bool deserialize(const json::Expr &Params, DidOpenTextDocumentParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("textDocument", R.textDocument) &&
+         O.map("metadata", R.metadata);
+}
+
+bool deserialize(const json::Expr &Params, DidCloseTextDocumentParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("textDocument", R.textDocument);
+}
+
+bool deserialize(const json::Expr &Params, DidChangeTextDocumentParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("textDocument", R.textDocument) &&
+         O.map("contentChanges", R.contentChanges);
+}
+
+bool deserialize(const json::Expr &E, FileChangeType &Out) {
+  if (auto T = E.asInteger()) {
+    if (*T < static_cast<int>(FileChangeType::Created) ||
+        *T > static_cast<int>(FileChangeType::Deleted))
+      return false;
+    Out = static_cast<FileChangeType>(*T);
+    return true;
+  }
+  return false;
 }
 
-llvm::Optional<DidOpenTextDocumentParams>
-DidOpenTextDocumentParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  DidOpenTextDocumentParams R;
-  if (!O || !O.parse("textDocument", R.textDocument) ||
-      !O.parse("metadata", R.metadata))
-    return None;
-  return R;
-}
-
-llvm::Optional<DidCloseTextDocumentParams>
-DidCloseTextDocumentParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  DidCloseTextDocumentParams R;
-  if (!O || !O.parse("textDocument", R.textDocument))
-    return None;
-  return R;
-}
-
-llvm::Optional<DidChangeTextDocumentParams>
-DidChangeTextDocumentParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  DidChangeTextDocumentParams R;
-  if (!O || !O.parse("textDocument", R.textDocument) ||
-      !O.parse("contentChanges", R.contentChanges))
-    return None;
-  return R;
-}
-
-llvm::Optional<FileEvent> FileEvent::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  FileEvent R;
-  if (!O || !O.parse("uri", R.uri) || !O.parse("type", R.type))
-    return None;
-  return R;
-}
-
-llvm::Optional<DidChangeWatchedFilesParams>
-DidChangeWatchedFilesParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  DidChangeWatchedFilesParams R;
-  if (!O || !O.parse("changes", R.changes))
-    return None;
-  return R;
-}
-
-llvm::Optional<TextDocumentContentChangeEvent>
-TextDocumentContentChangeEvent::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  TextDocumentContentChangeEvent R;
-  if (!O || !O.parse("text", R.text))
-    return None;
-  return R;
-}
-
-llvm::Optional<FormattingOptions>
-FormattingOptions::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  FormattingOptions R;
-  if (!O || !O.parse("tabSize", R.tabSize) ||
-      !O.parse("insertSpaces", R.insertSpaces))
-    return None;
-  return R;
+bool deserialize(const json::Expr &Params, FileEvent &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("uri", R.uri) && O.map("type", R.type);
 }
 
-json::Expr FormattingOptions::unparse(const FormattingOptions &P) {
+bool deserialize(const json::Expr &Params, DidChangeWatchedFilesParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("changes", R.changes);
+}
+
+bool deserialize(const json::Expr &Params, TextDocumentContentChangeEvent &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("text", R.text);
+}
+
+bool deserialize(const json::Expr &Params, FormattingOptions &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("tabSize", R.tabSize) &&
+         O.map("insertSpaces", R.insertSpaces);
+}
+
+json::Expr serialize(const FormattingOptions &P) {
   return json::obj{
       {"tabSize", P.tabSize},
       {"insertSpaces", P.insertSpaces},
   };
 }
 
-llvm::Optional<DocumentRangeFormattingParams>
-DocumentRangeFormattingParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  DocumentRangeFormattingParams R;
-  if (!O || !O.parse("textDocument", R.textDocument) ||
-      !O.parse("range", R.range) || !O.parse("options", R.options))
-    return None;
-  return R;
-}
-
-llvm::Optional<DocumentOnTypeFormattingParams>
-DocumentOnTypeFormattingParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  DocumentOnTypeFormattingParams R;
-  if (!O || !O.parse("textDocument", R.textDocument) ||
-      !O.parse("position", R.position) || !O.parse("ch", R.ch) ||
-      !O.parse("options", R.options))
-    return None;
-  return R;
-}
-
-llvm::Optional<DocumentFormattingParams>
-DocumentFormattingParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  DocumentFormattingParams R;
-  if (!O || !O.parse("textDocument", R.textDocument) ||
-      !O.parse("options", R.options))
-    return None;
-  return R;
-}
-
-llvm::Optional<Diagnostic> Diagnostic::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  Diagnostic R;
-  if (!O || !O.parse("range", R.range) || !O.parse("message", R.message))
-    return None;
-  O.parse("severity", R.severity);
-  return R;
-}
-
-llvm::Optional<CodeActionContext>
-CodeActionContext::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  CodeActionContext R;
-  if (!O || !O.parse("diagnostics", R.diagnostics))
-    return None;
-  return R;
-}
-
-llvm::Optional<CodeActionParams>
-CodeActionParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  CodeActionParams R;
-  if (!O || !O.parse("textDocument", R.textDocument) ||
-      !O.parse("range", R.range) || !O.parse("context", R.context))
-    return None;
-  return R;
-}
-
-llvm::Optional<WorkspaceEdit> WorkspaceEdit::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  WorkspaceEdit R;
-  if (!O || !O.parse("changes", R.changes))
-    return None;
-  return R;
+bool deserialize(const json::Expr &Params, DocumentRangeFormattingParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("textDocument", R.textDocument) &&
+         O.map("range", R.range) && O.map("options", R.options);
+}
+
+bool deserialize(const json::Expr &Params, DocumentOnTypeFormattingParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("textDocument", R.textDocument) &&
+         O.map("position", R.position) && O.map("ch", R.ch) &&
+         O.map("options", R.options);
+}
+
+bool deserialize(const json::Expr &Params, DocumentFormattingParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("textDocument", R.textDocument) &&
+         O.map("options", R.options);
+}
+
+bool deserialize(const json::Expr &Params, Diagnostic &R) {
+  json::ObjectMapper O(Params);
+  if (!O || !O.map("range", R.range) || !O.map("message", R.message))
+    return false;
+  O.map("severity", R.severity);
+  return true;
+}
+
+bool deserialize(const json::Expr &Params, CodeActionContext &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("diagnostics", R.diagnostics);
+}
+
+bool deserialize(const json::Expr &Params, CodeActionParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("textDocument", R.textDocument) &&
+         O.map("range", R.range) && O.map("context", R.context);
+}
+
+bool deserialize(const json::Expr &Params, WorkspaceEdit &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("changes", R.changes);
 }
 
 const std::string ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND =
     "clangd.applyFix";
 
-llvm::Optional<ExecuteCommandParams>
-ExecuteCommandParams::parse(const json::Expr &Params) {
-  const json::obj *O = Params.asObject();
-  if (!O)
-    return None;
+bool deserialize(const json::Expr &Params, ExecuteCommandParams &R) {
+  json::ObjectMapper O(Params);
+  if (!O || !O.map("command", R.command))
+    return false;
 
-  ExecuteCommandParams Result;
-  if (auto Command = O->getString("command"))
-    Result.command = *Command;
-  auto Args = O->getArray("arguments");
-
-  if (Result.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND) {
-    if (!Args || Args->size() != 1)
-      return llvm::None;
-    if (auto Parsed = WorkspaceEdit::parse(Args->front()))
-      Result.workspaceEdit = std::move(*Parsed);
-    else
-      return llvm::None;
-  } else
-    return llvm::None; // Unrecognized command.
-  return Result;
+  auto Args = Params.asObject()->getArray("arguments");
+  if (R.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND) {
+    return Args && Args->size() == 1 &&
+           deserialize(Args->front(), R.workspaceEdit);
+  }
+  return false; // Unrecognized command.
 }
 
-json::Expr WorkspaceEdit::unparse(const WorkspaceEdit &WE) {
+json::Expr serialize(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) {
+json::Expr serialize(const ApplyWorkspaceEditParams &Params) {
   return json::obj{{"edit", Params.edit}};
 }
 
-llvm::Optional<TextDocumentPositionParams>
-TextDocumentPositionParams::parse(const json::Expr &Params) {
-  ObjectParser O(Params);
-  TextDocumentPositionParams R;
-  if (!O || !O.parse("textDocument", R.textDocument) ||
-      !O.parse("position", R.position))
-    return None;
-  return R;
+bool deserialize(const json::Expr &Params, TextDocumentPositionParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("textDocument", R.textDocument) &&
+         O.map("position", R.position);
 }
 
-json::Expr CompletionItem::unparse(const CompletionItem &CI) {
+json::Expr serialize(const CompletionItem &CI) {
   assert(!CI.label.empty() && "completion item label is required");
   json::obj Result{{"label", CI.label}};
   if (CI.kind != CompletionItemKind::Missing)
     Result["kind"] = static_cast<int>(CI.kind);
   if (!CI.detail.empty())
     Result["detail"] = CI.detail;
   if (!CI.documentation.empty())
     Result["documentation"] = CI.documentation;
   if (!CI.sortText.empty())
     Result["sortText"] = CI.sortText;
   if (!CI.filterText.empty())
     Result["filterText"] = CI.filterText;
   if (!CI.insertText.empty())
     Result["insertText"] = CI.insertText;
   if (CI.insertTextFormat != InsertTextFormat::Missing)
     Result["insertTextFormat"] = static_cast<int>(CI.insertTextFormat);
   if (CI.textEdit)
     Result["textEdit"] = *CI.textEdit;
   if (!CI.additionalTextEdits.empty())
     Result["additionalTextEdits"] = json::ary(CI.additionalTextEdits);
   return std::move(Result);
 }
 
-bool clangd::operator<(const CompletionItem &L, const CompletionItem &R) {
+bool operator<(const CompletionItem &L, const CompletionItem &R) {
   return (L.sortText.empty() ? L.label : L.sortText) <
          (R.sortText.empty() ? R.label : R.sortText);
 }
 
-json::Expr CompletionList::unparse(const CompletionList &L) {
+json::Expr serialize(const CompletionList &L) {
   return json::obj{
       {"isIncomplete", L.isIncomplete},
       {"items", json::ary(L.items)},
   };
 }
 
-json::Expr ParameterInformation::unparse(const ParameterInformation &PI) {
+json::Expr serialize(const ParameterInformation &PI) {
   assert(!PI.label.empty() && "parameter information label is required");
   json::obj Result{{"label", PI.label}};
   if (!PI.documentation.empty())
     Result["documentation"] = PI.documentation;
   return std::move(Result);
 }
 
-json::Expr SignatureInformation::unparse(const SignatureInformation &SI) {
+json::Expr serialize(const SignatureInformation &SI) {
   assert(!SI.label.empty() && "signature information label is required");
   json::obj Result{
       {"label", SI.label},
       {"parameters", json::ary(SI.parameters)},
   };
   if (!SI.documentation.empty())
     Result["documentation"] = SI.documentation;
   return std::move(Result);
 }
 
-json::Expr SignatureHelp::unparse(const SignatureHelp &SH) {
+json::Expr serialize(const SignatureHelp &SH) {
   assert(SH.activeSignature >= 0 &&
          "Unexpected negative value for number of active signatures.");
   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(const json::Expr &Params) {
-  ObjectParser O(Params);
-  RenameParams R;
-  if (!O || !O.parse("textDocument", R.textDocument) ||
-      !O.parse("position", R.position) || !O.parse("newName", R.newName))
-    return None;
-  return R;
+bool deserialize(const json::Expr &Params, RenameParams &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("textDocument", R.textDocument) &&
+         O.map("position", R.position) && O.map("newName", R.newName);
 }
+
+} // namespace clangd
+} // namespace clang

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(const json::Expr&).
+// FooParams should have a JSON deserialize function.
 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, const json::Expr &RawParams) {
-          if (auto P = [&] {
-                trace::Span Tracer("Parse");
-                return std::decay<Param>::type::parse(RawParams);
-              }()) {
-            (Callbacks->*Handler)(std::move(C), *P);
+          typename std::remove_reference<Param>::type P;
+          if (deserialize(RawParams, P)) {
+            (Callbacks->*Handler)(std::move(C), P);
           } else {
             Out->log("Failed to decode " + Method + " request.\n");
           }
         });
   }
 
   JSONRPCDispatcher &Dispatcher;
   JSONOutput *Out;

test/clangd/trace.test

 # RUN: clangd -pretty -run-synchronously -trace %t < %s && FileCheck %s < %t
 # It is absolutely vital that this file has CRLF line endings.
 #
 Content-Length: 125
 
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
 #
 Content-Length: 152
 
 {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///foo.c","languageId":"c","version":1,"text":"void main() {}"}}}
 #      CHECK: {"displayTimeUnit":"ns","traceEvents":[
 # Start opening the doc.
 #      CHECK: "name": "textDocument/didOpen"
-#      CHECK: "ph": "E"
+#      CHECK: "ph": "B"
 # Start building the preamble.
 #      CHECK: "name": "Preamble"
 #      CHECK: },
 # Finish building the preamble, with filename.
 #      CHECK: "File": "/foo.c"
 # CHECK-NEXT: },
 # CHECK-NEXT: "ph": "E"
 # Start building the file.
 #      CHECK: "name": "Build"
 Content-Length: 44
 
 {"jsonrpc":"2.0","id":5,"method":"shutdown"}

unittests/clangd/JSONExprTests.cpp

if (I++ == 5) {
       ASSERT_TRUE(E.asObject());
       EXPECT_EQ(E.asObject()->getString("time"),
                 llvm::Optional<llvm::StringRef>("arrow"));
     } else
       EXPECT_FALSE(E.asObject());
   }
 }
 
+// Sample struct with typical JSON-mapping rules.
+struct CustomStruct {
+  CustomStruct() : B(false) {}
+  CustomStruct(std::string S, llvm::Optional<int> I, bool B)
+      : S(S), I(I), B(B) {}
+  std::string S;
+  llvm::Optional<int> I;
+  bool B;
+};
+inline bool operator==(const CustomStruct &L, const CustomStruct &R) {
+  return L.S == R.S && L.I == R.I && L.B == R.B;
+}
+inline std::ostream &operator<<(std::ostream &OS, const CustomStruct &S) {
+  return OS << "(" << S.S << ", " << (S.I ? std::to_string(*S.I) : "None")
+            << ", " << S.B << ")";
+}
+bool deserialize(const json::Expr &E, CustomStruct &R) {
+  ObjectMapper O(E);
+  if (!O || !O.map("str", R.S) || !O.map("int", R.I))
+    return false;
+  O.map("bool", R.B);
+  return true;
+}
+
+TEST(JSONTest, Deserialize) {
+  std::map<std::string, std::vector<CustomStruct>> R;
+  CustomStruct ExpectedStruct = {"foo", 42, true};
+  std::map<std::string, std::vector<CustomStruct>> Expected;
+  Expr J = obj{{"foo", ary{
+                           obj{
+                               {"str", "foo"},
+                               {"int", 42},
+                               {"bool", true},
+                               {"unknown", "ignored"},
+                           },
+                           obj{{"str", "bar"}},
+                           obj{
+                               {"str", "baz"},
+                               {"bool", "string"}, // OK, deserialize ignores.
+                           },
+                       }}};
+  Expected["foo"] = {
+      CustomStruct("foo", 42, true),
+      CustomStruct("bar", llvm::None, false),
+      CustomStruct("baz", llvm::None, false),
+  };
+  ASSERT_TRUE(deserialize(J, R));
+  EXPECT_EQ(R, Expected);
+
+  CustomStruct V;
+  EXPECT_FALSE(deserialize(nullptr, V)) << "Not an object " << V;
+  EXPECT_FALSE(deserialize(obj{}, V)) << "Missing required field " << V;
+  EXPECT_FALSE(deserialize(obj{{"str", 1}}, V)) << "Wrong type " << V;
+  // Optional<T> must parse as the correct type if present.
+  EXPECT_FALSE(deserialize(obj{{"str", 1}, {"int", "string"}}, V))
+      << "Wrong type for Optional<T> " << V;
+}
+
 } // namespace
 } // namespace json
 } // namespace clangd
 } // namespace clang