1//===--- Protocol.cpp - Language Server Protocol Implementation -----------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains the serialization code for the LSP structs.
10//
11//===----------------------------------------------------------------------===//
12
13#include "Protocol.h"
14#include "URI.h"
15#include "support/Logger.h"
16#include "clang/Basic/LLVM.h"
17#include "clang/Index/IndexSymbol.h"
18#include "llvm/ADT/StringExtras.h"
19#include "llvm/ADT/StringRef.h"
20#include "llvm/ADT/StringSwitch.h"
21#include "llvm/Support/ErrorHandling.h"
22#include "llvm/Support/JSON.h"
23#include "llvm/Support/Path.h"
24#include "llvm/Support/raw_ostream.h"
25
26namespace clang {
27namespace clangd {
28namespace {
29
30// Helper that doesn't treat `null` and absent fields as failures.
31template <typename T>
32bool mapOptOrNull(const llvm::json::Value &Params, llvm::StringLiteral Prop,
33 T &Out, llvm::json::Path P) {
34 auto *O = Params.getAsObject();
35 assert(O);
36 auto *V = O->get(Prop);
37 // Field is missing or null.
38 if (!V || V->getAsNull())
39 return true;
40 return fromJSON(*V, Out, P.field(Prop));
41}
42} // namespace
43
44char LSPError::ID;
45
46URIForFile URIForFile::canonicalize(llvm::StringRef AbsPath,
47 llvm::StringRef TUPath) {
48 assert(llvm::sys::path::is_absolute(AbsPath) && "the path is relative");
49 auto Resolved = URI::resolvePath(AbsPath, TUPath);
50 if (!Resolved) {
51 elog("URIForFile: failed to resolve path {0} with TU path {1}: "
52 "{2}.\nUsing unresolved path.",
53 AbsPath, TUPath, Resolved.takeError());
54 return URIForFile(std::string(AbsPath));
55 }
56 return URIForFile(std::move(*Resolved));
57}
58
59llvm::Expected<URIForFile> URIForFile::fromURI(const URI &U,
60 llvm::StringRef HintPath) {
61 auto Resolved = URI::resolve(U, HintPath);
62 if (!Resolved)
63 return Resolved.takeError();
64 return URIForFile(std::move(*Resolved));
65}
66
67bool fromJSON(const llvm::json::Value &E, URIForFile &R, llvm::json::Path P) {
68 if (auto S = E.getAsString()) {
69 auto Parsed = URI::parse(*S);
70 if (!Parsed) {
71 consumeError(Parsed.takeError());
72 P.report("failed to parse URI");
73 return false;
74 }
75 if (Parsed->scheme() != "file" && Parsed->scheme() != "test") {
76 P.report("clangd only supports 'file' URI scheme for workspace files");
77 return false;
78 }
79 // "file" and "test" schemes do not require hint path.
80 auto U = URIForFile::fromURI(*Parsed, /*HintPath=*/"");
81 if (!U) {
82 P.report("unresolvable URI");
83 consumeError(U.takeError());
84 return false;
85 }
86 R = std::move(*U);
87 return true;
88 }
89 return false;
90}
91
92llvm::json::Value toJSON(const URIForFile &U) { return U.uri(); }
93
94llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const URIForFile &U) {
95 return OS << U.uri();
96}
97
98llvm::json::Value toJSON(const TextDocumentIdentifier &R) {
99 return llvm::json::Object{{"uri", R.uri}};
100}
101
102bool fromJSON(const llvm::json::Value &Params, TextDocumentIdentifier &R,
103 llvm::json::Path P) {
104 llvm::json::ObjectMapper O(Params, P);
105 return O && O.map("uri", R.uri);
106}
107
108llvm::json::Value toJSON(const VersionedTextDocumentIdentifier &R) {
109 auto Result = toJSON(static_cast<const TextDocumentIdentifier &>(R));
110 Result.getAsObject()->try_emplace("version", R.version);
111 return Result;
112}
113
114bool fromJSON(const llvm::json::Value &Params,
115 VersionedTextDocumentIdentifier &R, llvm::json::Path P) {
116 llvm::json::ObjectMapper O(Params, P);
117 return fromJSON(Params, static_cast<TextDocumentIdentifier &>(R), P) && O &&
118 O.map("version", R.version);
119}
120
121bool fromJSON(const llvm::json::Value &Params, Position &R,
122 llvm::json::Path P) {
123 llvm::json::ObjectMapper O(Params, P);
124 return O && O.map("line", R.line) && O.map("character", R.character);
125}
126
127llvm::json::Value toJSON(const Position &P) {
128 return llvm::json::Object{
129 {"line", P.line},
130 {"character", P.character},
131 };
132}
133
134llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Position &P) {
135 return OS << P.line << ':' << P.character;
136}
137
138bool fromJSON(const llvm::json::Value &Params, Range &R, llvm::json::Path P) {
139 llvm::json::ObjectMapper O(Params, P);
140 return O && O.map("start", R.start) && O.map("end", R.end);
141}
142
143llvm::json::Value toJSON(const Range &P) {
144 return llvm::json::Object{
145 {"start", P.start},
146 {"end", P.end},
147 };
148}
149
150llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Range &R) {
151 return OS << R.start << '-' << R.end;
152}
153
154llvm::json::Value toJSON(const Location &P) {
155 return llvm::json::Object{
156 {"uri", P.uri},
157 {"range", P.range},
158 };
159}
160
161llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Location &L) {
162 return OS << L.range << '@' << L.uri;
163}
164
165llvm::json::Value toJSON(const ReferenceLocation &P) {
166 llvm::json::Object Result{
167 {"uri", P.uri},
168 {"range", P.range},
169 };
170 if (P.containerName)
171 Result.insert({"containerName", P.containerName});
172 return Result;
173}
174
175llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
176 const ReferenceLocation &L) {
177 return OS << L.range << '@' << L.uri << " (container: " << L.containerName
178 << ")";
179}
180
181bool fromJSON(const llvm::json::Value &Params, TextDocumentItem &R,
182 llvm::json::Path P) {
183 llvm::json::ObjectMapper O(Params, P);
184 return O && O.map("uri", R.uri) && O.map("languageId", R.languageId) &&
185 O.map("version", R.version) && O.map("text", R.text);
186}
187
188bool fromJSON(const llvm::json::Value &Params, TextEdit &R,
189 llvm::json::Path P) {
190 llvm::json::ObjectMapper O(Params, P);
191 return O && O.map("range", R.range) && O.map("newText", R.newText) &&
192 O.mapOptional("annotationId", R.annotationId);
193}
194
195llvm::json::Value toJSON(const TextEdit &P) {
196 llvm::json::Object Result{
197 {"range", P.range},
198 {"newText", P.newText},
199 };
200 if (!P.annotationId.empty())
201 Result["annotationId"] = P.annotationId;
202 return Result;
203}
204
205bool fromJSON(const llvm::json::Value &Params, ChangeAnnotation &R,
206 llvm::json::Path P) {
207 llvm::json::ObjectMapper O(Params, P);
208 return O && O.map("label", R.label) &&
209 O.map("needsConfirmation", R.needsConfirmation) &&
210 O.mapOptional("description", R.description);
211}
212llvm::json::Value toJSON(const ChangeAnnotation & CA) {
213 llvm::json::Object Result{{"label", CA.label}};
214 if (CA.needsConfirmation)
215 Result["needsConfirmation"] = *CA.needsConfirmation;
216 if (!CA.description.empty())
217 Result["description"] = CA.description;
218 return Result;
219}
220
221bool fromJSON(const llvm::json::Value &Params, TextDocumentEdit &R,
222 llvm::json::Path P) {
223 llvm::json::ObjectMapper O(Params, P);
224 return O && O.map("textDocument", R.textDocument) && O.map("edits", R.edits);
225}
226llvm::json::Value toJSON(const TextDocumentEdit &P) {
227 llvm::json::Object Result{{"textDocument", P.textDocument},
228 {"edits", P.edits}};
229 return Result;
230}
231
232llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const TextEdit &TE) {
233 OS << TE.range << " => \"";
234 llvm::printEscapedString(TE.newText, OS);
235 return OS << '"';
236}
237
238bool fromJSON(const llvm::json::Value &E, TraceLevel &Out, llvm::json::Path P) {
239 if (auto S = E.getAsString()) {
240 if (*S == "off") {
241 Out = TraceLevel::Off;
242 return true;
243 }
244 if (*S == "messages") {
245 Out = TraceLevel::Messages;
246 return true;
247 }
248 if (*S == "verbose") {
249 Out = TraceLevel::Verbose;
250 return true;
251 }
252 }
253 return false;
254}
255
256bool fromJSON(const llvm::json::Value &E, SymbolKind &Out, llvm::json::Path P) {
257 if (auto T = E.getAsInteger()) {
258 if (*T < static_cast<int>(SymbolKind::File) ||
259 *T > static_cast<int>(SymbolKind::TypeParameter))
260 return false;
261 Out = static_cast<SymbolKind>(*T);
262 return true;
263 }
264 return false;
265}
266
267bool fromJSON(const llvm::json::Value &E, SymbolKindBitset &Out,
268 llvm::json::Path P) {
269 if (auto *A = E.getAsArray()) {
270 for (size_t I = 0; I < A->size(); ++I) {
271 SymbolKind KindOut;
272 if (fromJSON((*A)[I], KindOut, P.index(I)))
273 Out.set(size_t(KindOut));
274 }
275 return true;
276 }
277 return false;
278}
279
280SymbolKind adjustKindToCapability(SymbolKind Kind,
281 SymbolKindBitset &SupportedSymbolKinds) {
282 auto KindVal = static_cast<size_t>(Kind);
283 if (KindVal >= SymbolKindMin && KindVal <= SupportedSymbolKinds.size() &&
284 SupportedSymbolKinds[KindVal])
285 return Kind;
286
287 switch (Kind) {
288 // Provide some fall backs for common kinds that are close enough.
289 case SymbolKind::Struct:
290 return SymbolKind::Class;
291 case SymbolKind::EnumMember:
292 return SymbolKind::Enum;
293 default:
294 return SymbolKind::String;
295 }
296}
297
298SymbolKind indexSymbolKindToSymbolKind(index::SymbolKind Kind) {
299 switch (Kind) {
300 case index::SymbolKind::Unknown:
301 return SymbolKind::Variable;
302 case index::SymbolKind::Module:
303 return SymbolKind::Module;
304 case index::SymbolKind::Namespace:
305 return SymbolKind::Namespace;
306 case index::SymbolKind::NamespaceAlias:
307 return SymbolKind::Namespace;
308 case index::SymbolKind::Macro:
309 return SymbolKind::String;
310 case index::SymbolKind::Enum:
311 return SymbolKind::Enum;
312 case index::SymbolKind::Struct:
313 return SymbolKind::Struct;
314 case index::SymbolKind::Class:
315 return SymbolKind::Class;
316 case index::SymbolKind::Protocol:
317 return SymbolKind::Interface;
318 case index::SymbolKind::Extension:
319 return SymbolKind::Interface;
320 case index::SymbolKind::Union:
321 return SymbolKind::Class;
322 case index::SymbolKind::TypeAlias:
323 return SymbolKind::Class;
324 case index::SymbolKind::Function:
325 return SymbolKind::Function;
326 case index::SymbolKind::Variable:
327 return SymbolKind::Variable;
328 case index::SymbolKind::Field:
329 return SymbolKind::Field;
330 case index::SymbolKind::EnumConstant:
331 return SymbolKind::EnumMember;
332 case index::SymbolKind::InstanceMethod:
333 case index::SymbolKind::ClassMethod:
334 case index::SymbolKind::StaticMethod:
335 return SymbolKind::Method;
336 case index::SymbolKind::InstanceProperty:
337 case index::SymbolKind::ClassProperty:
338 case index::SymbolKind::StaticProperty:
339 return SymbolKind::Property;
340 case index::SymbolKind::Constructor:
341 case index::SymbolKind::Destructor:
342 return SymbolKind::Constructor;
343 case index::SymbolKind::ConversionFunction:
344 return SymbolKind::Function;
345 case index::SymbolKind::Parameter:
346 case index::SymbolKind::NonTypeTemplateParm:
347 return SymbolKind::Variable;
348 case index::SymbolKind::Using:
349 return SymbolKind::Namespace;
350 case index::SymbolKind::TemplateTemplateParm:
351 case index::SymbolKind::TemplateTypeParm:
352 return SymbolKind::TypeParameter;
353 case index::SymbolKind::Concept:
354 return SymbolKind::Interface;
355 }
356 llvm_unreachable("invalid symbol kind");
357}
358
359bool fromJSON(const llvm::json::Value &Params, ClientCapabilities &R,
360 llvm::json::Path P) {
361 const llvm::json::Object *O = Params.getAsObject();
362 if (!O) {
363 P.report("expected object");
364 return false;
365 }
366 if (auto *TextDocument = O->getObject("textDocument")) {
367 if (auto *SemanticHighlighting =
368 TextDocument->getObject("semanticHighlightingCapabilities")) {
369 if (auto SemanticHighlightingSupport =
370 SemanticHighlighting->getBoolean("semanticHighlighting"))
371 R.TheiaSemanticHighlighting = *SemanticHighlightingSupport;
372 }
373 if (auto *InactiveRegions =
374 TextDocument->getObject("inactiveRegionsCapabilities")) {
375 if (auto InactiveRegionsSupport =
376 InactiveRegions->getBoolean("inactiveRegions")) {
377 R.InactiveRegions = *InactiveRegionsSupport;
378 }
379 }
380 if (TextDocument->getObject("semanticTokens"))
381 R.SemanticTokens = true;
382 if (auto *Diagnostics = TextDocument->getObject("publishDiagnostics")) {
383 if (auto CategorySupport = Diagnostics->getBoolean("categorySupport"))
384 R.DiagnosticCategory = *CategorySupport;
385 if (auto CodeActions = Diagnostics->getBoolean("codeActionsInline"))
386 R.DiagnosticFixes = *CodeActions;
387 if (auto RelatedInfo = Diagnostics->getBoolean("relatedInformation"))
388 R.DiagnosticRelatedInformation = *RelatedInfo;
389 }
390 if (auto *References = TextDocument->getObject("references"))
391 if (auto ContainerSupport = References->getBoolean("container"))
392 R.ReferenceContainer = *ContainerSupport;
393 if (auto *Completion = TextDocument->getObject("completion")) {
394 if (auto *Item = Completion->getObject("completionItem")) {
395 if (auto SnippetSupport = Item->getBoolean("snippetSupport"))
396 R.CompletionSnippets = *SnippetSupport;
397 if (auto LabelDetailsSupport = Item->getBoolean("labelDetailsSupport"))
398 R.CompletionLabelDetail = *LabelDetailsSupport;
399 if (const auto *DocumentationFormat =
400 Item->getArray("documentationFormat")) {
401 for (const auto &Format : *DocumentationFormat) {
402 if (fromJSON(Format, R.CompletionDocumentationFormat, P))
403 break;
404 }
405 }
406 }
407 if (auto *ItemKind = Completion->getObject("completionItemKind")) {
408 if (auto *ValueSet = ItemKind->get("valueSet")) {
409 R.CompletionItemKinds.emplace();
410 if (!fromJSON(*ValueSet, *R.CompletionItemKinds,
411 P.field("textDocument")
412 .field("completion")
413 .field("completionItemKind")
414 .field("valueSet")))
415 return false;
416 }
417 }
418 if (auto EditsNearCursor = Completion->getBoolean("editsNearCursor"))
419 R.CompletionFixes = *EditsNearCursor;
420 }
421 if (auto *CodeAction = TextDocument->getObject("codeAction")) {
422 if (CodeAction->getObject("codeActionLiteralSupport"))
423 R.CodeActionStructure = true;
424 }
425 if (auto *DocumentSymbol = TextDocument->getObject("documentSymbol")) {
426 if (auto HierarchicalSupport =
427 DocumentSymbol->getBoolean("hierarchicalDocumentSymbolSupport"))
428 R.HierarchicalDocumentSymbol = *HierarchicalSupport;
429 }
430 if (auto *Hover = TextDocument->getObject("hover")) {
431 if (auto *ContentFormat = Hover->getArray("contentFormat")) {
432 for (const auto &Format : *ContentFormat) {
433 if (fromJSON(Format, R.HoverContentFormat, P))
434 break;
435 }
436 }
437 }
438 if (auto *Help = TextDocument->getObject("signatureHelp")) {
439 R.HasSignatureHelp = true;
440 if (auto *Info = Help->getObject("signatureInformation")) {
441 if (auto *Parameter = Info->getObject("parameterInformation")) {
442 if (auto OffsetSupport = Parameter->getBoolean("labelOffsetSupport"))
443 R.OffsetsInSignatureHelp = *OffsetSupport;
444 }
445 if (const auto *DocumentationFormat =
446 Info->getArray("documentationFormat")) {
447 for (const auto &Format : *DocumentationFormat) {
448 if (fromJSON(Format, R.SignatureHelpDocumentationFormat, P))
449 break;
450 }
451 }
452 }
453 }
454 if (auto *Folding = TextDocument->getObject("foldingRange")) {
455 if (auto LineFolding = Folding->getBoolean("lineFoldingOnly"))
456 R.LineFoldingOnly = *LineFolding;
457 }
458 if (auto *Rename = TextDocument->getObject("rename")) {
459 if (auto RenameSupport = Rename->getBoolean("prepareSupport"))
460 R.RenamePrepareSupport = *RenameSupport;
461 }
462 }
463 if (auto *Workspace = O->getObject("workspace")) {
464 if (auto *Symbol = Workspace->getObject("symbol")) {
465 if (auto *SymbolKind = Symbol->getObject("symbolKind")) {
466 if (auto *ValueSet = SymbolKind->get("valueSet")) {
467 R.WorkspaceSymbolKinds.emplace();
468 if (!fromJSON(*ValueSet, *R.WorkspaceSymbolKinds,
469 P.field("workspace")
470 .field("symbol")
471 .field("symbolKind")
472 .field("valueSet")))
473 return false;
474 }
475 }
476 }
477 if (auto *SemanticTokens = Workspace->getObject("semanticTokens")) {
478 if (auto RefreshSupport = SemanticTokens->getBoolean("refreshSupport"))
479 R.SemanticTokenRefreshSupport = *RefreshSupport;
480 }
481 if (auto *WorkspaceEdit = Workspace->getObject("workspaceEdit")) {
482 if (auto DocumentChanges = WorkspaceEdit->getBoolean("documentChanges"))
483 R.DocumentChanges = *DocumentChanges;
484 if (WorkspaceEdit->getObject("changeAnnotationSupport")) {
485 R.ChangeAnnotation = true;
486 }
487 }
488 }
489 if (auto *Window = O->getObject("window")) {
490 if (auto WorkDoneProgress = Window->getBoolean("workDoneProgress"))
491 R.WorkDoneProgress = *WorkDoneProgress;
492 if (auto Implicit = Window->getBoolean("implicitWorkDoneProgressCreate"))
493 R.ImplicitProgressCreation = *Implicit;
494 }
495 if (auto *General = O->getObject("general")) {
496 if (auto *StaleRequestSupport = General->getObject("staleRequestSupport")) {
497 if (auto Cancel = StaleRequestSupport->getBoolean("cancel"))
498 R.CancelsStaleRequests = *Cancel;
499 }
500 }
501 if (auto *OffsetEncoding = O->get("offsetEncoding")) {
502 R.offsetEncoding.emplace();
503 if (!fromJSON(*OffsetEncoding, *R.offsetEncoding,
504 P.field("offsetEncoding")))
505 return false;
506 }
507 return true;
508}
509
510bool fromJSON(const llvm::json::Value &Params, InitializeParams &R,
511 llvm::json::Path P) {
512 llvm::json::ObjectMapper O(Params, P);
513 if (!O)
514 return false;
515 // We deliberately don't fail if we can't parse individual fields.
516 // Failing to handle a slightly malformed initialize would be a disaster.
517 O.map("processId", R.processId);
518 O.map("rootUri", R.rootUri);
519 O.map("rootPath", R.rootPath);
520 O.map("capabilities", R.capabilities);
521 if (auto *RawCaps = Params.getAsObject()->getObject("capabilities"))
522 R.rawCapabilities = *RawCaps;
523 O.map("trace", R.trace);
524 O.map("initializationOptions", R.initializationOptions);
525 return true;
526}
527
528llvm::json::Value toJSON(const WorkDoneProgressCreateParams &P) {
529 return llvm::json::Object{{"token", P.token}};
530}
531
532llvm::json::Value toJSON(const WorkDoneProgressBegin &P) {
533 llvm::json::Object Result{
534 {"kind", "begin"},
535 {"title", P.title},
536 };
537 if (P.cancellable)
538 Result["cancellable"] = true;
539 if (P.percentage)
540 Result["percentage"] = 0;
541
542 // FIXME: workaround for older gcc/clang
543 return std::move(Result);
544}
545
546llvm::json::Value toJSON(const WorkDoneProgressReport &P) {
547 llvm::json::Object Result{{"kind", "report"}};
548 if (P.cancellable)
549 Result["cancellable"] = *P.cancellable;
550 if (P.message)
551 Result["message"] = *P.message;
552 if (P.percentage)
553 Result["percentage"] = *P.percentage;
554 // FIXME: workaround for older gcc/clang
555 return std::move(Result);
556}
557
558llvm::json::Value toJSON(const WorkDoneProgressEnd &P) {
559 llvm::json::Object Result{{"kind", "end"}};
560 if (P.message)
561 Result["message"] = *P.message;
562 // FIXME: workaround for older gcc/clang
563 return std::move(Result);
564}
565
566llvm::json::Value toJSON(const MessageType &R) {
567 return static_cast<int64_t>(R);
568}
569
570llvm::json::Value toJSON(const ShowMessageParams &R) {
571 return llvm::json::Object{{"type", R.type}, {"message", R.message}};
572}
573
574bool fromJSON(const llvm::json::Value &Params, DidOpenTextDocumentParams &R,
575 llvm::json::Path P) {
576 llvm::json::ObjectMapper O(Params, P);
577 return O && O.map("textDocument", R.textDocument);
578}
579
580bool fromJSON(const llvm::json::Value &Params, DidCloseTextDocumentParams &R,
581 llvm::json::Path P) {
582 llvm::json::ObjectMapper O(Params, P);
583 return O && O.map("textDocument", R.textDocument);
584}
585
586bool fromJSON(const llvm::json::Value &Params, DidSaveTextDocumentParams &R,
587 llvm::json::Path P) {
588 llvm::json::ObjectMapper O(Params, P);
589 return O && O.map("textDocument", R.textDocument);
590}
591
592bool fromJSON(const llvm::json::Value &Params, DidChangeTextDocumentParams &R,
593 llvm::json::Path P) {
594 llvm::json::ObjectMapper O(Params, P);
595 return O && O.map("textDocument", R.textDocument) &&
596 O.map("contentChanges", R.contentChanges) &&
597 O.map("wantDiagnostics", R.wantDiagnostics) &&
598 mapOptOrNull(Params, "forceRebuild", R.forceRebuild, P);
599}
600
601bool fromJSON(const llvm::json::Value &E, FileChangeType &Out,
602 llvm::json::Path P) {
603 if (auto T = E.getAsInteger()) {
604 if (*T < static_cast<int>(FileChangeType::Created) ||
605 *T > static_cast<int>(FileChangeType::Deleted))
606 return false;
607 Out = static_cast<FileChangeType>(*T);
608 return true;
609 }
610 return false;
611}
612
613bool fromJSON(const llvm::json::Value &Params, FileEvent &R,
614 llvm::json::Path P) {
615 llvm::json::ObjectMapper O(Params, P);
616 return O && O.map("uri", R.uri) && O.map("type", R.type);
617}
618
619bool fromJSON(const llvm::json::Value &Params, DidChangeWatchedFilesParams &R,
620 llvm::json::Path P) {
621 llvm::json::ObjectMapper O(Params, P);
622 return O && O.map("changes", R.changes);
623}
624
625bool fromJSON(const llvm::json::Value &Params,
626 TextDocumentContentChangeEvent &R, llvm::json::Path P) {
627 llvm::json::ObjectMapper O(Params, P);
628 return O && O.map("range", R.range) && O.map("rangeLength", R.rangeLength) &&
629 O.map("text", R.text);
630}
631
632bool fromJSON(const llvm::json::Value &Params, DocumentRangeFormattingParams &R,
633 llvm::json::Path P) {
634 llvm::json::ObjectMapper O(Params, P);
635 return O && O.map("textDocument", R.textDocument) && O.map("range", R.range);
636}
637
638bool fromJSON(const llvm::json::Value &Params,
639 DocumentOnTypeFormattingParams &R, llvm::json::Path P) {
640 llvm::json::ObjectMapper O(Params, P);
641 return O && O.map("textDocument", R.textDocument) &&
642 O.map("position", R.position) && O.map("ch", R.ch);
643}
644
645bool fromJSON(const llvm::json::Value &Params, DocumentFormattingParams &R,
646 llvm::json::Path P) {
647 llvm::json::ObjectMapper O(Params, P);
648 return O && O.map("textDocument", R.textDocument);
649}
650
651bool fromJSON(const llvm::json::Value &Params, DocumentSymbolParams &R,
652 llvm::json::Path P) {
653 llvm::json::ObjectMapper O(Params, P);
654 return O && O.map("textDocument", R.textDocument);
655}
656
657llvm::json::Value toJSON(const DiagnosticRelatedInformation &DRI) {
658 return llvm::json::Object{
659 {"location", DRI.location},
660 {"message", DRI.message},
661 };
662}
663
664llvm::json::Value toJSON(DiagnosticTag Tag) { return static_cast<int>(Tag); }
665
666llvm::json::Value toJSON(const CodeDescription &D) {
667 return llvm::json::Object{{"href", D.href}};
668}
669
670llvm::json::Value toJSON(const Diagnostic &D) {
671 llvm::json::Object Diag{
672 {"range", D.range},
673 {"severity", D.severity},
674 {"message", D.message},
675 };
676 if (D.category)
677 Diag["category"] = *D.category;
678 if (D.codeActions)
679 Diag["codeActions"] = D.codeActions;
680 if (!D.code.empty())
681 Diag["code"] = D.code;
682 if (D.codeDescription)
683 Diag["codeDescription"] = *D.codeDescription;
684 if (!D.source.empty())
685 Diag["source"] = D.source;
686 if (D.relatedInformation)
687 Diag["relatedInformation"] = *D.relatedInformation;
688 if (!D.data.empty())
689 Diag["data"] = llvm::json::Object(D.data);
690 if (!D.tags.empty())
691 Diag["tags"] = llvm::json::Array{D.tags};
692 // FIXME: workaround for older gcc/clang
693 return std::move(Diag);
694}
695
696bool fromJSON(const llvm::json::Value &Params, Diagnostic &R,
697 llvm::json::Path P) {
698 llvm::json::ObjectMapper O(Params, P);
699 if (!O)
700 return false;
701 if (auto *Data = Params.getAsObject()->getObject("data"))
702 R.data = *Data;
703 return O.map("range", R.range) && O.map("message", R.message) &&
704 mapOptOrNull(Params, "severity", R.severity, P) &&
705 mapOptOrNull(Params, "category", R.category, P) &&
706 mapOptOrNull(Params, "code", R.code, P) &&
707 mapOptOrNull(Params, "source", R.source, P);
708}
709
710llvm::json::Value toJSON(const PublishDiagnosticsParams &PDP) {
711 llvm::json::Object Result{
712 {"uri", PDP.uri},
713 {"diagnostics", PDP.diagnostics},
714 };
715 if (PDP.version)
716 Result["version"] = PDP.version;
717 return std::move(Result);
718}
719
720bool fromJSON(const llvm::json::Value &Params, CodeActionContext &R,
721 llvm::json::Path P) {
722 llvm::json::ObjectMapper O(Params, P);
723 if (!O || !O.map("diagnostics", R.diagnostics))
724 return false;
725 O.map("only", R.only);
726 return true;
727}
728
729llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Diagnostic &D) {
730 OS << D.range << " [";
731 switch (D.severity) {
732 case 1:
733 OS << "error";
734 break;
735 case 2:
736 OS << "warning";
737 break;
738 case 3:
739 OS << "note";
740 break;
741 case 4:
742 OS << "remark";
743 break;
744 default:
745 OS << "diagnostic";
746 break;
747 }
748 return OS << '(' << D.severity << "): " << D.message << "]";
749}
750
751bool fromJSON(const llvm::json::Value &Params, CodeActionParams &R,
752 llvm::json::Path P) {
753 llvm::json::ObjectMapper O(Params, P);
754 return O && O.map("textDocument", R.textDocument) &&
755 O.map("range", R.range) && O.map("context", R.context);
756}
757
758bool fromJSON(const llvm::json::Value &Params, WorkspaceEdit &R,
759 llvm::json::Path P) {
760 llvm::json::ObjectMapper O(Params, P);
761 return O && O.map("changes", R.changes) &&
762 O.map("documentChanges", R.documentChanges) &&
763 O.mapOptional("changeAnnotations", R.changeAnnotations);
764}
765
766bool fromJSON(const llvm::json::Value &Params, ExecuteCommandParams &R,
767 llvm::json::Path P) {
768 llvm::json::ObjectMapper O(Params, P);
769 if (!O || !O.map("command", R.command))
770 return false;
771
772 const auto *Args = Params.getAsObject()->get("arguments");
773 if (!Args)
774 return true; // Missing args is ok, argument is null.
775 const auto *ArgsArray = Args->getAsArray();
776 if (!ArgsArray) {
777 P.field("arguments").report("expected array");
778 return false;
779 }
780 if (ArgsArray->size() > 1) {
781 P.field("arguments").report("Command should have 0 or 1 argument");
782 return false;
783 }
784 if (ArgsArray->size() == 1) {
785 R.argument = ArgsArray->front();
786 }
787 return true;
788}
789
790llvm::json::Value toJSON(const SymbolInformation &P) {
791 llvm::json::Object O{
792 {"name", P.name},
793 {"kind", static_cast<int>(P.kind)},
794 {"location", P.location},
795 {"containerName", P.containerName},
796 };
797 if (P.score)
798 O["score"] = *P.score;
799 return std::move(O);
800}
801
802llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
803 const SymbolInformation &SI) {
804 O << SI.containerName << "::" << SI.name << " - " << toJSON(SI);
805 return O;
806}
807
808bool operator==(const SymbolDetails &LHS, const SymbolDetails &RHS) {
809 return LHS.name == RHS.name && LHS.containerName == RHS.containerName &&
810 LHS.USR == RHS.USR && LHS.ID == RHS.ID &&
811 LHS.declarationRange == RHS.declarationRange &&
812 LHS.definitionRange == RHS.definitionRange;
813}
814
815llvm::json::Value toJSON(const SymbolDetails &P) {
816 llvm::json::Object Result{{"name", llvm::json::Value(nullptr)},
817 {"containerName", llvm::json::Value(nullptr)},
818 {"usr", llvm::json::Value(nullptr)},
819 {"id", llvm::json::Value(nullptr)}};
820
821 if (!P.name.empty())
822 Result["name"] = P.name;
823
824 if (!P.containerName.empty())
825 Result["containerName"] = P.containerName;
826
827 if (!P.USR.empty())
828 Result["usr"] = P.USR;
829
830 if (P.ID)
831 Result["id"] = P.ID.str();
832
833 if (P.declarationRange)
834 Result["declarationRange"] = *P.declarationRange;
835
836 if (P.definitionRange)
837 Result["definitionRange"] = *P.definitionRange;
838
839 // FIXME: workaround for older gcc/clang
840 return std::move(Result);
841}
842
843llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const SymbolDetails &S) {
844 if (!S.containerName.empty()) {
845 O << S.containerName;
846 llvm::StringRef ContNameRef;
847 if (!ContNameRef.endswith("::")) {
848 O << " ";
849 }
850 }
851 O << S.name << " - " << toJSON(S);
852 return O;
853}
854
855bool fromJSON(const llvm::json::Value &Params, WorkspaceSymbolParams &R,
856 llvm::json::Path P) {
857 llvm::json::ObjectMapper O(Params, P);
858 return O && O.map("query", R.query) &&
859 mapOptOrNull(Params, "limit", R.limit, P);
860}
861
862llvm::json::Value toJSON(const Command &C) {
863 auto Cmd = llvm::json::Object{{"title", C.title}, {"command", C.command}};
864 if (!C.argument.getAsNull())
865 Cmd["arguments"] = llvm::json::Array{C.argument};
866 return std::move(Cmd);
867}
868
869const llvm::StringLiteral CodeAction::QUICKFIX_KIND = "quickfix";
870const llvm::StringLiteral CodeAction::REFACTOR_KIND = "refactor";
871const llvm::StringLiteral CodeAction::INFO_KIND = "info";
872
873llvm::json::Value toJSON(const CodeAction &CA) {
874 auto CodeAction = llvm::json::Object{{"title", CA.title}};
875 if (CA.kind)
876 CodeAction["kind"] = *CA.kind;
877 if (CA.diagnostics)
878 CodeAction["diagnostics"] = llvm::json::Array(*CA.diagnostics);
879 if (CA.isPreferred)
880 CodeAction["isPreferred"] = true;
881 if (CA.edit)
882 CodeAction["edit"] = *CA.edit;
883 if (CA.command)
884 CodeAction["command"] = *CA.command;
885 return std::move(CodeAction);
886}
887
888llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const DocumentSymbol &S) {
889 return O << S.name << " - " << toJSON(S);
890}
891
892llvm::json::Value toJSON(const DocumentSymbol &S) {
893 llvm::json::Object Result{{"name", S.name},
894 {"kind", static_cast<int>(S.kind)},
895 {"range", S.range},
896 {"selectionRange", S.selectionRange}};
897
898 if (!S.detail.empty())
899 Result["detail"] = S.detail;
900 if (!S.children.empty())
901 Result["children"] = S.children;
902 if (S.deprecated)
903 Result["deprecated"] = true;
904 // FIXME: workaround for older gcc/clang
905 return std::move(Result);
906}
907
908llvm::json::Value toJSON(const WorkspaceEdit &WE) {
909 llvm::json::Object Result;
910 if (WE.changes) {
911 llvm::json::Object FileChanges;
912 for (auto &Change : *WE.changes)
913 FileChanges[Change.first] = llvm::json::Array(Change.second);
914 Result["changes"] = std::move(FileChanges);
915 }
916 if (WE.documentChanges)
917 Result["documentChanges"] = *WE.documentChanges;
918 if (!WE.changeAnnotations.empty()) {
919 llvm::json::Object ChangeAnnotations;
920 for (auto &Annotation : WE.changeAnnotations)
921 ChangeAnnotations[Annotation.first] = Annotation.second;
922 Result["changeAnnotations"] = std::move(ChangeAnnotations);
923 }
924 return Result;
925}
926
927bool fromJSON(const llvm::json::Value &Params, TweakArgs &A,
928 llvm::json::Path P) {
929 llvm::json::ObjectMapper O(Params, P);
930 return O && O.map("file", A.file) && O.map("selection", A.selection) &&
931 O.map("tweakID", A.tweakID);
932}
933
934llvm::json::Value toJSON(const TweakArgs &A) {
935 return llvm::json::Object{
936 {"tweakID", A.tweakID}, {"selection", A.selection}, {"file", A.file}};
937}
938
939llvm::json::Value toJSON(const ApplyWorkspaceEditParams &Params) {
940 return llvm::json::Object{{"edit", Params.edit}};
941}
942
943bool fromJSON(const llvm::json::Value &Response, ApplyWorkspaceEditResponse &R,
944 llvm::json::Path P) {
945 llvm::json::ObjectMapper O(Response, P);
946 return O && O.map("applied", R.applied) &&
947 O.map("failureReason", R.failureReason);
948}
949
950bool fromJSON(const llvm::json::Value &Params, TextDocumentPositionParams &R,
951 llvm::json::Path P) {
952 llvm::json::ObjectMapper O(Params, P);
953 return O && O.map("textDocument", R.textDocument) &&
954 O.map("position", R.position);
955}
956
957bool fromJSON(const llvm::json::Value &Params, CompletionContext &R,
958 llvm::json::Path P) {
959 llvm::json::ObjectMapper O(Params, P);
960 int TriggerKind;
961 if (!O || !O.map("triggerKind", TriggerKind) ||
962 !mapOptOrNull(Params, "triggerCharacter", R.triggerCharacter, P))
963 return false;
964 R.triggerKind = static_cast<CompletionTriggerKind>(TriggerKind);
965 return true;
966}
967
968bool fromJSON(const llvm::json::Value &Params, CompletionParams &R,
969 llvm::json::Path P) {
970 if (!fromJSON(Params, static_cast<TextDocumentPositionParams &>(R), P) ||
971 !mapOptOrNull(Params, "limit", R.limit, P))
972 return false;
973 if (auto *Context = Params.getAsObject()->get("context"))
974 return fromJSON(*Context, R.context, P.field("context"));
975 return true;
976}
977
978static llvm::StringRef toTextKind(MarkupKind Kind) {
979 switch (Kind) {
980 case MarkupKind::PlainText:
981 return "plaintext";
982 case MarkupKind::Markdown:
983 return "markdown";
984 }
985 llvm_unreachable("Invalid MarkupKind");
986}
987
988bool fromJSON(const llvm::json::Value &V, MarkupKind &K, llvm::json::Path P) {
989 auto Str = V.getAsString();
990 if (!Str) {
991 P.report("expected string");
992 return false;
993 }
994 if (*Str == "plaintext")
995 K = MarkupKind::PlainText;
996 else if (*Str == "markdown")
997 K = MarkupKind::Markdown;
998 else {
999 P.report("unknown markup kind");
1000 return false;
1001 }
1002 return true;
1003}
1004
1005llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, MarkupKind K) {
1006 return OS << toTextKind(K);
1007}
1008
1009llvm::json::Value toJSON(const MarkupContent &MC) {
1010 if (MC.value.empty())
1011 return nullptr;
1012
1013 return llvm::json::Object{
1014 {"kind", toTextKind(MC.kind)},
1015 {"value", MC.value},
1016 };
1017}
1018
1019llvm::json::Value toJSON(const Hover &H) {
1020 llvm::json::Object Result{{"contents", toJSON(H.contents)}};
1021
1022 if (H.range)
1023 Result["range"] = toJSON(*H.range);
1024
1025 return std::move(Result);
1026}
1027
1028bool fromJSON(const llvm::json::Value &E, CompletionItemKind &Out,
1029 llvm::json::Path P) {
1030 if (auto T = E.getAsInteger()) {
1031 if (*T < static_cast<int>(CompletionItemKind::Text) ||
1032 *T > static_cast<int>(CompletionItemKind::TypeParameter))
1033 return false;
1034 Out = static_cast<CompletionItemKind>(*T);
1035 return true;
1036 }
1037 return false;
1038}
1039
1040CompletionItemKind
1041adjustKindToCapability(CompletionItemKind Kind,
1042 CompletionItemKindBitset &SupportedCompletionItemKinds) {
1043 auto KindVal = static_cast<size_t>(Kind);
1044 if (KindVal >= CompletionItemKindMin &&
1045 KindVal <= SupportedCompletionItemKinds.size() &&
1046 SupportedCompletionItemKinds[KindVal])
1047 return Kind;
1048
1049 switch (Kind) {
1050 // Provide some fall backs for common kinds that are close enough.
1051 case CompletionItemKind::Folder:
1052 return CompletionItemKind::File;
1053 case CompletionItemKind::EnumMember:
1054 return CompletionItemKind::Enum;
1055 case CompletionItemKind::Struct:
1056 return CompletionItemKind::Class;
1057 default:
1058 return CompletionItemKind::Text;
1059 }
1060}
1061
1062bool fromJSON(const llvm::json::Value &E, CompletionItemKindBitset &Out,
1063 llvm::json::Path P) {
1064 if (auto *A = E.getAsArray()) {
1065 for (size_t I = 0; I < A->size(); ++I) {
1066 CompletionItemKind KindOut;
1067 if (fromJSON((*A)[I], KindOut, P.index(I)))
1068 Out.set(size_t(KindOut));
1069 }
1070 return true;
1071 }
1072 return false;
1073}
1074
1075llvm::json::Value toJSON(const CompletionItemLabelDetails &CD) {
1076 llvm::json::Object Result;
1077 if (!CD.detail.empty())
1078 Result["detail"] = CD.detail;
1079 if (!CD.description.empty())
1080 Result["description"] = CD.description;
1081 return Result;
1082}
1083
1084void removeCompletionLabelDetails(CompletionItem &C) {
1085 if (!C.labelDetails)
1086 return;
1087 if (!C.labelDetails->detail.empty())
1088 C.label += C.labelDetails->detail;
1089 if (!C.labelDetails->description.empty())
1090 C.label = C.labelDetails->description + C.label;
1091 C.labelDetails.reset();
1092}
1093
1094llvm::json::Value toJSON(const CompletionItem &CI) {
1095 assert(!CI.label.empty() && "completion item label is required");
1096 llvm::json::Object Result{{"label", CI.label}};
1097 if (CI.kind != CompletionItemKind::Missing)
1098 Result["kind"] = static_cast<int>(CI.kind);
1099 if (!CI.detail.empty())
1100 Result["detail"] = CI.detail;
1101 if (CI.labelDetails)
1102 Result["labelDetails"] = *CI.labelDetails;
1103 if (CI.documentation)
1104 Result["documentation"] = CI.documentation;
1105 if (!CI.sortText.empty())
1106 Result["sortText"] = CI.sortText;
1107 if (!CI.filterText.empty())
1108 Result["filterText"] = CI.filterText;
1109 if (!CI.insertText.empty())
1110 Result["insertText"] = CI.insertText;
1111 if (CI.insertTextFormat != InsertTextFormat::Missing)
1112 Result["insertTextFormat"] = static_cast<int>(CI.insertTextFormat);
1113 if (CI.textEdit)
1114 Result["textEdit"] = *CI.textEdit;
1115 if (!CI.additionalTextEdits.empty())
1116 Result["additionalTextEdits"] = llvm::json::Array(CI.additionalTextEdits);
1117 if (CI.deprecated)
1118 Result["deprecated"] = CI.deprecated;
1119 Result["score"] = CI.score;
1120 return std::move(Result);
1121}
1122
1123llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const CompletionItem &I) {
1124 O << I.label << " - " << toJSON(I);
1125 return O;
1126}
1127
1128bool operator<(const CompletionItem &L, const CompletionItem &R) {
1129 return (L.sortText.empty() ? L.label : L.sortText) <
1130 (R.sortText.empty() ? R.label : R.sortText);
1131}
1132
1133llvm::json::Value toJSON(const CompletionList &L) {
1134 return llvm::json::Object{
1135 {"isIncomplete", L.isIncomplete},
1136 {"items", llvm::json::Array(L.items)},
1137 };
1138}
1139
1140llvm::json::Value toJSON(const ParameterInformation &PI) {
1141 assert((PI.labelOffsets || !PI.labelString.empty()) &&
1142 "parameter information label is required");
1143 llvm::json::Object Result;
1144 if (PI.labelOffsets)
1145 Result["label"] =
1146 llvm::json::Array({PI.labelOffsets->first, PI.labelOffsets->second});
1147 else
1148 Result["label"] = PI.labelString;
1149 if (!PI.documentation.empty())
1150 Result["documentation"] = PI.documentation;
1151 return std::move(Result);
1152}
1153
1154llvm::json::Value toJSON(const SignatureInformation &SI) {
1155 assert(!SI.label.empty() && "signature information label is required");
1156 llvm::json::Object Result{
1157 {"label", SI.label},
1158 {"parameters", llvm::json::Array(SI.parameters)},
1159 };
1160 if (!SI.documentation.value.empty())
1161 Result["documentation"] = SI.documentation;
1162 return std::move(Result);
1163}
1164
1165llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
1166 const SignatureInformation &I) {
1167 O << I.label << " - " << toJSON(I);
1168 return O;
1169}
1170
1171llvm::json::Value toJSON(const SignatureHelp &SH) {
1172 assert(SH.activeSignature >= 0 &&
1173 "Unexpected negative value for number of active signatures.");
1174 assert(SH.activeParameter >= 0 &&
1175 "Unexpected negative value for active parameter index");
1176 return llvm::json::Object{
1177 {"activeSignature", SH.activeSignature},
1178 {"activeParameter", SH.activeParameter},
1179 {"signatures", llvm::json::Array(SH.signatures)},
1180 };
1181}
1182
1183bool fromJSON(const llvm::json::Value &Params, RenameParams &R,
1184 llvm::json::Path P) {
1185 llvm::json::ObjectMapper O(Params, P);
1186 return O && O.map("textDocument", R.textDocument) &&
1187 O.map("position", R.position) && O.map("newName", R.newName);
1188}
1189
1190llvm::json::Value toJSON(const DocumentHighlight &DH) {
1191 return llvm::json::Object{
1192 {"range", toJSON(DH.range)},
1193 {"kind", static_cast<int>(DH.kind)},
1194 };
1195}
1196
1197llvm::json::Value toJSON(const FileStatus &FStatus) {
1198 return llvm::json::Object{
1199 {"uri", FStatus.uri},
1200 {"state", FStatus.state},
1201 };
1202}
1203
1204constexpr unsigned SemanticTokenEncodingSize = 5;
1205static llvm::json::Value encodeTokens(llvm::ArrayRef<SemanticToken> Toks) {
1206 llvm::json::Array Result;
1207 Result.reserve(SemanticTokenEncodingSize * Toks.size());
1208 for (const auto &Tok : Toks) {
1209 Result.push_back(Tok.deltaLine);
1210 Result.push_back(Tok.deltaStart);
1211 Result.push_back(Tok.length);
1212 Result.push_back(Tok.tokenType);
1213 Result.push_back(Tok.tokenModifiers);
1214 }
1215 assert(Result.size() == SemanticTokenEncodingSize * Toks.size());
1216 return std::move(Result);
1217}
1218
1219bool operator==(const SemanticToken &L, const SemanticToken &R) {
1220 return std::tie(L.deltaLine, L.deltaStart, L.length, L.tokenType,
1221 L.tokenModifiers) == std::tie(R.deltaLine, R.deltaStart,
1222 R.length, R.tokenType,
1223 R.tokenModifiers);
1224}
1225
1226llvm::json::Value toJSON(const SemanticTokens &Tokens) {
1227 return llvm::json::Object{{"resultId", Tokens.resultId},
1228 {"data", encodeTokens(Tokens.tokens)}};
1229}
1230
1231llvm::json::Value toJSON(const SemanticTokensEdit &Edit) {
1232 return llvm::json::Object{
1233 {"start", SemanticTokenEncodingSize * Edit.startToken},
1234 {"deleteCount", SemanticTokenEncodingSize * Edit.deleteTokens},
1235 {"data", encodeTokens(Edit.tokens)}};
1236}
1237
1238llvm::json::Value toJSON(const SemanticTokensOrDelta &TE) {
1239 llvm::json::Object Result{{"resultId", TE.resultId}};
1240 if (TE.edits)
1241 Result["edits"] = *TE.edits;
1242 if (TE.tokens)
1243 Result["data"] = encodeTokens(*TE.tokens);
1244 return std::move(Result);
1245}
1246
1247bool fromJSON(const llvm::json::Value &Params, SemanticTokensParams &R,
1248 llvm::json::Path P) {
1249 llvm::json::ObjectMapper O(Params, P);
1250 return O && O.map("textDocument", R.textDocument);
1251}
1252
1253bool fromJSON(const llvm::json::Value &Params, SemanticTokensDeltaParams &R,
1254 llvm::json::Path P) {
1255 llvm::json::ObjectMapper O(Params, P);
1256 return O && O.map("textDocument", R.textDocument) &&
1257 O.map("previousResultId", R.previousResultId);
1258}
1259
1260llvm::json::Value toJSON(const InactiveRegionsParams &InactiveRegions) {
1261 return llvm::json::Object{
1262 {"textDocument", InactiveRegions.TextDocument},
1263 {"regions", std::move(InactiveRegions.InactiveRegions)}};
1264}
1265
1266llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
1267 const DocumentHighlight &V) {
1268 O << V.range;
1269 if (V.kind == DocumentHighlightKind::Read)
1270 O << "(r)";
1271 if (V.kind == DocumentHighlightKind::Write)
1272 O << "(w)";
1273 return O;
1274}
1275
1276bool fromJSON(const llvm::json::Value &Params,
1277 DidChangeConfigurationParams &CCP, llvm::json::Path P) {
1278 llvm::json::ObjectMapper O(Params, P);
1279 return O && O.map("settings", CCP.settings);
1280}
1281
1282bool fromJSON(const llvm::json::Value &Params, ClangdCompileCommand &CDbUpdate,
1283 llvm::json::Path P) {
1284 llvm::json::ObjectMapper O(Params, P);
1285 return O && O.map("workingDirectory", CDbUpdate.workingDirectory) &&
1286 O.map("compilationCommand", CDbUpdate.compilationCommand);
1287}
1288
1289bool fromJSON(const llvm::json::Value &Params, ConfigurationSettings &S,
1290 llvm::json::Path P) {
1291 llvm::json::ObjectMapper O(Params, P);
1292 if (!O)
1293 return true; // 'any' type in LSP.
1294 return mapOptOrNull(Params, "compilationDatabaseChanges",
1295 S.compilationDatabaseChanges, P);
1296}
1297
1298bool fromJSON(const llvm::json::Value &Params, InitializationOptions &Opts,
1299 llvm::json::Path P) {
1300 llvm::json::ObjectMapper O(Params, P);
1301 if (!O)
1302 return true; // 'any' type in LSP.
1303
1304 return fromJSON(Params, Opts.ConfigSettings, P) &&
1305 O.map("compilationDatabasePath", Opts.compilationDatabasePath) &&
1306 mapOptOrNull(Params, "fallbackFlags", Opts.fallbackFlags, P) &&
1307 mapOptOrNull(Params, "clangdFileStatus", Opts.FileStatus, P);
1308}
1309
1310bool fromJSON(const llvm::json::Value &E, TypeHierarchyDirection &Out,
1311 llvm::json::Path P) {
1312 auto T = E.getAsInteger();
1313 if (!T)
1314 return false;
1315 if (*T < static_cast<int>(TypeHierarchyDirection::Children) ||
1316 *T > static_cast<int>(TypeHierarchyDirection::Both))
1317 return false;
1318 Out = static_cast<TypeHierarchyDirection>(*T);
1319 return true;
1320}
1321
1322bool fromJSON(const llvm::json::Value &Params, TypeHierarchyPrepareParams &R,
1323 llvm::json::Path P) {
1324 llvm::json::ObjectMapper O(Params, P);
1325 return O && O.map("textDocument", R.textDocument) &&
1326 O.map("position", R.position) &&
1327 mapOptOrNull(Params, "resolve", R.resolve, P) &&
1328 mapOptOrNull(Params, "direction", R.direction, P);
1329}
1330
1331llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
1332 const TypeHierarchyItem &I) {
1333 return O << I.name << " - " << toJSON(I);
1334}
1335
1336llvm::json::Value toJSON(const TypeHierarchyItem::ResolveParams &RP) {
1337 llvm::json::Object Result{{"symbolID", RP.symbolID}};
1338 if (RP.parents)
1339 Result["parents"] = RP.parents;
1340 return std::move(Result);
1341}
1342bool fromJSON(const llvm::json::Value &Params,
1343 TypeHierarchyItem::ResolveParams &RP, llvm::json::Path P) {
1344 llvm::json::ObjectMapper O(Params, P);
1345 return O && O.map("symbolID", RP.symbolID) &&
1346 mapOptOrNull(Params, "parents", RP.parents, P);
1347}
1348
1349llvm::json::Value toJSON(const TypeHierarchyItem &I) {
1350 llvm::json::Object Result{
1351 {"name", I.name}, {"kind", static_cast<int>(I.kind)},
1352 {"range", I.range}, {"selectionRange", I.selectionRange},
1353 {"uri", I.uri}, {"data", I.data},
1354 };
1355
1356 if (I.detail)
1357 Result["detail"] = I.detail;
1358 return std::move(Result);
1359}
1360
1361bool fromJSON(const llvm::json::Value &Params, TypeHierarchyItem &I,
1362 llvm::json::Path P) {
1363 llvm::json::ObjectMapper O(Params, P);
1364
1365 // Required fields.
1366 return O && O.map("name", I.name) && O.map("kind", I.kind) &&
1367 O.map("uri", I.uri) && O.map("range", I.range) &&
1368 O.map("selectionRange", I.selectionRange) &&
1369 mapOptOrNull(Params, "detail", I.detail, P) &&
1370 mapOptOrNull(Params, "deprecated", I.deprecated, P) &&
1371 mapOptOrNull(Params, "parents", I.parents, P) &&
1372 mapOptOrNull(Params, "children", I.children, P) &&
1373 mapOptOrNull(Params, "data", I.data, P);
1374}
1375
1376bool fromJSON(const llvm::json::Value &Params,
1377 ResolveTypeHierarchyItemParams &R, llvm::json::Path P) {
1378 llvm::json::ObjectMapper O(Params, P);
1379 return O && O.map("item", R.item) &&
1380 mapOptOrNull(Params, "resolve", R.resolve, P) &&
1381 mapOptOrNull(Params, "direction", R.direction, P);
1382}
1383
1384bool fromJSON(const llvm::json::Value &Params, ReferenceContext &R,
1385 llvm::json::Path P) {
1386 llvm::json::ObjectMapper O(Params, P);
1387 return O && O.mapOptional("includeDeclaration", R.includeDeclaration);
1388}
1389
1390bool fromJSON(const llvm::json::Value &Params, ReferenceParams &R,
1391 llvm::json::Path P) {
1392 TextDocumentPositionParams &Base = R;
1393 llvm::json::ObjectMapper O(Params, P);
1394 return fromJSON(Params, Base, P) && O && O.mapOptional("context", R.context);
1395}
1396
1397llvm::json::Value toJSON(SymbolTag Tag) {
1398 return llvm::json::Value{static_cast<int>(Tag)};
1399}
1400
1401llvm::json::Value toJSON(const CallHierarchyItem &I) {
1402 llvm::json::Object Result{{"name", I.name},
1403 {"kind", static_cast<int>(I.kind)},
1404 {"range", I.range},
1405 {"selectionRange", I.selectionRange},
1406 {"uri", I.uri}};
1407 if (!I.tags.empty())
1408 Result["tags"] = I.tags;
1409 if (!I.detail.empty())
1410 Result["detail"] = I.detail;
1411 if (!I.data.empty())
1412 Result["data"] = I.data;
1413 return std::move(Result);
1414}
1415
1416bool fromJSON(const llvm::json::Value &Params, CallHierarchyItem &I,
1417 llvm::json::Path P) {
1418 llvm::json::ObjectMapper O(Params, P);
1419
1420 // Populate the required fields only. We don't care about the
1421 // optional fields `Tags` and `Detail` for the purpose of
1422 // client --> server communication.
1423 return O && O.map("name", I.name) && O.map("kind", I.kind) &&
1424 O.map("uri", I.uri) && O.map("range", I.range) &&
1425 O.map("selectionRange", I.selectionRange) &&
1426 mapOptOrNull(Params, "data", I.data, P);
1427}
1428
1429bool fromJSON(const llvm::json::Value &Params,
1430 CallHierarchyIncomingCallsParams &C, llvm::json::Path P) {
1431 llvm::json::ObjectMapper O(Params, P);
1432 return O.map("item", C.item);
1433}
1434
1435llvm::json::Value toJSON(const CallHierarchyIncomingCall &C) {
1436 return llvm::json::Object{{"from", C.from}, {"fromRanges", C.fromRanges}};
1437}
1438
1439bool fromJSON(const llvm::json::Value &Params,
1440 CallHierarchyOutgoingCallsParams &C, llvm::json::Path P) {
1441 llvm::json::ObjectMapper O(Params, P);
1442 return O.map("item", C.item);
1443}
1444
1445llvm::json::Value toJSON(const CallHierarchyOutgoingCall &C) {
1446 return llvm::json::Object{{"to", C.to}, {"fromRanges", C.fromRanges}};
1447}
1448
1449bool fromJSON(const llvm::json::Value &Params, InlayHintsParams &R,
1450 llvm::json::Path P) {
1451 llvm::json::ObjectMapper O(Params, P);
1452 return O && O.map("textDocument", R.textDocument) && O.map("range", R.range);
1453}
1454
1455llvm::json::Value toJSON(const InlayHintKind &Kind) {
1456 switch (Kind) {
1457 case InlayHintKind::Type:
1458 return 1;
1459 case InlayHintKind::Parameter:
1460 return 2;
1461 case InlayHintKind::Designator:
1462 case InlayHintKind::BlockEnd:
1463 // This is an extension, don't serialize.
1464 return nullptr;
1465 }
1466 llvm_unreachable("Unknown clang.clangd.InlayHintKind");
1467}
1468
1469llvm::json::Value toJSON(const InlayHint &H) {
1470 llvm::json::Object Result{{"position", H.position},
1471 {"label", H.label},
1472 {"paddingLeft", H.paddingLeft},
1473 {"paddingRight", H.paddingRight}};
1474 auto K = toJSON(H.kind);
1475 if (!K.getAsNull())
1476 Result["kind"] = std::move(K);
1477 return std::move(Result);
1478}
1479bool operator==(const InlayHint &A, const InlayHint &B) {
1480 return std::tie(A.position, A.range, A.kind, A.label) ==
1481 std::tie(B.position, B.range, B.kind, B.label);
1482}
1483bool operator<(const InlayHint &A, const InlayHint &B) {
1484 return std::tie(A.position, A.range, A.kind, A.label) <
1485 std::tie(B.position, B.range, B.kind, B.label);
1486}
1487
1488llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, InlayHintKind Kind) {
1489 auto ToString = [](InlayHintKind K) {
1490 switch (K) {
1491 case InlayHintKind::Parameter:
1492 return "parameter";
1493 case InlayHintKind::Type:
1494 return "type";
1495 case InlayHintKind::Designator:
1496 return "designator";
1497 case InlayHintKind::BlockEnd:
1498 return "block-end";
1499 }
1500 llvm_unreachable("Unknown clang.clangd.InlayHintKind");
1501 };
1502 return OS << ToString(Kind);
1503}
1504
1505static const char *toString(OffsetEncoding OE) {
1506 switch (OE) {
1507 case OffsetEncoding::UTF8:
1508 return "utf-8";
1509 case OffsetEncoding::UTF16:
1510 return "utf-16";
1511 case OffsetEncoding::UTF32:
1512 return "utf-32";
1513 case OffsetEncoding::UnsupportedEncoding:
1514 return "unknown";
1515 }
1516 llvm_unreachable("Unknown clang.clangd.OffsetEncoding");
1517}
1518llvm::json::Value toJSON(const OffsetEncoding &OE) { return toString(OE); }
1519bool fromJSON(const llvm::json::Value &V, OffsetEncoding &OE,
1520 llvm::json::Path P) {
1521 auto Str = V.getAsString();
1522 if (!Str)
1523 return false;
1524 OE = llvm::StringSwitch<OffsetEncoding>(*Str)
1525 .Case("utf-8", OffsetEncoding::UTF8)
1526 .Case("utf-16", OffsetEncoding::UTF16)
1527 .Case("utf-32", OffsetEncoding::UTF32)
1528 .Default(OffsetEncoding::UnsupportedEncoding);
1529 return true;
1530}
1531llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, OffsetEncoding Enc) {
1532 return OS << toString(Enc);
1533}
1534
1535bool fromJSON(const llvm::json::Value &Params, SelectionRangeParams &S,
1536 llvm::json::Path P) {
1537 llvm::json::ObjectMapper O(Params, P);
1538 return O && O.map("textDocument", S.textDocument) &&
1539 O.map("positions", S.positions);
1540}
1541
1542llvm::json::Value toJSON(const SelectionRange &Out) {
1543 if (Out.parent) {
1544 return llvm::json::Object{{"range", Out.range},
1545 {"parent", toJSON(*Out.parent)}};
1546 }
1547 return llvm::json::Object{{"range", Out.range}};
1548}
1549
1550bool fromJSON(const llvm::json::Value &Params, DocumentLinkParams &R,
1551 llvm::json::Path P) {
1552 llvm::json::ObjectMapper O(Params, P);
1553 return O && O.map("textDocument", R.textDocument);
1554}
1555
1556llvm::json::Value toJSON(const DocumentLink &DocumentLink) {
1557 return llvm::json::Object{
1558 {"range", DocumentLink.range},
1559 {"target", DocumentLink.target},
1560 };
1561}
1562
1563bool fromJSON(const llvm::json::Value &Params, FoldingRangeParams &R,
1564 llvm::json::Path P) {
1565 llvm::json::ObjectMapper O(Params, P);
1566 return O && O.map("textDocument", R.textDocument);
1567}
1568
1569const llvm::StringLiteral FoldingRange::REGION_KIND = "region";
1570const llvm::StringLiteral FoldingRange::COMMENT_KIND = "comment";
1571const llvm::StringLiteral FoldingRange::IMPORT_KIND = "import";
1572
1573llvm::json::Value toJSON(const FoldingRange &Range) {
1574 llvm::json::Object Result{
1575 {"startLine", Range.startLine},
1576 {"endLine", Range.endLine},
1577 };
1578 if (Range.startCharacter)
1579 Result["startCharacter"] = Range.startCharacter;
1580 if (Range.endCharacter)
1581 Result["endCharacter"] = Range.endCharacter;
1582 if (!Range.kind.empty())
1583 Result["kind"] = Range.kind;
1584 return Result;
1585}
1586
1587llvm::json::Value toJSON(const MemoryTree &MT) {
1588 llvm::json::Object Out;
1589 int64_t Total = MT.self();
1590 Out["_self"] = Total;
1591 for (const auto &Entry : MT.children()) {
1592 auto Child = toJSON(Entry.getSecond());
1593 Total += *Child.getAsObject()->getInteger("_total");
1594 Out[Entry.first] = std::move(Child);
1595 }
1596 Out["_total"] = Total;
1597 return Out;
1598}
1599
1600bool fromJSON(const llvm::json::Value &Params, ASTParams &R,
1601 llvm::json::Path P) {
1602 llvm::json::ObjectMapper O(Params, P);
1603 return O && O.map("textDocument", R.textDocument) && O.map("range", R.range);
1604}
1605
1606llvm::json::Value toJSON(const ASTNode &N) {
1607 llvm::json::Object Result{
1608 {"role", N.role},
1609 {"kind", N.kind},
1610 };
1611 if (!N.children.empty())
1612 Result["children"] = N.children;
1613 if (!N.detail.empty())
1614 Result["detail"] = N.detail;
1615 if (!N.arcana.empty())
1616 Result["arcana"] = N.arcana;
1617 if (N.range)
1618 Result["range"] = *N.range;
1619 return Result;
1620}
1621
1622llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const ASTNode &Root) {
1623 std::function<void(const ASTNode &, unsigned)> Print = [&](const ASTNode &N,
1624 unsigned Level) {
1625 OS.indent(2 * Level) << N.role << ": " << N.kind;
1626 if (!N.detail.empty())
1627 OS << " - " << N.detail;
1628 OS << "\n";
1629 for (const ASTNode &C : N.children)
1630 Print(C, Level + 1);
1631 };
1632 Print(Root, 0);
1633 return OS;
1634}
1635
1636bool fromJSON(const llvm::json::Value &E, SymbolID &S, llvm::json::Path P) {
1637 auto Str = E.getAsString();
1638 if (!Str) {
1639 P.report("expected a string");
1640 return false;
1641 }
1642 auto ID = SymbolID::fromStr(*Str);
1643 if (!ID) {
1644 elog("Malformed symbolid: {0}", ID.takeError());
1645 P.report("malformed symbolid");
1646 return false;
1647 }
1648 S = *ID;
1649 return true;
1650}
1651llvm::json::Value toJSON(const SymbolID &S) { return S.str(); }
1652
1653} // namespace clangd
1654} // namespace clang
1655