clang-tools 19.0.0git
Protocol.h
Go to the documentation of this file.
1//===--- Protocol.h - Language Server Protocol Implementation ---*- C++ -*-===//
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 structs based on the LSP specification at
10// https://github.com/Microsoft/language-server-protocol/blob/main/protocol.md
11//
12// This is not meant to be a complete implementation, new interfaces are added
13// when they're needed.
14//
15// Each struct has a toJSON and fromJSON function, that converts between
16// the struct and a JSON representation. (See JSON.h)
17//
18// Some structs also have operator<< serialization. This is for debugging and
19// tests, and is not generally machine-readable.
20//
21//===----------------------------------------------------------------------===//
22
23#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
24#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
25
26#include "URI.h"
27#include "index/SymbolID.h"
28#include "support/MemoryTree.h"
29#include "clang/Index/IndexSymbol.h"
30#include "llvm/ADT/SmallVector.h"
31#include "llvm/Support/JSON.h"
32#include "llvm/Support/raw_ostream.h"
33#include <bitset>
34#include <memory>
35#include <optional>
36#include <string>
37#include <vector>
38
39// This file is using the LSP syntax for identifier names which is different
40// from the LLVM coding standard. To avoid the clang-tidy warnings, we're
41// disabling one check here.
42// NOLINTBEGIN(readability-identifier-naming)
43
44namespace clang {
45namespace clangd {
46
47enum class ErrorCode {
48 // Defined by JSON RPC.
49 ParseError = -32700,
50 InvalidRequest = -32600,
51 MethodNotFound = -32601,
52 InvalidParams = -32602,
53 InternalError = -32603,
54
55 ServerNotInitialized = -32002,
56 UnknownErrorCode = -32001,
57
58 // Defined by the protocol.
59 RequestCancelled = -32800,
60 ContentModified = -32801,
61};
62// Models an LSP error as an llvm::Error.
63class LSPError : public llvm::ErrorInfo<LSPError> {
64public:
65 std::string Message;
67 static char ID;
68
70 : Message(std::move(Message)), Code(Code) {}
71
72 void log(llvm::raw_ostream &OS) const override {
73 OS << int(Code) << ": " << Message;
74 }
75 std::error_code convertToErrorCode() const override {
76 return llvm::inconvertibleErrorCode();
77 }
78};
79
80bool fromJSON(const llvm::json::Value &, SymbolID &, llvm::json::Path);
81llvm::json::Value toJSON(const SymbolID &);
82
83// URI in "file" scheme for a file.
84struct URIForFile {
85 URIForFile() = default;
86
87 /// Canonicalizes \p AbsPath via URI.
88 ///
89 /// File paths in URIForFile can come from index or local AST. Path from
90 /// index goes through URI transformation, and the final path is resolved by
91 /// URI scheme and could potentially be different from the original path.
92 /// Hence, we do the same transformation for all paths.
93 ///
94 /// Files can be referred to by several paths (e.g. in the presence of links).
95 /// Which one we prefer may depend on where we're coming from. \p TUPath is a
96 /// hint, and should usually be the main entrypoint file we're processing.
97 static URIForFile canonicalize(llvm::StringRef AbsPath,
98 llvm::StringRef TUPath);
99
100 static llvm::Expected<URIForFile> fromURI(const URI &U,
101 llvm::StringRef HintPath);
102
103 /// Retrieves absolute path to the file.
104 llvm::StringRef file() const { return File; }
105
106 explicit operator bool() const { return !File.empty(); }
107 std::string uri() const { return URI::createFile(File).toString(); }
108
109 friend bool operator==(const URIForFile &LHS, const URIForFile &RHS) {
110 return LHS.File == RHS.File;
111 }
112
113 friend bool operator!=(const URIForFile &LHS, const URIForFile &RHS) {
114 return !(LHS == RHS);
115 }
116
117 friend bool operator<(const URIForFile &LHS, const URIForFile &RHS) {
118 return LHS.File < RHS.File;
119 }
120
121private:
122 explicit URIForFile(std::string &&File) : File(std::move(File)) {}
123
124 std::string File;
125};
126
127/// Serialize/deserialize \p URIForFile to/from a string URI.
128llvm::json::Value toJSON(const URIForFile &U);
129bool fromJSON(const llvm::json::Value &, URIForFile &, llvm::json::Path);
130
132 /// The text document's URI.
134};
135llvm::json::Value toJSON(const TextDocumentIdentifier &);
136bool fromJSON(const llvm::json::Value &, TextDocumentIdentifier &,
137 llvm::json::Path);
138
140 /// The version number of this document. If a versioned text document
141 /// identifier is sent from the server to the client and the file is not open
142 /// in the editor (the server has not received an open notification before)
143 /// the server can send `null` to indicate that the version is known and the
144 /// content on disk is the master (as speced with document content ownership).
145 ///
146 /// The version number of a document will increase after each change,
147 /// including undo/redo. The number doesn't need to be consecutive.
148 ///
149 /// clangd extension: versions are optional, and synthesized if missing.
150 std::optional<std::int64_t> version;
151};
152llvm::json::Value toJSON(const VersionedTextDocumentIdentifier &);
153bool fromJSON(const llvm::json::Value &, VersionedTextDocumentIdentifier &,
154 llvm::json::Path);
155
156struct Position {
157 /// Line position in a document (zero-based).
158 int line = 0;
159
160 /// Character offset on a line in a document (zero-based).
161 /// WARNING: this is in UTF-16 codepoints, not bytes or characters!
162 /// Use the functions in SourceCode.h to construct/interpret Positions.
163 int character = 0;
164
165 friend bool operator==(const Position &LHS, const Position &RHS) {
166 return std::tie(LHS.line, LHS.character) ==
167 std::tie(RHS.line, RHS.character);
168 }
169 friend bool operator!=(const Position &LHS, const Position &RHS) {
170 return !(LHS == RHS);
171 }
172 friend bool operator<(const Position &LHS, const Position &RHS) {
173 return std::tie(LHS.line, LHS.character) <
174 std::tie(RHS.line, RHS.character);
175 }
176 friend bool operator<=(const Position &LHS, const Position &RHS) {
177 return std::tie(LHS.line, LHS.character) <=
178 std::tie(RHS.line, RHS.character);
179 }
180};
181bool fromJSON(const llvm::json::Value &, Position &, llvm::json::Path);
182llvm::json::Value toJSON(const Position &);
183llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Position &);
184
185struct Range {
186 /// The range's start position.
188
189 /// The range's end position.
191
192 friend bool operator==(const Range &LHS, const Range &RHS) {
193 return std::tie(LHS.start, LHS.end) == std::tie(RHS.start, RHS.end);
194 }
195 friend bool operator!=(const Range &LHS, const Range &RHS) {
196 return !(LHS == RHS);
197 }
198 friend bool operator<(const Range &LHS, const Range &RHS) {
199 return std::tie(LHS.start, LHS.end) < std::tie(RHS.start, RHS.end);
200 }
201
202 bool contains(Position Pos) const { return start <= Pos && Pos < end; }
203 bool contains(Range Rng) const {
204 return start <= Rng.start && Rng.end <= end;
205 }
206};
207bool fromJSON(const llvm::json::Value &, Range &, llvm::json::Path);
208llvm::json::Value toJSON(const Range &);
209llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Range &);
210
211struct Location {
212 /// The text document's URI.
215
216 friend bool operator==(const Location &LHS, const Location &RHS) {
217 return LHS.uri == RHS.uri && LHS.range == RHS.range;
218 }
219
220 friend bool operator!=(const Location &LHS, const Location &RHS) {
221 return !(LHS == RHS);
222 }
223
224 friend bool operator<(const Location &LHS, const Location &RHS) {
225 return std::tie(LHS.uri, LHS.range) < std::tie(RHS.uri, RHS.range);
226 }
227};
228llvm::json::Value toJSON(const Location &);
229llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Location &);
230
231/// Extends Locations returned by textDocument/references with extra info.
232/// This is a clangd extension: LSP uses `Location`.
234 /// clangd extension: contains the name of the function or class in which the
235 /// reference occurs
236 std::optional<std::string> containerName;
237};
238llvm::json::Value toJSON(const ReferenceLocation &);
239llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ReferenceLocation &);
240
241using ChangeAnnotationIdentifier = std::string;
242// A combination of a LSP standard TextEdit and AnnotatedTextEdit.
243struct TextEdit {
244 /// The range of the text document to be manipulated. To insert
245 /// text into a document create a range where start === end.
247
248 /// The string to be inserted. For delete operations use an
249 /// empty string.
250 std::string newText;
251
252 /// The actual annotation identifier (optional)
253 /// If empty, then this field is nullopt.
255};
256inline bool operator==(const TextEdit &L, const TextEdit &R) {
257 return std::tie(L.newText, L.range, L.annotationId) ==
258 std::tie(R.newText, R.range, L.annotationId);
259}
260bool fromJSON(const llvm::json::Value &, TextEdit &, llvm::json::Path);
261llvm::json::Value toJSON(const TextEdit &);
262llvm::raw_ostream &operator<<(llvm::raw_ostream &, const TextEdit &);
263
265 /// A human-readable string describing the actual change. The string
266 /// is rendered prominent in the user interface.
267 std::string label;
268
269 /// A flag which indicates that user confirmation is needed
270 /// before applying the change.
271 std::optional<bool> needsConfirmation;
272
273 /// A human-readable string which is rendered less prominent in
274 /// the user interface.
275 std::string description;
276};
277bool fromJSON(const llvm::json::Value &, ChangeAnnotation &, llvm::json::Path);
278llvm::json::Value toJSON(const ChangeAnnotation &);
279
281 /// The text document to change.
283
284 /// The edits to be applied.
285 /// FIXME: support the AnnotatedTextEdit variant.
286 std::vector<TextEdit> edits;
287};
288bool fromJSON(const llvm::json::Value &, TextDocumentEdit &, llvm::json::Path);
289llvm::json::Value toJSON(const TextDocumentEdit &);
290
292 /// The text document's URI.
294
295 /// The text document's language identifier.
296 std::string languageId;
297
298 /// The version number of this document (it will strictly increase after each
299 /// change, including undo/redo.
300 ///
301 /// clangd extension: versions are optional, and synthesized if missing.
302 std::optional<int64_t> version;
303
304 /// The content of the opened text document.
305 std::string text;
306};
307bool fromJSON(const llvm::json::Value &, TextDocumentItem &, llvm::json::Path);
308
309enum class TraceLevel {
310 Off = 0,
311 Messages = 1,
312 Verbose = 2,
313};
314bool fromJSON(const llvm::json::Value &E, TraceLevel &Out, llvm::json::Path);
315
316struct NoParams {};
317inline llvm::json::Value toJSON(const NoParams &) { return nullptr; }
318inline bool fromJSON(const llvm::json::Value &, NoParams &, llvm::json::Path) {
319 return true;
320}
322
323/// Defines how the host (editor) should sync document changes to the language
324/// server.
326 /// Documents should not be synced at all.
327 None = 0,
328
329 /// Documents are synced by always sending the full content of the document.
330 Full = 1,
331
332 /// Documents are synced by sending the full content on open. After that
333 /// only incremental updates to the document are send.
334 Incremental = 2,
335};
336
337/// The kind of a completion entry.
339 Missing = 0,
340 Text = 1,
341 Method = 2,
342 Function = 3,
343 Constructor = 4,
344 Field = 5,
345 Variable = 6,
346 Class = 7,
347 Interface = 8,
348 Module = 9,
349 Property = 10,
350 Unit = 11,
351 Value = 12,
352 Enum = 13,
353 Keyword = 14,
354 Snippet = 15,
355 Color = 16,
356 File = 17,
357 Reference = 18,
358 Folder = 19,
359 EnumMember = 20,
360 Constant = 21,
361 Struct = 22,
362 Event = 23,
363 Operator = 24,
364 TypeParameter = 25,
365};
366bool fromJSON(const llvm::json::Value &, CompletionItemKind &,
367 llvm::json::Path);
368constexpr auto CompletionItemKindMin =
369 static_cast<size_t>(CompletionItemKind::Text);
370constexpr auto CompletionItemKindMax =
371 static_cast<size_t>(CompletionItemKind::TypeParameter);
372using CompletionItemKindBitset = std::bitset<CompletionItemKindMax + 1>;
373bool fromJSON(const llvm::json::Value &, CompletionItemKindBitset &,
374 llvm::json::Path);
377 CompletionItemKindBitset &SupportedCompletionItemKinds);
378
379/// A symbol kind.
380enum class SymbolKind {
381 File = 1,
382 Module = 2,
383 Namespace = 3,
384 Package = 4,
385 Class = 5,
386 Method = 6,
387 Property = 7,
388 Field = 8,
389 Constructor = 9,
390 Enum = 10,
391 Interface = 11,
392 Function = 12,
393 Variable = 13,
394 Constant = 14,
395 String = 15,
396 Number = 16,
397 Boolean = 17,
398 Array = 18,
399 Object = 19,
400 Key = 20,
401 Null = 21,
402 EnumMember = 22,
403 Struct = 23,
404 Event = 24,
405 Operator = 25,
406 TypeParameter = 26
407};
408bool fromJSON(const llvm::json::Value &, SymbolKind &, llvm::json::Path);
409constexpr auto SymbolKindMin = static_cast<size_t>(SymbolKind::File);
410constexpr auto SymbolKindMax = static_cast<size_t>(SymbolKind::TypeParameter);
411using SymbolKindBitset = std::bitset<SymbolKindMax + 1>;
412bool fromJSON(const llvm::json::Value &, SymbolKindBitset &, llvm::json::Path);
414 SymbolKindBitset &supportedSymbolKinds);
415
416// Convert a index::SymbolKind to clangd::SymbolKind (LSP)
417// Note, some are not perfect matches and should be improved when this LSP
418// issue is addressed:
419// https://github.com/Microsoft/language-server-protocol/issues/344
421
422// Determines the encoding used to measure offsets and lengths of source in LSP.
423enum class OffsetEncoding {
424 // Any string is legal on the wire. Unrecognized encodings parse as this.
426 // Length counts code units of UTF-16 encoded text. (Standard LSP behavior).
427 UTF16,
428 // Length counts bytes of UTF-8 encoded text. (Clangd extension).
429 UTF8,
430 // Length counts codepoints in unicode text. (Clangd extension).
431 UTF32,
432};
433llvm::json::Value toJSON(const OffsetEncoding &);
434bool fromJSON(const llvm::json::Value &, OffsetEncoding &, llvm::json::Path);
435llvm::raw_ostream &operator<<(llvm::raw_ostream &, OffsetEncoding);
436
437// Describes the content type that a client supports in various result literals
438// like `Hover`, `ParameterInfo` or `CompletionItem`.
439enum class MarkupKind {
440 PlainText,
441 Markdown,
442};
443bool fromJSON(const llvm::json::Value &, MarkupKind &, llvm::json::Path);
444llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, MarkupKind);
445
446// This struct doesn't mirror LSP!
447// The protocol defines deeply nested structures for client capabilities.
448// Instead of mapping them all, this just parses out the bits we care about.
450 /// The supported set of SymbolKinds for workspace/symbol.
451 /// workspace.symbol.symbolKind.valueSet
452 std::optional<SymbolKindBitset> WorkspaceSymbolKinds;
453
454 /// Whether the client accepts diagnostics with codeActions attached inline.
455 /// textDocument.publishDiagnostics.codeActionsInline.
456 bool DiagnosticFixes = false;
457
458 /// Whether the client accepts diagnostics with related locations.
459 /// textDocument.publishDiagnostics.relatedInformation.
461
462 /// Whether the client accepts diagnostics with category attached to it
463 /// using the "category" extension.
464 /// textDocument.publishDiagnostics.categorySupport
465 bool DiagnosticCategory = false;
466
467 /// Client supports snippets as insert text.
468 /// textDocument.completion.completionItem.snippetSupport
469 bool CompletionSnippets = false;
470
471 /// Client supports completions with additionalTextEdit near the cursor.
472 /// This is a clangd extension. (LSP says this is for unrelated text only).
473 /// textDocument.completion.editsNearCursor
474 bool CompletionFixes = false;
475
476 /// Client supports displaying a container string for results of
477 /// textDocument/reference (clangd extension)
478 bool ReferenceContainer = false;
479
480 /// Client supports hierarchical document symbols.
481 /// textDocument.documentSymbol.hierarchicalDocumentSymbolSupport
483
484 /// Client supports signature help.
485 /// textDocument.signatureHelp
486 bool HasSignatureHelp = false;
487
488 /// Client signals that it only supports folding complete lines.
489 /// Client will ignore specified `startCharacter` and `endCharacter`
490 /// properties in a FoldingRange.
491 /// textDocument.foldingRange.lineFoldingOnly
492 bool LineFoldingOnly = false;
493
494 /// Client supports processing label offsets instead of a simple label string.
495 /// textDocument.signatureHelp.signatureInformation.parameterInformation.labelOffsetSupport
497
498 /// The documentation format that should be used for
499 /// textDocument/signatureHelp.
500 /// textDocument.signatureHelp.signatureInformation.documentationFormat
502
503 /// The supported set of CompletionItemKinds for textDocument/completion.
504 /// textDocument.completion.completionItemKind.valueSet
505 std::optional<CompletionItemKindBitset> CompletionItemKinds;
506
507 /// The documentation format that should be used for textDocument/completion.
508 /// textDocument.completion.completionItem.documentationFormat
510
511 /// The client has support for completion item label details.
512 /// textDocument.completion.completionItem.labelDetailsSupport.
514
515 /// Client supports CodeAction return value for textDocument/codeAction.
516 /// textDocument.codeAction.codeActionLiteralSupport.
518
519 /// Client advertises support for the semanticTokens feature.
520 /// We support the textDocument/semanticTokens request in any case.
521 /// textDocument.semanticTokens
522 bool SemanticTokens = false;
523 /// Client supports Theia semantic highlighting extension.
524 /// https://github.com/microsoft/vscode-languageserver-node/pull/367
525 /// clangd no longer supports this, we detect it just to log a warning.
526 /// textDocument.semanticHighlightingCapabilities.semanticHighlighting
528
529 /// Supported encodings for LSP character offsets. (clangd extension).
530 std::optional<std::vector<OffsetEncoding>> offsetEncoding;
531
532 /// The content format that should be used for Hover requests.
533 /// textDocument.hover.contentEncoding
535
536 /// The client supports testing for validity of rename operations
537 /// before execution.
539
540 /// The client supports progress notifications.
541 /// window.workDoneProgress
542 bool WorkDoneProgress = false;
543
544 /// The client supports implicit $/progress work-done progress streams,
545 /// without a preceding window/workDoneProgress/create.
546 /// This is a clangd extension.
547 /// window.implicitWorkDoneProgressCreate
549
550 /// Whether the client claims to cancel stale requests.
551 /// general.staleRequestSupport.cancel
553
554 /// Whether the client implementation supports a refresh request sent from the
555 /// server to the client.
557
558 /// The client supports versioned document changes for WorkspaceEdit.
559 bool DocumentChanges = false;
560
561 /// The client supports change annotations on text edits,
562 bool ChangeAnnotation = false;
563
564 /// Whether the client supports the textDocument/inactiveRegions
565 /// notification. This is a clangd extension.
566 bool InactiveRegions = false;
567};
568bool fromJSON(const llvm::json::Value &, ClientCapabilities &,
569 llvm::json::Path);
570
571/// Clangd extension that's used in the 'compilationDatabaseChanges' in
572/// workspace/didChangeConfiguration to record updates to the in-memory
573/// compilation database.
575 std::string workingDirectory;
576 std::vector<std::string> compilationCommand;
577};
578bool fromJSON(const llvm::json::Value &, ClangdCompileCommand &,
579 llvm::json::Path);
580
581/// Clangd extension: parameters configurable at any time, via the
582/// `workspace/didChangeConfiguration` notification.
583/// LSP defines this type as `any`.
585 // Changes to the in-memory compilation database.
586 // The key of the map is a file name.
587 std::map<std::string, ClangdCompileCommand> compilationDatabaseChanges;
588};
589bool fromJSON(const llvm::json::Value &, ConfigurationSettings &,
590 llvm::json::Path);
591
592/// Clangd extension: parameters configurable at `initialize` time.
593/// LSP defines this type as `any`.
595 // What we can change through the didChangeConfiguration request, we can
596 // also set through the initialize request (initializationOptions field).
598
599 std::optional<std::string> compilationDatabasePath;
600 // Additional flags to be included in the "fallback command" used when
601 // the compilation database doesn't describe an opened file.
602 // The command used will be approximately `clang $FILE $fallbackFlags`.
603 std::vector<std::string> fallbackFlags;
604
605 /// Clients supports show file status for textDocument/clangd.fileStatus.
606 bool FileStatus = false;
607};
608bool fromJSON(const llvm::json::Value &, InitializationOptions &,
609 llvm::json::Path);
610
612 /// The process Id of the parent process that started
613 /// the server. Is null if the process has not been started by another
614 /// process. If the parent process is not alive then the server should exit
615 /// (see exit notification) its process.
616 std::optional<int> processId;
617
618 /// The rootPath of the workspace. Is null
619 /// if no folder is open.
620 ///
621 /// @deprecated in favour of rootUri.
622 std::optional<std::string> rootPath;
623
624 /// The rootUri of the workspace. Is null if no
625 /// folder is open. If both `rootPath` and `rootUri` are set
626 /// `rootUri` wins.
627 std::optional<URIForFile> rootUri;
628
629 // User provided initialization options.
630 // initializationOptions?: any;
631
632 /// The capabilities provided by the client (editor or tool)
634 /// The same data as capabilities, but not parsed (to expose to modules).
635 llvm::json::Object rawCapabilities;
636
637 /// The initial trace setting. If omitted trace is disabled ('off').
638 std::optional<TraceLevel> trace;
639
640 /// User-provided initialization options.
642};
643bool fromJSON(const llvm::json::Value &, InitializeParams &, llvm::json::Path);
644
646 /// The token to be used to report progress.
647 llvm::json::Value token = nullptr;
648};
649llvm::json::Value toJSON(const WorkDoneProgressCreateParams &P);
650
651template <typename T> struct ProgressParams {
652 /// The progress token provided by the client or server.
653 llvm::json::Value token = nullptr;
654
655 /// The progress data.
657};
658template <typename T> llvm::json::Value toJSON(const ProgressParams<T> &P) {
659 return llvm::json::Object{{"token", P.token}, {"value", P.value}};
660}
661/// To start progress reporting a $/progress notification with the following
662/// payload must be sent.
664 /// Mandatory title of the progress operation. Used to briefly inform about
665 /// the kind of operation being performed.
666 ///
667 /// Examples: "Indexing" or "Linking dependencies".
668 std::string title;
669
670 /// Controls if a cancel button should show to allow the user to cancel the
671 /// long-running operation. Clients that don't support cancellation are
672 /// allowed to ignore the setting.
673 bool cancellable = false;
674
675 /// Optional progress percentage to display (value 100 is considered 100%).
676 /// If not provided infinite progress is assumed and clients are allowed
677 /// to ignore the `percentage` value in subsequent in report notifications.
678 ///
679 /// The value should be steadily rising. Clients are free to ignore values
680 /// that are not following this rule.
681 ///
682 /// Clangd implementation note: we only send nonzero percentages in
683 /// the WorkProgressReport. 'true' here means percentages will be used.
684 bool percentage = false;
685};
686llvm::json::Value toJSON(const WorkDoneProgressBegin &);
687
688/// Reporting progress is done using the following payload.
690 /// Mandatory title of the progress operation. Used to briefly inform about
691 /// the kind of operation being performed.
692 ///
693 /// Examples: "Indexing" or "Linking dependencies".
694 std::string title;
695
696 /// Controls enablement state of a cancel button. This property is only valid
697 /// if a cancel button got requested in the `WorkDoneProgressStart` payload.
698 ///
699 /// Clients that don't support cancellation or don't support control
700 /// the button's enablement state are allowed to ignore the setting.
701 std::optional<bool> cancellable;
702
703 /// Optional, more detailed associated progress message. Contains
704 /// complementary information to the `title`.
705 ///
706 /// Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
707 /// If unset, the previous progress message (if any) is still valid.
708 std::optional<std::string> message;
709
710 /// Optional progress percentage to display (value 100 is considered 100%).
711 /// If not provided infinite progress is assumed and clients are allowed
712 /// to ignore the `percentage` value in subsequent in report notifications.
713 ///
714 /// The value should be steadily rising. Clients are free to ignore values
715 /// that are not following this rule.
716 std::optional<unsigned> percentage;
717};
718llvm::json::Value toJSON(const WorkDoneProgressReport &);
719//
720/// Signals the end of progress reporting.
722 /// Optional, a final message indicating to for example indicate the outcome
723 /// of the operation.
724 std::optional<std::string> message;
725};
726llvm::json::Value toJSON(const WorkDoneProgressEnd &);
727
728enum class MessageType {
729 /// An error message.
730 Error = 1,
731 /// A warning message.
732 Warning = 2,
733 /// An information message.
734 Info = 3,
735 /// A log message.
736 Log = 4,
737};
738llvm::json::Value toJSON(const MessageType &);
739
740/// The show message notification is sent from a server to a client to ask the
741/// client to display a particular message in the user interface.
743 /// The message type.
745 /// The actual message.
746 std::string message;
747};
748llvm::json::Value toJSON(const ShowMessageParams &);
749
751 /// The document that was opened.
753};
754bool fromJSON(const llvm::json::Value &, DidOpenTextDocumentParams &,
755 llvm::json::Path);
756
758 /// The document that was closed.
760};
761bool fromJSON(const llvm::json::Value &, DidCloseTextDocumentParams &,
762 llvm::json::Path);
763
765 /// The document that was saved.
767};
768bool fromJSON(const llvm::json::Value &, DidSaveTextDocumentParams &,
769 llvm::json::Path);
770
772 /// The range of the document that changed.
773 std::optional<Range> range;
774
775 /// The length of the range that got replaced.
776 std::optional<int> rangeLength;
777
778 /// The new text of the range/document.
779 std::string text;
780};
781bool fromJSON(const llvm::json::Value &, TextDocumentContentChangeEvent &,
782 llvm::json::Path);
783
785 /// The document that did change. The version number points
786 /// to the version after all provided content changes have
787 /// been applied.
789
790 /// The actual content changes.
791 std::vector<TextDocumentContentChangeEvent> contentChanges;
792
793 /// Forces diagnostics to be generated, or to not be generated, for this
794 /// version of the file. If not set, diagnostics are eventually consistent:
795 /// either they will be provided for this version or some subsequent one.
796 /// This is a clangd extension.
797 std::optional<bool> wantDiagnostics;
798
799 /// Force a complete rebuild of the file, ignoring all cached state. Slow!
800 /// This is useful to defeat clangd's assumption that missing headers will
801 /// stay missing.
802 /// This is a clangd extension.
803 bool forceRebuild = false;
804};
805bool fromJSON(const llvm::json::Value &, DidChangeTextDocumentParams &,
806 llvm::json::Path);
807
808enum class FileChangeType {
809 /// The file got created.
810 Created = 1,
811 /// The file got changed.
812 Changed = 2,
813 /// The file got deleted.
814 Deleted = 3
815};
816bool fromJSON(const llvm::json::Value &E, FileChangeType &Out,
817 llvm::json::Path);
818
819struct FileEvent {
820 /// The file's URI.
822 /// The change type.
824};
825bool fromJSON(const llvm::json::Value &, FileEvent &, llvm::json::Path);
826
828 /// The actual file events.
829 std::vector<FileEvent> changes;
830};
831bool fromJSON(const llvm::json::Value &, DidChangeWatchedFilesParams &,
832 llvm::json::Path);
833
836};
837bool fromJSON(const llvm::json::Value &, DidChangeConfigurationParams &,
838 llvm::json::Path);
839
840// Note: we do not parse FormattingOptions for *FormattingParams.
841// In general, we use a clang-format style detected from common mechanisms
842// (.clang-format files and the -fallback-style flag).
843// It would be possible to override these with FormatOptions, but:
844// - the protocol makes FormatOptions mandatory, so many clients set them to
845// useless values, and we can't tell when to respect them
846// - we also format in other places, where FormatOptions aren't available.
847
849 /// The document to format.
851
852 /// The range to format
854};
855bool fromJSON(const llvm::json::Value &, DocumentRangeFormattingParams &,
856 llvm::json::Path);
857
859 /// The document to format.
861
862 /// The position at which this request was sent.
864
865 /// The character that has been typed.
866 std::string ch;
867};
868bool fromJSON(const llvm::json::Value &, DocumentOnTypeFormattingParams &,
869 llvm::json::Path);
870
872 /// The document to format.
874};
875bool fromJSON(const llvm::json::Value &, DocumentFormattingParams &,
876 llvm::json::Path);
877
879 // The text document to find symbols in.
881};
882bool fromJSON(const llvm::json::Value &, DocumentSymbolParams &,
883 llvm::json::Path);
884
885/// Represents a related message and source code location for a diagnostic.
886/// This should be used to point to code locations that cause or related to a
887/// diagnostics, e.g when duplicating a symbol in a scope.
889 /// The location of this related diagnostic information.
891 /// The message of this related diagnostic information.
892 std::string message;
893};
894llvm::json::Value toJSON(const DiagnosticRelatedInformation &);
895
897 /// Unused or unnecessary code.
898 ///
899 /// Clients are allowed to render diagnostics with this tag faded out instead
900 /// of having an error squiggle.
902 /// Deprecated or obsolete code.
903 ///
904 /// Clients are allowed to rendered diagnostics with this tag strike through.
906};
907llvm::json::Value toJSON(DiagnosticTag Tag);
908
909/// Structure to capture a description for an error code.
911 /// An URI to open with more information about the diagnostic error.
912 std::string href;
913};
914llvm::json::Value toJSON(const CodeDescription &);
915
916struct CodeAction;
918 /// The range at which the message applies.
920
921 /// The diagnostic's severity. Can be omitted. If omitted it is up to the
922 /// client to interpret diagnostics as error, warning, info or hint.
923 int severity = 0;
924
925 /// The diagnostic's code. Can be omitted.
926 std::string code;
927
928 /// An optional property to describe the error code.
929 std::optional<CodeDescription> codeDescription;
930
931 /// A human-readable string describing the source of this
932 /// diagnostic, e.g. 'typescript' or 'super lint'.
933 std::string source;
934
935 /// The diagnostic's message.
936 std::string message;
937
938 /// Additional metadata about the diagnostic.
939 llvm::SmallVector<DiagnosticTag, 1> tags;
940
941 /// An array of related diagnostic information, e.g. when symbol-names within
942 /// a scope collide all definitions can be marked via this property.
943 std::optional<std::vector<DiagnosticRelatedInformation>> relatedInformation;
944
945 /// The diagnostic's category. Can be omitted.
946 /// An LSP extension that's used to send the name of the category over to the
947 /// client. The category typically describes the compilation stage during
948 /// which the issue was produced, e.g. "Semantic Issue" or "Parse Issue".
949 std::optional<std::string> category;
950
951 /// Clangd extension: code actions related to this diagnostic.
952 /// Only with capability textDocument.publishDiagnostics.codeActionsInline.
953 /// (These actions can also be obtained using textDocument/codeAction).
954 std::optional<std::vector<CodeAction>> codeActions;
955
956 /// A data entry field that is preserved between a
957 /// `textDocument/publishDiagnostics` notification
958 /// and `textDocument/codeAction` request.
959 /// Mutating users should associate their data with a unique key they can use
960 /// to retrieve later on.
961 llvm::json::Object data;
962};
963llvm::json::Value toJSON(const Diagnostic &);
964
965bool fromJSON(const llvm::json::Value &, Diagnostic &, llvm::json::Path);
966llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Diagnostic &);
967
969 /// The URI for which diagnostic information is reported.
971 /// An array of diagnostic information items.
972 std::vector<Diagnostic> diagnostics;
973 /// The version number of the document the diagnostics are published for.
974 std::optional<int64_t> version;
975};
976llvm::json::Value toJSON(const PublishDiagnosticsParams &);
977
979 /// An array of diagnostics known on the client side overlapping the range
980 /// provided to the `textDocument/codeAction` request. They are provided so
981 /// that the server knows which errors are currently presented to the user for
982 /// the given range. There is no guarantee that these accurately reflect the
983 /// error state of the resource. The primary parameter to compute code actions
984 /// is the provided range.
985 std::vector<Diagnostic> diagnostics;
986
987 /// Requested kind of actions to return.
988 ///
989 /// Actions not of this kind are filtered out by the client before being
990 /// shown. So servers can omit computing them.
991 std::vector<std::string> only;
992};
993bool fromJSON(const llvm::json::Value &, CodeActionContext &, llvm::json::Path);
994
996 /// The document in which the command was invoked.
998
999 /// The range for which the command was invoked.
1001
1002 /// Context carrying additional information.
1004};
1005bool fromJSON(const llvm::json::Value &, CodeActionParams &, llvm::json::Path);
1006
1007/// The edit should either provide changes or documentChanges. If the client
1008/// can handle versioned document edits and if documentChanges are present,
1009/// the latter are preferred over changes.
1011 /// Holds changes to existing resources.
1012 std::optional<std::map<std::string, std::vector<TextEdit>>> changes;
1013 /// Versioned document edits.
1014 ///
1015 /// If a client neither supports `documentChanges` nor
1016 /// `workspace.workspaceEdit.resourceOperations` then only plain `TextEdit`s
1017 /// using the `changes` property are supported.
1018 std::optional<std::vector<TextDocumentEdit>> documentChanges;
1019
1020 /// A map of change annotations that can be referenced in
1021 /// AnnotatedTextEdit.
1022 std::map<std::string, ChangeAnnotation> changeAnnotations;
1023};
1024bool fromJSON(const llvm::json::Value &, WorkspaceEdit &, llvm::json::Path);
1025llvm::json::Value toJSON(const WorkspaceEdit &WE);
1026
1027/// Arguments for the 'applyTweak' command. The server sends these commands as a
1028/// response to the textDocument/codeAction request. The client can later send a
1029/// command back to the server if the user requests to execute a particular code
1030/// tweak.
1032 /// A file provided by the client on a textDocument/codeAction request.
1034 /// A selection provided by the client on a textDocument/codeAction request.
1036 /// ID of the tweak that should be executed. Corresponds to Tweak::id().
1037 std::string tweakID;
1038};
1039bool fromJSON(const llvm::json::Value &, TweakArgs &, llvm::json::Path);
1040llvm::json::Value toJSON(const TweakArgs &A);
1041
1043 /// The identifier of the actual command handler.
1044 std::string command;
1045
1046 // This is `arguments?: []any` in LSP.
1047 // All clangd's commands accept a single argument (or none => null).
1048 llvm::json::Value argument = nullptr;
1049};
1050bool fromJSON(const llvm::json::Value &, ExecuteCommandParams &,
1051 llvm::json::Path);
1052
1053struct Command : public ExecuteCommandParams {
1054 std::string title;
1055};
1056llvm::json::Value toJSON(const Command &C);
1057
1058/// A code action represents a change that can be performed in code, e.g. to fix
1059/// a problem or to refactor code.
1060///
1061/// A CodeAction must set either `edit` and/or a `command`. If both are
1062/// supplied, the `edit` is applied first, then the `command` is executed.
1064 /// A short, human-readable, title for this code action.
1065 std::string title;
1066
1067 /// The kind of the code action.
1068 /// Used to filter code actions.
1069 std::optional<std::string> kind;
1070 const static llvm::StringLiteral QUICKFIX_KIND;
1071 const static llvm::StringLiteral REFACTOR_KIND;
1072 const static llvm::StringLiteral INFO_KIND;
1073
1074 /// The diagnostics that this code action resolves.
1075 std::optional<std::vector<Diagnostic>> diagnostics;
1076
1077 /// Marks this as a preferred action. Preferred actions are used by the
1078 /// `auto fix` command and can be targeted by keybindings.
1079 /// A quick fix should be marked preferred if it properly addresses the
1080 /// underlying error. A refactoring should be marked preferred if it is the
1081 /// most reasonable choice of actions to take.
1082 bool isPreferred = false;
1083
1084 /// The workspace edit this code action performs.
1085 std::optional<WorkspaceEdit> edit;
1086
1087 /// A command this code action executes. If a code action provides an edit
1088 /// and a command, first the edit is executed and then the command.
1089 std::optional<Command> command;
1090};
1091llvm::json::Value toJSON(const CodeAction &);
1092
1093/// Represents programming constructs like variables, classes, interfaces etc.
1094/// that appear in a document. Document symbols can be hierarchical and they
1095/// have two ranges: one that encloses its definition and one that points to its
1096/// most interesting range, e.g. the range of an identifier.
1098 /// The name of this symbol.
1099 std::string name;
1100
1101 /// More detail for this symbol, e.g the signature of a function.
1102 std::string detail;
1103
1104 /// The kind of this symbol.
1106
1107 /// Indicates if this symbol is deprecated.
1108 bool deprecated = false;
1109
1110 /// The range enclosing this symbol not including leading/trailing whitespace
1111 /// but everything else like comments. This information is typically used to
1112 /// determine if the clients cursor is inside the symbol to reveal in the
1113 /// symbol in the UI.
1115
1116 /// The range that should be selected and revealed when this symbol is being
1117 /// picked, e.g the name of a function. Must be contained by the `range`.
1119
1120 /// Children of this symbol, e.g. properties of a class.
1121 std::vector<DocumentSymbol> children;
1122};
1123llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const DocumentSymbol &S);
1124llvm::json::Value toJSON(const DocumentSymbol &S);
1125
1126/// Represents information about programming constructs like variables, classes,
1127/// interfaces etc.
1129 /// The name of this symbol.
1130 std::string name;
1131
1132 /// The kind of this symbol.
1134
1135 /// The location of this symbol.
1137
1138 /// The name of the symbol containing this symbol.
1139 std::string containerName;
1140
1141 /// The score that clangd calculates to rank the returned symbols.
1142 /// This excludes the fuzzy-matching score between `name` and the query.
1143 /// (Specifically, the last ::-separated component).
1144 /// This can be used to re-rank results as the user types, using client-side
1145 /// fuzzy-matching (that score should be multiplied with this one).
1146 /// This is a clangd extension, set only for workspace/symbol responses.
1147 std::optional<float> score;
1148};
1149llvm::json::Value toJSON(const SymbolInformation &);
1150llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SymbolInformation &);
1151
1152/// Represents information about identifier.
1153/// This is returned from textDocument/symbolInfo, which is a clangd extension.
1155 std::string name;
1156
1157 std::string containerName;
1158
1159 /// Unified Symbol Resolution identifier
1160 /// This is an opaque string uniquely identifying a symbol.
1161 /// Unlike SymbolID, it is variable-length and somewhat human-readable.
1162 /// It is a common representation across several clang tools.
1163 /// (See USRGeneration.h)
1164 std::string USR;
1165
1167
1168 std::optional<Location> declarationRange;
1169
1170 std::optional<Location> definitionRange;
1171};
1172llvm::json::Value toJSON(const SymbolDetails &);
1173llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SymbolDetails &);
1174bool operator==(const SymbolDetails &, const SymbolDetails &);
1175
1176/// The parameters of a Workspace Symbol Request.
1178 /// A query string to filter symbols by.
1179 /// Clients may send an empty string here to request all the symbols.
1180 std::string query;
1181
1182 /// Max results to return, overriding global default. 0 means no limit.
1183 /// Clangd extension.
1184 std::optional<int> limit;
1185};
1186bool fromJSON(const llvm::json::Value &, WorkspaceSymbolParams &,
1187 llvm::json::Path);
1188
1191};
1192llvm::json::Value toJSON(const ApplyWorkspaceEditParams &);
1193
1195 bool applied = true;
1196 std::optional<std::string> failureReason;
1197};
1198bool fromJSON(const llvm::json::Value &, ApplyWorkspaceEditResponse &,
1199 llvm::json::Path);
1200
1202 /// The text document.
1204
1205 /// The position inside the text document.
1207};
1208bool fromJSON(const llvm::json::Value &, TextDocumentPositionParams &,
1209 llvm::json::Path);
1210
1212 /// Completion was triggered by typing an identifier (24x7 code
1213 /// complete), manual invocation (e.g Ctrl+Space) or via API.
1214 Invoked = 1,
1215 /// Completion was triggered by a trigger character specified by
1216 /// the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
1217 TriggerCharacter = 2,
1218 /// Completion was re-triggered as the current completion list is incomplete.
1220};
1221
1223 /// How the completion was triggered.
1225 /// The trigger character (a single character) that has trigger code complete.
1226 /// Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
1227 std::string triggerCharacter;
1228};
1229bool fromJSON(const llvm::json::Value &, CompletionContext &, llvm::json::Path);
1230
1233
1234 /// Max results to return, overriding global default. 0 means no limit.
1235 /// Clangd extension.
1236 std::optional<int> limit;
1237};
1238bool fromJSON(const llvm::json::Value &, CompletionParams &, llvm::json::Path);
1239
1242 std::string value;
1243};
1244llvm::json::Value toJSON(const MarkupContent &MC);
1245
1246struct Hover {
1247 /// The hover's content
1249
1250 /// An optional range is a range inside a text document
1251 /// that is used to visualize a hover, e.g. by changing the background color.
1252 std::optional<Range> range;
1253};
1254llvm::json::Value toJSON(const Hover &H);
1255
1256/// Defines whether the insert text in a completion item should be interpreted
1257/// as plain text or a snippet.
1259 Missing = 0,
1260 /// The primary text to be inserted is treated as a plain string.
1261 PlainText = 1,
1262 /// The primary text to be inserted is treated as a snippet.
1263 ///
1264 /// A snippet can define tab stops and placeholders with `$1`, `$2`
1265 /// and `${3:foo}`. `$0` defines the final tab stop, it defaults to the end
1266 /// of the snippet. Placeholders with equal identifiers are linked, that is
1267 /// typing in one will update others too.
1268 ///
1269 /// See also:
1270 /// https://github.com/Microsoft/vscode/blob/main/src/vs/editor/contrib/snippet/snippet.md
1271 Snippet = 2,
1272};
1273
1274/// Additional details for a completion item label.
1276 /// An optional string which is rendered less prominently directly after label
1277 /// without any spacing. Should be used for function signatures or type
1278 /// annotations.
1279 std::string detail;
1280
1281 /// An optional string which is rendered less prominently after
1282 /// CompletionItemLabelDetails.detail. Should be used for fully qualified
1283 /// names or file path.
1284 std::string description;
1285};
1286llvm::json::Value toJSON(const CompletionItemLabelDetails &);
1287
1289 /// The label of this completion item. By default also the text that is
1290 /// inserted when selecting this completion.
1291 std::string label;
1292
1293 /// Additional details for the label.
1294 std::optional<CompletionItemLabelDetails> labelDetails;
1295
1296 /// The kind of this completion item. Based of the kind an icon is chosen by
1297 /// the editor.
1299
1300 /// A human-readable string with additional information about this item, like
1301 /// type or symbol information.
1302 std::string detail;
1303
1304 /// A human-readable string that represents a doc-comment.
1305 std::optional<MarkupContent> documentation;
1306
1307 /// A string that should be used when comparing this item with other items.
1308 /// When `falsy` the label is used.
1309 std::string sortText;
1310
1311 /// A string that should be used when filtering a set of completion items.
1312 /// When `falsy` the label is used.
1313 std::string filterText;
1314
1315 /// A string that should be inserted to a document when selecting this
1316 /// completion. When `falsy` the label is used.
1317 std::string insertText;
1318
1319 /// The format of the insert text. The format applies to both the `insertText`
1320 /// property and the `newText` property of a provided `textEdit`.
1322
1323 /// An edit which is applied to a document when selecting this completion.
1324 /// When an edit is provided `insertText` is ignored.
1325 ///
1326 /// Note: The range of the edit must be a single line range and it must
1327 /// contain the position at which completion has been requested.
1328 std::optional<TextEdit> textEdit;
1329
1330 /// An optional array of additional text edits that are applied when selecting
1331 /// this completion. Edits must not overlap with the main edit nor with
1332 /// themselves.
1333 std::vector<TextEdit> additionalTextEdits;
1334
1335 /// Indicates if this item is deprecated.
1336 bool deprecated = false;
1337
1338 /// The score that clangd calculates to rank the returned completions.
1339 /// This excludes the fuzzy-match between `filterText` and the partial word.
1340 /// This can be used to re-rank results as the user types, using client-side
1341 /// fuzzy-matching (that score should be multiplied with this one).
1342 /// This is a clangd extension.
1343 float score = 0.f;
1344
1345 // TODO: Add custom commitCharacters for some of the completion items. For
1346 // example, it makes sense to use () only for the functions.
1347 // TODO(krasimir): The following optional fields defined by the language
1348 // server protocol are unsupported:
1349 //
1350 // data?: any - A data entry field that is preserved on a completion item
1351 // between a completion and a completion resolve request.
1352};
1353llvm::json::Value toJSON(const CompletionItem &);
1354llvm::raw_ostream &operator<<(llvm::raw_ostream &, const CompletionItem &);
1355
1356/// Remove the labelDetails field (for clients that don't support it).
1357/// Places the information into other fields of the completion item.
1359
1360bool operator<(const CompletionItem &, const CompletionItem &);
1361
1362/// Represents a collection of completion items to be presented in the editor.
1364 /// The list is not complete. Further typing should result in recomputing the
1365 /// list.
1366 bool isIncomplete = false;
1367
1368 /// The completion items.
1369 std::vector<CompletionItem> items;
1370};
1371llvm::json::Value toJSON(const CompletionList &);
1372
1373/// A single parameter of a particular signature.
1375
1376 /// The label of this parameter. Ignored when labelOffsets is set.
1377 std::string labelString;
1378
1379 /// Inclusive start and exclusive end offsets withing the containing signature
1380 /// label.
1381 /// Offsets are computed by lspLength(), which counts UTF-16 code units by
1382 /// default but that can be overriden, see its documentation for details.
1383 std::optional<std::pair<unsigned, unsigned>> labelOffsets;
1384
1385 /// The documentation of this parameter. Optional.
1386 std::string documentation;
1387};
1388llvm::json::Value toJSON(const ParameterInformation &);
1389
1390/// Represents the signature of something callable.
1392
1393 /// The label of this signature. Mandatory.
1394 std::string label;
1395
1396 /// The documentation of this signature. Optional.
1398
1399 /// The parameters of this signature.
1400 std::vector<ParameterInformation> parameters;
1401};
1402llvm::json::Value toJSON(const SignatureInformation &);
1403llvm::raw_ostream &operator<<(llvm::raw_ostream &,
1404 const SignatureInformation &);
1405
1406/// Represents the signature of a callable.
1408
1409 /// The resulting signatures.
1410 std::vector<SignatureInformation> signatures;
1411
1412 /// The active signature.
1414
1415 /// The active parameter of the active signature.
1417
1418 /// Position of the start of the argument list, including opening paren. e.g.
1419 /// foo("first arg", "second arg",
1420 /// ^-argListStart ^-cursor
1421 /// This is a clangd-specific extension, it is only available via C++ API and
1422 /// not currently serialized for the LSP.
1424};
1425llvm::json::Value toJSON(const SignatureHelp &);
1426
1428 /// The document that was opened.
1430
1431 /// The position at which this request was sent.
1433
1434 /// The new name of the symbol.
1435 std::string newName;
1436};
1437bool fromJSON(const llvm::json::Value &, RenameParams &, llvm::json::Path);
1438llvm::json::Value toJSON(const RenameParams &);
1439
1441 /// Range of the string to rename.
1443 /// Placeholder text to use in the editor if non-empty.
1444 std::string placeholder;
1445};
1446llvm::json::Value toJSON(const PrepareRenameResult &PRR);
1447
1448enum class DocumentHighlightKind { Text = 1, Read = 2, Write = 3 };
1449
1450/// A document highlight is a range inside a text document which deserves
1451/// special attention. Usually a document highlight is visualized by changing
1452/// the background color of its range.
1453
1455 /// The range this highlight applies to.
1457
1458 /// The highlight kind, default is DocumentHighlightKind.Text.
1460
1461 friend bool operator<(const DocumentHighlight &LHS,
1462 const DocumentHighlight &RHS) {
1463 int LHSKind = static_cast<int>(LHS.kind);
1464 int RHSKind = static_cast<int>(RHS.kind);
1465 return std::tie(LHS.range, LHSKind) < std::tie(RHS.range, RHSKind);
1466 }
1467
1468 friend bool operator==(const DocumentHighlight &LHS,
1469 const DocumentHighlight &RHS) {
1470 return LHS.kind == RHS.kind && LHS.range == RHS.range;
1471 }
1472};
1473llvm::json::Value toJSON(const DocumentHighlight &DH);
1474llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DocumentHighlight &);
1475
1476enum class TypeHierarchyDirection { Children = 0, Parents = 1, Both = 2 };
1477bool fromJSON(const llvm::json::Value &E, TypeHierarchyDirection &Out,
1478 llvm::json::Path);
1479
1480/// The type hierarchy params is an extension of the
1481/// `TextDocumentPositionsParams` with optional properties which can be used to
1482/// eagerly resolve the item when requesting from the server.
1484 /// The hierarchy levels to resolve. `0` indicates no level.
1485 /// This is a clangd extension.
1486 int resolve = 0;
1487
1488 /// The direction of the hierarchy levels to resolve.
1489 /// This is a clangd extension.
1491};
1492bool fromJSON(const llvm::json::Value &, TypeHierarchyPrepareParams &,
1493 llvm::json::Path);
1494
1496 /// The name of this item.
1497 std::string name;
1498
1499 /// The kind of this item.
1501
1502 /// More detail for this item, e.g. the signature of a function.
1503 std::optional<std::string> detail;
1504
1505 /// The resource identifier of this item.
1507
1508 /// The range enclosing this symbol not including leading/trailing whitespace
1509 /// but everything else, e.g. comments and code.
1511
1512 /// The range that should be selected and revealed when this symbol is being
1513 /// picked, e.g. the name of a function. Must be contained by the `range`.
1515
1516 /// Used to resolve a client provided item back.
1519 /// std::nullopt means parents aren't resolved and empty is no parents.
1520 std::optional<std::vector<ResolveParams>> parents;
1521 };
1522 /// A data entry field that is preserved between a type hierarchy prepare and
1523 /// supertypes or subtypes requests. It could also be used to identify the
1524 /// type hierarchy in the server, helping improve the performance on resolving
1525 /// supertypes and subtypes.
1527
1528 /// `true` if the hierarchy item is deprecated. Otherwise, `false`.
1529 /// This is a clangd exntesion.
1530 bool deprecated = false;
1531
1532 /// This is a clangd exntesion.
1533 std::optional<std::vector<TypeHierarchyItem>> parents;
1534
1535 /// If this type hierarchy item is resolved, it contains the direct children
1536 /// of the current item. Could be empty if the item does not have any
1537 /// descendants. If not defined, the children have not been resolved.
1538 /// This is a clangd exntesion.
1539 std::optional<std::vector<TypeHierarchyItem>> children;
1540};
1541llvm::json::Value toJSON(const TypeHierarchyItem::ResolveParams &);
1543llvm::json::Value toJSON(const TypeHierarchyItem &);
1544llvm::raw_ostream &operator<<(llvm::raw_ostream &, const TypeHierarchyItem &);
1545bool fromJSON(const llvm::json::Value &, TypeHierarchyItem &, llvm::json::Path);
1546
1547/// Parameters for the `typeHierarchy/resolve` request.
1549 /// The item to resolve.
1551
1552 /// The hierarchy levels to resolve. `0` indicates no level.
1554
1555 /// The direction of the hierarchy levels to resolve.
1557};
1558bool fromJSON(const llvm::json::Value &, ResolveTypeHierarchyItemParams &,
1559 llvm::json::Path);
1560
1561enum class SymbolTag { Deprecated = 1 };
1562llvm::json::Value toJSON(SymbolTag);
1563
1564/// The parameter of a `textDocument/prepareCallHierarchy` request.
1566
1567/// Represents programming constructs like functions or constructors
1568/// in the context of call hierarchy.
1570 /// The name of this item.
1571 std::string name;
1572
1573 /// The kind of this item.
1575
1576 /// Tags for this item.
1577 std::vector<SymbolTag> tags;
1578
1579 /// More detaill for this item, e.g. the signature of a function.
1580 std::string detail;
1581
1582 /// The resource identifier of this item.
1584
1585 /// The range enclosing this symbol not including leading / trailing
1586 /// whitespace but everything else, e.g. comments and code.
1588
1589 /// The range that should be selected and revealed when this symbol
1590 /// is being picked, e.g. the name of a function.
1591 /// Must be contained by `Rng`.
1593
1594 /// An optional 'data' field, which can be used to identify a call
1595 /// hierarchy item in an incomingCalls or outgoingCalls request.
1596 std::string data;
1597};
1598llvm::json::Value toJSON(const CallHierarchyItem &);
1599bool fromJSON(const llvm::json::Value &, CallHierarchyItem &, llvm::json::Path);
1600
1601/// The parameter of a `callHierarchy/incomingCalls` request.
1604};
1605bool fromJSON(const llvm::json::Value &, CallHierarchyIncomingCallsParams &,
1606 llvm::json::Path);
1607
1608/// Represents an incoming call, e.g. a caller of a method or constructor.
1610 /// The item that makes the call.
1612
1613 /// The range at which the calls appear.
1614 /// This is relative to the caller denoted by `From`.
1615 std::vector<Range> fromRanges;
1616};
1617llvm::json::Value toJSON(const CallHierarchyIncomingCall &);
1618
1619/// The parameter of a `callHierarchy/outgoingCalls` request.
1622};
1623bool fromJSON(const llvm::json::Value &, CallHierarchyOutgoingCallsParams &,
1624 llvm::json::Path);
1625
1626/// Represents an outgoing call, e.g. calling a getter from a method or
1627/// a method from a constructor etc.
1629 /// The item that is called.
1631
1632 /// The range at which this item is called.
1633 /// This is the range relative to the caller, and not `To`.
1634 std::vector<Range> fromRanges;
1635};
1636llvm::json::Value toJSON(const CallHierarchyOutgoingCall &);
1637
1638/// A parameter literal used in inlay hint requests.
1640 /// The text document.
1642
1643 /// The visible document range for which inlay hints should be computed.
1644 ///
1645 /// std::nullopt is a clangd extension, which hints for computing hints on the
1646 /// whole file.
1647 std::optional<Range> range;
1648};
1649bool fromJSON(const llvm::json::Value &, InlayHintsParams &, llvm::json::Path);
1650
1651/// Inlay hint kinds.
1652enum class InlayHintKind {
1653 /// An inlay hint that for a type annotation.
1654 ///
1655 /// An example of a type hint is a hint in this position:
1656 /// auto var ^ = expr;
1657 /// which shows the deduced type of the variable.
1658 Type = 1,
1659
1660 /// An inlay hint that is for a parameter.
1661 ///
1662 /// An example of a parameter hint is a hint in this position:
1663 /// func(^arg);
1664 /// which shows the name of the corresponding parameter.
1665 Parameter = 2,
1666
1667 /// A hint before an element of an aggregate braced initializer list,
1668 /// indicating what it is initializing.
1669 /// Pair{^1, ^2};
1670 /// Uses designator syntax, e.g. `.first:`.
1671 /// This is a clangd extension.
1672 Designator = 3,
1673
1674 /// A hint after function, type or namespace definition, indicating the
1675 /// defined symbol name of the definition.
1676 ///
1677 /// An example of a decl name hint in this position:
1678 /// void func() {
1679 /// } ^
1680 /// Uses comment-like syntax like "// func".
1681 /// This is a clangd extension.
1682 BlockEnd = 4,
1683
1684 /// Other ideas for hints that are not currently implemented:
1685 ///
1686 /// * Chaining hints, showing the types of intermediate expressions
1687 /// in a chain of function calls.
1688 /// * Hints indicating implicit conversions or implicit constructor calls.
1689};
1690llvm::json::Value toJSON(const InlayHintKind &);
1691
1692/// Inlay hint information.
1694 /// The position of this hint.
1696
1697 /// The label of this hint. A human readable string or an array of
1698 /// InlayHintLabelPart label parts.
1699 ///
1700 /// *Note* that neither the string nor the label part can be empty.
1701 std::string label;
1702
1703 /// The kind of this hint. Can be omitted in which case the client should fall
1704 /// back to a reasonable default.
1706
1707 /// Render padding before the hint.
1708 ///
1709 /// Note: Padding should use the editor's background color, not the
1710 /// background color of the hint itself. That means padding can be used
1711 /// to visually align/separate an inlay hint.
1712 bool paddingLeft = false;
1713
1714 /// Render padding after the hint.
1715 ///
1716 /// Note: Padding should use the editor's background color, not the
1717 /// background color of the hint itself. That means padding can be used
1718 /// to visually align/separate an inlay hint.
1719 bool paddingRight = false;
1720
1721 /// The range of source code to which the hint applies.
1722 ///
1723 /// For example, a parameter hint may have the argument as its range.
1724 /// The range allows clients more flexibility of when/how to display the hint.
1725 /// This is an (unserialized) clangd extension.
1727};
1728llvm::json::Value toJSON(const InlayHint &);
1729bool operator==(const InlayHint &, const InlayHint &);
1730bool operator<(const InlayHint &, const InlayHint &);
1731llvm::raw_ostream &operator<<(llvm::raw_ostream &, InlayHintKind);
1732
1734 /// Include the declaration of the current symbol.
1736};
1737
1740};
1741bool fromJSON(const llvm::json::Value &, ReferenceParams &, llvm::json::Path);
1742
1743/// Clangd extension: indicates the current state of the file in clangd,
1744/// sent from server via the `textDocument/clangd.fileStatus` notification.
1746 /// The text document's URI.
1748 /// The human-readable string presents the current state of the file, can be
1749 /// shown in the UI (e.g. status bar).
1750 std::string state;
1751 // FIXME: add detail messages.
1752};
1753llvm::json::Value toJSON(const FileStatus &);
1754
1755/// Specifies a single semantic token in the document.
1756/// This struct is not part of LSP, which just encodes lists of tokens as
1757/// arrays of numbers directly.
1759 /// token line number, relative to the previous token
1760 unsigned deltaLine = 0;
1761 /// token start character, relative to the previous token
1762 /// (relative to 0 or the previous token's start if they are on the same line)
1763 unsigned deltaStart = 0;
1764 /// the length of the token. A token cannot be multiline
1765 unsigned length = 0;
1766 /// will be looked up in `SemanticTokensLegend.tokenTypes`
1767 unsigned tokenType = 0;
1768 /// each set bit will be looked up in `SemanticTokensLegend.tokenModifiers`
1769 unsigned tokenModifiers = 0;
1770};
1771bool operator==(const SemanticToken &, const SemanticToken &);
1772
1773/// A versioned set of tokens.
1775 // An optional result id. If provided and clients support delta updating
1776 // the client will include the result id in the next semantic token request.
1777 // A server can then instead of computing all semantic tokens again simply
1778 // send a delta.
1779 std::string resultId;
1780
1781 /// The actual tokens.
1782 std::vector<SemanticToken> tokens; // encoded as a flat integer array.
1783};
1784llvm::json::Value toJSON(const SemanticTokens &);
1785
1786/// Body of textDocument/semanticTokens/full request.
1788 /// The text document.
1790};
1791bool fromJSON(const llvm::json::Value &, SemanticTokensParams &,
1792 llvm::json::Path);
1793
1794/// Body of textDocument/semanticTokens/full/delta request.
1795/// Requests the changes in semantic tokens since a previous response.
1797 /// The text document.
1799 /// The previous result id.
1800 std::string previousResultId;
1801};
1802bool fromJSON(const llvm::json::Value &Params, SemanticTokensDeltaParams &R,
1803 llvm::json::Path);
1804
1805/// Describes a replacement of a contiguous range of semanticTokens.
1807 // LSP specifies `start` and `deleteCount` which are relative to the array
1808 // encoding of the previous tokens.
1809 // We use token counts instead, and translate when serializing this struct.
1810 unsigned startToken = 0;
1811 unsigned deleteTokens = 0;
1812 std::vector<SemanticToken> tokens; // encoded as a flat integer array
1813};
1814llvm::json::Value toJSON(const SemanticTokensEdit &);
1815
1816/// This models LSP SemanticTokensDelta | SemanticTokens, which is the result of
1817/// textDocument/semanticTokens/full/delta.
1819 std::string resultId;
1820 /// Set if we computed edits relative to a previous set of tokens.
1821 std::optional<std::vector<SemanticTokensEdit>> edits;
1822 /// Set if we computed a fresh set of tokens.
1823 std::optional<std::vector<SemanticToken>> tokens; // encoded as integer array
1824};
1825llvm::json::Value toJSON(const SemanticTokensOrDelta &);
1826
1827/// Parameters for the inactive regions (server-side) push notification.
1828/// This is a clangd extension.
1830 /// The textdocument these inactive regions belong to.
1832 /// The inactive regions that should be sent.
1833 std::vector<Range> InactiveRegions;
1834};
1835llvm::json::Value toJSON(const InactiveRegionsParams &InactiveRegions);
1836
1838 /// The text document.
1840
1841 /// The positions inside the text document.
1842 std::vector<Position> positions;
1843};
1844bool fromJSON(const llvm::json::Value &, SelectionRangeParams &,
1845 llvm::json::Path);
1846
1848 /**
1849 * The range of this selection range.
1850 */
1852 /**
1853 * The parent selection range containing this range. Therefore `parent.range`
1854 * must contain `this.range`.
1855 */
1856 std::unique_ptr<SelectionRange> parent;
1857};
1858llvm::json::Value toJSON(const SelectionRange &);
1859
1860/// Parameters for the document link request.
1862 /// The document to provide document links for.
1864};
1865bool fromJSON(const llvm::json::Value &, DocumentLinkParams &,
1866 llvm::json::Path);
1867
1868/// A range in a text document that links to an internal or external resource,
1869/// like another text document or a web site.
1871 /// The range this link applies to.
1873
1874 /// The uri this link points to. If missing a resolve request is sent later.
1876
1877 // TODO(forster): The following optional fields defined by the language
1878 // server protocol are unsupported:
1879 //
1880 // data?: any - A data entry field that is preserved on a document link
1881 // between a DocumentLinkRequest and a
1882 // DocumentLinkResolveRequest.
1883
1884 friend bool operator==(const DocumentLink &LHS, const DocumentLink &RHS) {
1885 return LHS.range == RHS.range && LHS.target == RHS.target;
1886 }
1887
1888 friend bool operator!=(const DocumentLink &LHS, const DocumentLink &RHS) {
1889 return !(LHS == RHS);
1890 }
1891};
1892llvm::json::Value toJSON(const DocumentLink &DocumentLink);
1893
1894// FIXME(kirillbobyrev): Add FoldingRangeClientCapabilities so we can support
1895// per-line-folding editors.
1898};
1899bool fromJSON(const llvm::json::Value &, FoldingRangeParams &,
1900 llvm::json::Path);
1901
1902/// Stores information about a region of code that can be folded.
1904 unsigned startLine = 0;
1906 unsigned endLine = 0;
1908
1909 const static llvm::StringLiteral REGION_KIND;
1910 const static llvm::StringLiteral COMMENT_KIND;
1911 const static llvm::StringLiteral IMPORT_KIND;
1912 std::string kind;
1913};
1914llvm::json::Value toJSON(const FoldingRange &Range);
1915
1916/// Keys starting with an underscore(_) represent leaves, e.g. _total or _self
1917/// for memory usage of whole subtree or only that specific node in bytes. All
1918/// other keys represents children. An example:
1919/// {
1920/// "_self": 0,
1921/// "_total": 8,
1922/// "child1": {
1923/// "_self": 4,
1924/// "_total": 4,
1925/// }
1926/// "child2": {
1927/// "_self": 2,
1928/// "_total": 4,
1929/// "child_deep": {
1930/// "_self": 2,
1931/// "_total": 2,
1932/// }
1933/// }
1934/// }
1935llvm::json::Value toJSON(const MemoryTree &MT);
1936
1937/// Payload for textDocument/ast request.
1938/// This request is a clangd extension.
1940 /// The text document.
1942
1943 /// The position of the node to be dumped.
1944 /// The highest-level node that entirely contains the range will be returned.
1945 /// If no range is given, the root translation unit node will be returned.
1946 std::optional<Range> range;
1947};
1948bool fromJSON(const llvm::json::Value &, ASTParams &, llvm::json::Path);
1949
1950/// Simplified description of a clang AST node.
1951/// This is clangd's internal representation of C++ code.
1952struct ASTNode {
1953 /// The general kind of node, such as "expression"
1954 /// Corresponds to the base AST node type such as Expr.
1955 std::string role;
1956 /// The specific kind of node this is, such as "BinaryOperator".
1957 /// This is usually a concrete node class (with Expr etc suffix dropped).
1958 /// When there's no hierarchy (e.g. TemplateName), the variant (NameKind).
1959 std::string kind;
1960 /// Brief additional information, such as "||" for the particular operator.
1961 /// The information included depends on the node kind, and may be empty.
1962 std::string detail;
1963 /// A one-line dump of detailed information about the node.
1964 /// This includes role/kind/description information, but is rather cryptic.
1965 /// It is similar to the output from `clang -Xclang -ast-dump`.
1966 /// May be empty for certain types of nodes.
1967 std::string arcana;
1968 /// The range of the original source file covered by this node.
1969 /// May be missing for implicit nodes, or those created by macro expansion.
1970 std::optional<Range> range;
1971 /// Nodes nested within this one, such as the operands of a BinaryOperator.
1972 std::vector<ASTNode> children;
1973};
1974llvm::json::Value toJSON(const ASTNode &);
1975llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ASTNode &);
1976
1977} // namespace clangd
1978} // namespace clang
1979
1980namespace llvm {
1981
1982template <> struct DenseMapInfo<clang::clangd::Range> {
1984 static inline Range getEmptyKey() {
1985 static clang::clangd::Position Tomb{-1, -1};
1986 static Range R{Tomb, Tomb};
1987 return R;
1988 }
1989 static inline Range getTombstoneKey() {
1990 static clang::clangd::Position Tomb{-2, -2};
1991 static Range R{Tomb, Tomb};
1992 return R;
1993 }
1994 static unsigned getHashValue(const Range &Val) {
1995 return llvm::hash_combine(Val.start.line, Val.start.character, Val.end.line,
1996 Val.end.character);
1997 }
1998 static bool isEqual(const Range &LHS, const Range &RHS) {
1999 return std::tie(LHS.start, LHS.end) == std::tie(RHS.start, RHS.end);
2000 }
2001};
2002
2003template <> struct format_provider<clang::clangd::Position> {
2004 static void format(const clang::clangd::Position &Pos, raw_ostream &OS,
2005 StringRef Style) {
2006 assert(Style.empty() && "style modifiers for this type are not supported");
2007 OS << Pos;
2008 }
2009};
2010} // namespace llvm
2011
2012// NOLINTEND(readability-identifier-naming)
2013
2014#endif
const Expr * E
BindArgumentKind Kind
CompiledFragmentImpl & Out
const Criteria C
HTMLTag Tag
size_t Pos
llvm::raw_string_ostream OS
Definition: TraceTests.cpp:160
An Event<T> allows events of type T to be broadcast to listeners.
Definition: Function.h:31
Values in a Context are indexed by typed keys.
Definition: Context.h:40
LSPError(std::string Message, ErrorCode Code)
Definition: Protocol.h:69
std::error_code convertToErrorCode() const override
Definition: Protocol.h:75
void log(llvm::raw_ostream &OS) const override
Definition: Protocol.h:72
std::string Message
Definition: Protocol.h:65
A URI describes the location of a source file.
Definition: URI.h:28
static URI createFile(llvm::StringRef AbsolutePath)
This creates a file:// URI for AbsolutePath. The path must be absolute.
Definition: URI.cpp:237
std::string toString() const
Returns a string URI with all components percent-encoded.
Definition: URI.cpp:160
SymbolKind
The SymbolInfo Type.
Definition: SymbolInfo.h:29
@ Created
The file got created.
@ Deleted
The file got deleted.
@ Changed
The file got changed.
constexpr auto CompletionItemKindMax
Definition: Protocol.h:370
@ Warning
A warning message.
@ Info
An information message.
@ Error
An error message.
std::bitset< SymbolKindMax+1 > SymbolKindBitset
Definition: Protocol.h:411
constexpr auto CompletionItemKindMin
Definition: Protocol.h:368
constexpr auto SymbolKindMin
Definition: Protocol.h:409
CompletionItemKind
The kind of a completion entry.
Definition: Protocol.h:338
@ Invoked
Completion was triggered by typing an identifier (24x7 code complete), manual invocation (e....
@ TriggerTriggerForIncompleteCompletions
Completion was re-triggered as the current completion list is incomplete.
@ TriggerCharacter
Completion was triggered by a trigger character specified by the triggerCharacters properties of the ...
bool operator==(const Inclusion &LHS, const Inclusion &RHS)
Definition: Headers.cpp:331
llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, const CodeCompletion &C)
llvm::json::Value toJSON(const FuzzyFindRequest &Request)
Definition: Index.cpp:45
SymbolKind adjustKindToCapability(SymbolKind Kind, SymbolKindBitset &SupportedSymbolKinds)
Definition: Protocol.cpp:280
std::string ChangeAnnotationIdentifier
Definition: Protocol.h:241
void removeCompletionLabelDetails(CompletionItem &C)
Remove the labelDetails field (for clients that don't support it).
Definition: Protocol.cpp:1084
bool operator<(const Ref &L, const Ref &R)
Definition: Ref.h:95
SymbolKind indexSymbolKindToSymbolKind(index::SymbolKind Kind)
Definition: Protocol.cpp:298
InlayHintKind
Inlay hint kinds.
Definition: Protocol.h:1652
@ BlockEnd
A hint after function, type or namespace definition, indicating the defined symbol name of the defini...
@ Parameter
An inlay hint that is for a parameter.
@ Type
An inlay hint that for a type annotation.
@ Designator
A hint before an element of an aggregate braced initializer list, indicating what it is initializing.
constexpr auto SymbolKindMax
Definition: Protocol.h:410
std::bitset< CompletionItemKindMax+1 > CompletionItemKindBitset
Definition: Protocol.h:372
@ Deprecated
Deprecated or obsolete code.
Definition: Protocol.h:905
@ Unnecessary
Unused or unnecessary code.
Definition: Protocol.h:901
TextDocumentSyncKind
Defines how the host (editor) should sync document changes to the language server.
Definition: Protocol.h:325
@ Incremental
Documents are synced by sending the full content on open.
@ Full
Documents are synced by always sending the full content of the document.
InsertTextFormat
Defines whether the insert text in a completion item should be interpreted as plain text or a snippet...
Definition: Protocol.h:1258
bool fromJSON(const llvm::json::Value &Parameters, FuzzyFindRequest &Request, llvm::json::Path P)
Definition: Index.cpp:30
SymbolKind
A symbol kind.
Definition: Protocol.h:380
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Some operations such as code completion produce a set of candidates.
Simplified description of a clang AST node.
Definition: Protocol.h:1952
std::optional< Range > range
The range of the original source file covered by this node.
Definition: Protocol.h:1970
std::vector< ASTNode > children
Nodes nested within this one, such as the operands of a BinaryOperator.
Definition: Protocol.h:1972
std::string role
The general kind of node, such as "expression" Corresponds to the base AST node type such as Expr.
Definition: Protocol.h:1955
std::string kind
The specific kind of node this is, such as "BinaryOperator".
Definition: Protocol.h:1959
std::string detail
Brief additional information, such as "||" for the particular operator.
Definition: Protocol.h:1962
std::string arcana
A one-line dump of detailed information about the node.
Definition: Protocol.h:1967
Payload for textDocument/ast request.
Definition: Protocol.h:1939
std::optional< Range > range
The position of the node to be dumped.
Definition: Protocol.h:1946
TextDocumentIdentifier textDocument
The text document.
Definition: Protocol.h:1941
std::optional< std::string > failureReason
Definition: Protocol.h:1196
Represents an incoming call, e.g. a caller of a method or constructor.
Definition: Protocol.h:1609
CallHierarchyItem from
The item that makes the call.
Definition: Protocol.h:1611
std::vector< Range > fromRanges
The range at which the calls appear.
Definition: Protocol.h:1615
The parameter of a callHierarchy/incomingCalls request.
Definition: Protocol.h:1602
Represents programming constructs like functions or constructors in the context of call hierarchy.
Definition: Protocol.h:1569
std::string name
The name of this item.
Definition: Protocol.h:1571
URIForFile uri
The resource identifier of this item.
Definition: Protocol.h:1583
Range range
The range enclosing this symbol not including leading / trailing whitespace but everything else,...
Definition: Protocol.h:1587
SymbolKind kind
The kind of this item.
Definition: Protocol.h:1574
std::vector< SymbolTag > tags
Tags for this item.
Definition: Protocol.h:1577
std::string data
An optional 'data' field, which can be used to identify a call hierarchy item in an incomingCalls or ...
Definition: Protocol.h:1596
std::string detail
More detaill for this item, e.g. the signature of a function.
Definition: Protocol.h:1580
Range selectionRange
The range that should be selected and revealed when this symbol is being picked, e....
Definition: Protocol.h:1592
Represents an outgoing call, e.g.
Definition: Protocol.h:1628
std::vector< Range > fromRanges
The range at which this item is called.
Definition: Protocol.h:1634
CallHierarchyItem to
The item that is called.
Definition: Protocol.h:1630
The parameter of a callHierarchy/outgoingCalls request.
Definition: Protocol.h:1620
The parameter of a textDocument/prepareCallHierarchy request.
Definition: Protocol.h:1565
std::string description
A human-readable string which is rendered less prominent in the user interface.
Definition: Protocol.h:275
std::string label
A human-readable string describing the actual change.
Definition: Protocol.h:267
std::optional< bool > needsConfirmation
A flag which indicates that user confirmation is needed before applying the change.
Definition: Protocol.h:271
Clangd extension that's used in the 'compilationDatabaseChanges' in workspace/didChangeConfiguration ...
Definition: Protocol.h:574
std::vector< std::string > compilationCommand
Definition: Protocol.h:576
bool HierarchicalDocumentSymbol
Client supports hierarchical document symbols.
Definition: Protocol.h:482
bool WorkDoneProgress
The client supports progress notifications.
Definition: Protocol.h:542
bool DiagnosticCategory
Whether the client accepts diagnostics with category attached to it using the "category" extension.
Definition: Protocol.h:465
bool CompletionLabelDetail
The client has support for completion item label details.
Definition: Protocol.h:513
MarkupKind HoverContentFormat
The content format that should be used for Hover requests.
Definition: Protocol.h:534
bool CodeActionStructure
Client supports CodeAction return value for textDocument/codeAction.
Definition: Protocol.h:517
bool OffsetsInSignatureHelp
Client supports processing label offsets instead of a simple label string.
Definition: Protocol.h:496
bool DiagnosticFixes
Whether the client accepts diagnostics with codeActions attached inline.
Definition: Protocol.h:456
bool HasSignatureHelp
Client supports signature help.
Definition: Protocol.h:486
bool TheiaSemanticHighlighting
Client supports Theia semantic highlighting extension.
Definition: Protocol.h:527
bool SemanticTokenRefreshSupport
Whether the client implementation supports a refresh request sent from the server to the client.
Definition: Protocol.h:556
bool DocumentChanges
The client supports versioned document changes for WorkspaceEdit.
Definition: Protocol.h:559
bool ImplicitProgressCreation
The client supports implicit $/progress work-done progress streams, without a preceding window/workDo...
Definition: Protocol.h:548
MarkupKind SignatureHelpDocumentationFormat
The documentation format that should be used for textDocument/signatureHelp.
Definition: Protocol.h:501
bool CompletionFixes
Client supports completions with additionalTextEdit near the cursor.
Definition: Protocol.h:474
bool RenamePrepareSupport
The client supports testing for validity of rename operations before execution.
Definition: Protocol.h:538
bool CancelsStaleRequests
Whether the client claims to cancel stale requests.
Definition: Protocol.h:552
std::optional< CompletionItemKindBitset > CompletionItemKinds
The supported set of CompletionItemKinds for textDocument/completion.
Definition: Protocol.h:505
bool CompletionSnippets
Client supports snippets as insert text.
Definition: Protocol.h:469
MarkupKind CompletionDocumentationFormat
The documentation format that should be used for textDocument/completion.
Definition: Protocol.h:509
bool LineFoldingOnly
Client signals that it only supports folding complete lines.
Definition: Protocol.h:492
bool InactiveRegions
Whether the client supports the textDocument/inactiveRegions notification.
Definition: Protocol.h:566
std::optional< SymbolKindBitset > WorkspaceSymbolKinds
The supported set of SymbolKinds for workspace/symbol.
Definition: Protocol.h:452
std::optional< std::vector< OffsetEncoding > > offsetEncoding
Supported encodings for LSP character offsets. (clangd extension).
Definition: Protocol.h:530
bool ReferenceContainer
Client supports displaying a container string for results of textDocument/reference (clangd extension...
Definition: Protocol.h:478
std::vector< Diagnostic > diagnostics
An array of diagnostics known on the client side overlapping the range provided to the textDocument/c...
Definition: Protocol.h:985
std::vector< std::string > only
Requested kind of actions to return.
Definition: Protocol.h:991
CodeActionContext context
Context carrying additional information.
Definition: Protocol.h:1003
TextDocumentIdentifier textDocument
The document in which the command was invoked.
Definition: Protocol.h:997
Range range
The range for which the command was invoked.
Definition: Protocol.h:1000
A code action represents a change that can be performed in code, e.g.
Definition: Protocol.h:1063
static const llvm::StringLiteral INFO_KIND
Definition: Protocol.h:1072
bool isPreferred
Marks this as a preferred action.
Definition: Protocol.h:1082
static const llvm::StringLiteral REFACTOR_KIND
Definition: Protocol.h:1071
std::optional< std::vector< Diagnostic > > diagnostics
The diagnostics that this code action resolves.
Definition: Protocol.h:1075
static const llvm::StringLiteral QUICKFIX_KIND
Definition: Protocol.h:1070
std::optional< WorkspaceEdit > edit
The workspace edit this code action performs.
Definition: Protocol.h:1085
std::optional< Command > command
A command this code action executes.
Definition: Protocol.h:1089
std::optional< std::string > kind
The kind of the code action.
Definition: Protocol.h:1069
std::string title
A short, human-readable, title for this code action.
Definition: Protocol.h:1065
Structure to capture a description for an error code.
Definition: Protocol.h:910
std::string href
An URI to open with more information about the diagnostic error.
Definition: Protocol.h:912
CompletionTriggerKind triggerKind
How the completion was triggered.
Definition: Protocol.h:1224
std::string triggerCharacter
The trigger character (a single character) that has trigger code complete.
Definition: Protocol.h:1227
Additional details for a completion item label.
Definition: Protocol.h:1275
std::string detail
An optional string which is rendered less prominently directly after label without any spacing.
Definition: Protocol.h:1279
std::string description
An optional string which is rendered less prominently after CompletionItemLabelDetails....
Definition: Protocol.h:1284
std::string sortText
A string that should be used when comparing this item with other items.
Definition: Protocol.h:1309
std::optional< TextEdit > textEdit
An edit which is applied to a document when selecting this completion.
Definition: Protocol.h:1328
std::string filterText
A string that should be used when filtering a set of completion items.
Definition: Protocol.h:1313
std::string detail
A human-readable string with additional information about this item, like type or symbol information.
Definition: Protocol.h:1302
InsertTextFormat insertTextFormat
The format of the insert text.
Definition: Protocol.h:1321
CompletionItemKind kind
The kind of this completion item.
Definition: Protocol.h:1298
std::vector< TextEdit > additionalTextEdits
An optional array of additional text edits that are applied when selecting this completion.
Definition: Protocol.h:1333
std::optional< MarkupContent > documentation
A human-readable string that represents a doc-comment.
Definition: Protocol.h:1305
std::string insertText
A string that should be inserted to a document when selecting this completion.
Definition: Protocol.h:1317
bool deprecated
Indicates if this item is deprecated.
Definition: Protocol.h:1336
std::optional< CompletionItemLabelDetails > labelDetails
Additional details for the label.
Definition: Protocol.h:1294
float score
The score that clangd calculates to rank the returned completions.
Definition: Protocol.h:1343
std::string label
The label of this completion item.
Definition: Protocol.h:1291
Represents a collection of completion items to be presented in the editor.
Definition: Protocol.h:1363
std::vector< CompletionItem > items
The completion items.
Definition: Protocol.h:1369
bool isIncomplete
The list is not complete.
Definition: Protocol.h:1366
std::optional< int > limit
Max results to return, overriding global default.
Definition: Protocol.h:1236
CompletionContext context
Definition: Protocol.h:1232
Clangd extension: parameters configurable at any time, via the workspace/didChangeConfiguration notif...
Definition: Protocol.h:584
std::map< std::string, ClangdCompileCommand > compilationDatabaseChanges
Definition: Protocol.h:587
Represents a related message and source code location for a diagnostic.
Definition: Protocol.h:888
std::string message
The message of this related diagnostic information.
Definition: Protocol.h:892
Location location
The location of this related diagnostic information.
Definition: Protocol.h:890
std::optional< CodeDescription > codeDescription
An optional property to describe the error code.
Definition: Protocol.h:929
llvm::json::Object data
A data entry field that is preserved between a textDocument/publishDiagnostics notification and textD...
Definition: Protocol.h:961
std::optional< std::vector< DiagnosticRelatedInformation > > relatedInformation
An array of related diagnostic information, e.g.
Definition: Protocol.h:943
std::string code
The diagnostic's code. Can be omitted.
Definition: Protocol.h:926
std::optional< std::vector< CodeAction > > codeActions
Clangd extension: code actions related to this diagnostic.
Definition: Protocol.h:954
Range range
The range at which the message applies.
Definition: Protocol.h:919
std::string source
A human-readable string describing the source of this diagnostic, e.g.
Definition: Protocol.h:933
std::string message
The diagnostic's message.
Definition: Protocol.h:936
int severity
The diagnostic's severity.
Definition: Protocol.h:923
std::optional< std::string > category
The diagnostic's category.
Definition: Protocol.h:949
llvm::SmallVector< DiagnosticTag, 1 > tags
Additional metadata about the diagnostic.
Definition: Protocol.h:939
bool forceRebuild
Force a complete rebuild of the file, ignoring all cached state.
Definition: Protocol.h:803
VersionedTextDocumentIdentifier textDocument
The document that did change.
Definition: Protocol.h:788
std::optional< bool > wantDiagnostics
Forces diagnostics to be generated, or to not be generated, for this version of the file.
Definition: Protocol.h:797
std::vector< TextDocumentContentChangeEvent > contentChanges
The actual content changes.
Definition: Protocol.h:791
std::vector< FileEvent > changes
The actual file events.
Definition: Protocol.h:829
TextDocumentIdentifier textDocument
The document that was closed.
Definition: Protocol.h:759
TextDocumentItem textDocument
The document that was opened.
Definition: Protocol.h:752
TextDocumentIdentifier textDocument
The document that was saved.
Definition: Protocol.h:766
TextDocumentIdentifier textDocument
The document to format.
Definition: Protocol.h:873
A document highlight is a range inside a text document which deserves special attention.
Definition: Protocol.h:1454
Range range
The range this highlight applies to.
Definition: Protocol.h:1456
friend bool operator<(const DocumentHighlight &LHS, const DocumentHighlight &RHS)
Definition: Protocol.h:1461
DocumentHighlightKind kind
The highlight kind, default is DocumentHighlightKind.Text.
Definition: Protocol.h:1459
friend bool operator==(const DocumentHighlight &LHS, const DocumentHighlight &RHS)
Definition: Protocol.h:1468
Parameters for the document link request.
Definition: Protocol.h:1861
TextDocumentIdentifier textDocument
The document to provide document links for.
Definition: Protocol.h:1863
Position position
The position at which this request was sent.
Definition: Protocol.h:863
std::string ch
The character that has been typed.
Definition: Protocol.h:866
TextDocumentIdentifier textDocument
The document to format.
Definition: Protocol.h:860
TextDocumentIdentifier textDocument
The document to format.
Definition: Protocol.h:850
TextDocumentIdentifier textDocument
Definition: Protocol.h:880
Represents programming constructs like variables, classes, interfaces etc.
Definition: Protocol.h:1097
Range selectionRange
The range that should be selected and revealed when this symbol is being picked, e....
Definition: Protocol.h:1118
std::vector< DocumentSymbol > children
Children of this symbol, e.g. properties of a class.
Definition: Protocol.h:1121
std::string detail
More detail for this symbol, e.g the signature of a function.
Definition: Protocol.h:1102
std::string name
The name of this symbol.
Definition: Protocol.h:1099
Range range
The range enclosing this symbol not including leading/trailing whitespace but everything else like co...
Definition: Protocol.h:1114
bool deprecated
Indicates if this symbol is deprecated.
Definition: Protocol.h:1108
SymbolKind kind
The kind of this symbol.
Definition: Protocol.h:1105
std::string command
The identifier of the actual command handler.
Definition: Protocol.h:1044
FileChangeType type
The change type.
Definition: Protocol.h:823
URIForFile uri
The file's URI.
Definition: Protocol.h:821
Clangd extension: indicates the current state of the file in clangd, sent from server via the textDoc...
Definition: Protocol.h:1745
URIForFile uri
The text document's URI.
Definition: Protocol.h:1747
std::string state
The human-readable string presents the current state of the file, can be shown in the UI (e....
Definition: Protocol.h:1750
TextDocumentIdentifier textDocument
Definition: Protocol.h:1897
Stores information about a region of code that can be folded.
Definition: Protocol.h:1903
static const llvm::StringLiteral REGION_KIND
Definition: Protocol.h:1909
static const llvm::StringLiteral COMMENT_KIND
Definition: Protocol.h:1910
static const llvm::StringLiteral IMPORT_KIND
Definition: Protocol.h:1911
std::optional< Range > range
An optional range is a range inside a text document that is used to visualize a hover,...
Definition: Protocol.h:1252
MarkupContent contents
The hover's content.
Definition: Protocol.h:1248
Parameters for the inactive regions (server-side) push notification.
Definition: Protocol.h:1829
TextDocumentIdentifier TextDocument
The textdocument these inactive regions belong to.
Definition: Protocol.h:1831
std::vector< Range > InactiveRegions
The inactive regions that should be sent.
Definition: Protocol.h:1833
Clangd extension: parameters configurable at initialize time.
Definition: Protocol.h:594
std::optional< std::string > compilationDatabasePath
Definition: Protocol.h:599
std::vector< std::string > fallbackFlags
Definition: Protocol.h:603
ConfigurationSettings ConfigSettings
Definition: Protocol.h:597
llvm::json::Object rawCapabilities
The same data as capabilities, but not parsed (to expose to modules).
Definition: Protocol.h:635
InitializationOptions initializationOptions
User-provided initialization options.
Definition: Protocol.h:641
ClientCapabilities capabilities
The capabilities provided by the client (editor or tool)
Definition: Protocol.h:633
std::optional< TraceLevel > trace
The initial trace setting. If omitted trace is disabled ('off').
Definition: Protocol.h:638
std::optional< int > processId
The process Id of the parent process that started the server.
Definition: Protocol.h:616
std::optional< std::string > rootPath
The rootPath of the workspace.
Definition: Protocol.h:622
std::optional< URIForFile > rootUri
The rootUri of the workspace.
Definition: Protocol.h:627
Inlay hint information.
Definition: Protocol.h:1693
InlayHintKind kind
The kind of this hint.
Definition: Protocol.h:1705
bool paddingRight
Render padding after the hint.
Definition: Protocol.h:1719
std::string label
The label of this hint.
Definition: Protocol.h:1701
bool paddingLeft
Render padding before the hint.
Definition: Protocol.h:1712
Position position
The position of this hint.
Definition: Protocol.h:1695
Range range
The range of source code to which the hint applies.
Definition: Protocol.h:1726
A parameter literal used in inlay hint requests.
Definition: Protocol.h:1639
std::optional< Range > range
The visible document range for which inlay hints should be computed.
Definition: Protocol.h:1647
TextDocumentIdentifier textDocument
The text document.
Definition: Protocol.h:1641
URIForFile uri
The text document's URI.
Definition: Protocol.h:213
friend bool operator==(const Location &LHS, const Location &RHS)
Definition: Protocol.h:216
friend bool operator<(const Location &LHS, const Location &RHS)
Definition: Protocol.h:224
friend bool operator!=(const Location &LHS, const Location &RHS)
Definition: Protocol.h:220
A tree that can be used to represent memory usage of nested components while preserving the hierarchy...
Definition: MemoryTree.h:30
A single parameter of a particular signature.
Definition: Protocol.h:1374
std::string labelString
The label of this parameter. Ignored when labelOffsets is set.
Definition: Protocol.h:1377
std::string documentation
The documentation of this parameter. Optional.
Definition: Protocol.h:1386
std::optional< std::pair< unsigned, unsigned > > labelOffsets
Inclusive start and exclusive end offsets withing the containing signature label.
Definition: Protocol.h:1383
friend bool operator==(const Position &LHS, const Position &RHS)
Definition: Protocol.h:165
friend bool operator!=(const Position &LHS, const Position &RHS)
Definition: Protocol.h:169
friend bool operator<=(const Position &LHS, const Position &RHS)
Definition: Protocol.h:176
int line
Line position in a document (zero-based).
Definition: Protocol.h:158
int character
Character offset on a line in a document (zero-based).
Definition: Protocol.h:163
friend bool operator<(const Position &LHS, const Position &RHS)
Definition: Protocol.h:172
std::string placeholder
Placeholder text to use in the editor if non-empty.
Definition: Protocol.h:1444
Range range
Range of the string to rename.
Definition: Protocol.h:1442
T value
The progress data.
Definition: Protocol.h:656
llvm::json::Value token
The progress token provided by the client or server.
Definition: Protocol.h:653
std::vector< Diagnostic > diagnostics
An array of diagnostic information items.
Definition: Protocol.h:972
std::optional< int64_t > version
The version number of the document the diagnostics are published for.
Definition: Protocol.h:974
URIForFile uri
The URI for which diagnostic information is reported.
Definition: Protocol.h:970
Position start
The range's start position.
Definition: Protocol.h:187
Position end
The range's end position.
Definition: Protocol.h:190
friend bool operator==(const Range &LHS, const Range &RHS)
Definition: Protocol.h:192
friend bool operator<(const Range &LHS, const Range &RHS)
Definition: Protocol.h:198
bool contains(Position Pos) const
Definition: Protocol.h:202
bool contains(Range Rng) const
Definition: Protocol.h:203
friend bool operator!=(const Range &LHS, const Range &RHS)
Definition: Protocol.h:195
bool includeDeclaration
Include the declaration of the current symbol.
Definition: Protocol.h:1735
Extends Locations returned by textDocument/references with extra info.
Definition: Protocol.h:233
std::optional< std::string > containerName
clangd extension: contains the name of the function or class in which the reference occurs
Definition: Protocol.h:236
ReferenceContext context
Definition: Protocol.h:1739
TextDocumentIdentifier textDocument
The document that was opened.
Definition: Protocol.h:1429
Position position
The position at which this request was sent.
Definition: Protocol.h:1432
std::string newName
The new name of the symbol.
Definition: Protocol.h:1435
Parameters for the typeHierarchy/resolve request.
Definition: Protocol.h:1548
TypeHierarchyItem item
The item to resolve.
Definition: Protocol.h:1550
int resolve
The hierarchy levels to resolve. 0 indicates no level.
Definition: Protocol.h:1553
TypeHierarchyDirection direction
The direction of the hierarchy levels to resolve.
Definition: Protocol.h:1556
TextDocumentIdentifier textDocument
The text document.
Definition: Protocol.h:1839
std::vector< Position > positions
The positions inside the text document.
Definition: Protocol.h:1842
std::unique_ptr< SelectionRange > parent
The parent selection range containing this range.
Definition: Protocol.h:1856
Range range
The range of this selection range.
Definition: Protocol.h:1851
Specifies a single semantic token in the document.
Definition: Protocol.h:1758
unsigned length
the length of the token. A token cannot be multiline
Definition: Protocol.h:1765
unsigned deltaStart
token start character, relative to the previous token (relative to 0 or the previous token's start if...
Definition: Protocol.h:1763
unsigned deltaLine
token line number, relative to the previous token
Definition: Protocol.h:1760
unsigned tokenType
will be looked up in SemanticTokensLegend.tokenTypes
Definition: Protocol.h:1767
unsigned tokenModifiers
each set bit will be looked up in SemanticTokensLegend.tokenModifiers
Definition: Protocol.h:1769
Body of textDocument/semanticTokens/full/delta request.
Definition: Protocol.h:1796
TextDocumentIdentifier textDocument
The text document.
Definition: Protocol.h:1798
std::string previousResultId
The previous result id.
Definition: Protocol.h:1800
Describes a replacement of a contiguous range of semanticTokens.
Definition: Protocol.h:1806
std::vector< SemanticToken > tokens
Definition: Protocol.h:1812
This models LSP SemanticTokensDelta | SemanticTokens, which is the result of textDocument/semanticTok...
Definition: Protocol.h:1818
std::optional< std::vector< SemanticToken > > tokens
Set if we computed a fresh set of tokens.
Definition: Protocol.h:1823
std::optional< std::vector< SemanticTokensEdit > > edits
Set if we computed edits relative to a previous set of tokens.
Definition: Protocol.h:1821
Body of textDocument/semanticTokens/full request.
Definition: Protocol.h:1787
TextDocumentIdentifier textDocument
The text document.
Definition: Protocol.h:1789
A versioned set of tokens.
Definition: Protocol.h:1774
std::vector< SemanticToken > tokens
The actual tokens.
Definition: Protocol.h:1782
The show message notification is sent from a server to a client to ask the client to display a partic...
Definition: Protocol.h:742
MessageType type
The message type.
Definition: Protocol.h:744
std::string message
The actual message.
Definition: Protocol.h:746
Represents the signature of a callable.
Definition: Protocol.h:1407
int activeSignature
The active signature.
Definition: Protocol.h:1413
std::vector< SignatureInformation > signatures
The resulting signatures.
Definition: Protocol.h:1410
Position argListStart
Position of the start of the argument list, including opening paren.
Definition: Protocol.h:1423
int activeParameter
The active parameter of the active signature.
Definition: Protocol.h:1416
Represents the signature of something callable.
Definition: Protocol.h:1391
MarkupContent documentation
The documentation of this signature. Optional.
Definition: Protocol.h:1397
std::vector< ParameterInformation > parameters
The parameters of this signature.
Definition: Protocol.h:1400
std::string label
The label of this signature. Mandatory.
Definition: Protocol.h:1394
Represents information about identifier.
Definition: Protocol.h:1154
std::optional< Location > definitionRange
Definition: Protocol.h:1170
std::optional< Location > declarationRange
Definition: Protocol.h:1168
std::string USR
Unified Symbol Resolution identifier This is an opaque string uniquely identifying a symbol.
Definition: Protocol.h:1164
Represents information about programming constructs like variables, classes, interfaces etc.
Definition: Protocol.h:1128
std::string containerName
The name of the symbol containing this symbol.
Definition: Protocol.h:1139
Location location
The location of this symbol.
Definition: Protocol.h:1136
SymbolKind kind
The kind of this symbol.
Definition: Protocol.h:1133
std::optional< float > score
The score that clangd calculates to rank the returned symbols.
Definition: Protocol.h:1147
std::string name
The name of this symbol.
Definition: Protocol.h:1130
std::optional< Range > range
The range of the document that changed.
Definition: Protocol.h:773
std::string text
The new text of the range/document.
Definition: Protocol.h:779
std::optional< int > rangeLength
The length of the range that got replaced.
Definition: Protocol.h:776
VersionedTextDocumentIdentifier textDocument
The text document to change.
Definition: Protocol.h:282
std::vector< TextEdit > edits
The edits to be applied.
Definition: Protocol.h:286
URIForFile uri
The text document's URI.
Definition: Protocol.h:133
std::string languageId
The text document's language identifier.
Definition: Protocol.h:296
std::optional< int64_t > version
The version number of this document (it will strictly increase after each change, including undo/redo...
Definition: Protocol.h:302
URIForFile uri
The text document's URI.
Definition: Protocol.h:293
std::string text
The content of the opened text document.
Definition: Protocol.h:305
TextDocumentIdentifier textDocument
The text document.
Definition: Protocol.h:1203
Position position
The position inside the text document.
Definition: Protocol.h:1206
std::string newText
The string to be inserted.
Definition: Protocol.h:250
ChangeAnnotationIdentifier annotationId
The actual annotation identifier (optional) If empty, then this field is nullopt.
Definition: Protocol.h:254
Range range
The range of the text document to be manipulated.
Definition: Protocol.h:246
Arguments for the 'applyTweak' command.
Definition: Protocol.h:1031
Range selection
A selection provided by the client on a textDocument/codeAction request.
Definition: Protocol.h:1035
URIForFile file
A file provided by the client on a textDocument/codeAction request.
Definition: Protocol.h:1033
std::string tweakID
ID of the tweak that should be executed. Corresponds to Tweak::id().
Definition: Protocol.h:1037
Used to resolve a client provided item back.
Definition: Protocol.h:1517
std::optional< std::vector< ResolveParams > > parents
std::nullopt means parents aren't resolved and empty is no parents.
Definition: Protocol.h:1520
Range range
The range enclosing this symbol not including leading/trailing whitespace but everything else,...
Definition: Protocol.h:1510
URIForFile uri
The resource identifier of this item.
Definition: Protocol.h:1506
Range selectionRange
The range that should be selected and revealed when this symbol is being picked, e....
Definition: Protocol.h:1514
SymbolKind kind
The kind of this item.
Definition: Protocol.h:1500
std::optional< std::vector< TypeHierarchyItem > > children
If this type hierarchy item is resolved, it contains the direct children of the current item.
Definition: Protocol.h:1539
std::optional< std::vector< TypeHierarchyItem > > parents
This is a clangd exntesion.
Definition: Protocol.h:1533
bool deprecated
true if the hierarchy item is deprecated.
Definition: Protocol.h:1530
std::optional< std::string > detail
More detail for this item, e.g. the signature of a function.
Definition: Protocol.h:1503
ResolveParams data
A data entry field that is preserved between a type hierarchy prepare and supertypes or subtypes requ...
Definition: Protocol.h:1526
std::string name
The name of this item.
Definition: Protocol.h:1497
The type hierarchy params is an extension of the TextDocumentPositionsParams with optional properties...
Definition: Protocol.h:1483
int resolve
The hierarchy levels to resolve.
Definition: Protocol.h:1486
TypeHierarchyDirection direction
The direction of the hierarchy levels to resolve.
Definition: Protocol.h:1490
std::string uri() const
Definition: Protocol.h:107
friend bool operator<(const URIForFile &LHS, const URIForFile &RHS)
Definition: Protocol.h:117
static llvm::Expected< URIForFile > fromURI(const URI &U, llvm::StringRef HintPath)
Definition: Protocol.cpp:59
friend bool operator!=(const URIForFile &LHS, const URIForFile &RHS)
Definition: Protocol.h:113
friend bool operator==(const URIForFile &LHS, const URIForFile &RHS)
Definition: Protocol.h:109
static URIForFile canonicalize(llvm::StringRef AbsPath, llvm::StringRef TUPath)
Canonicalizes AbsPath via URI.
Definition: Protocol.cpp:46
llvm::StringRef file() const
Retrieves absolute path to the file.
Definition: Protocol.h:104
std::optional< std::int64_t > version
The version number of this document.
Definition: Protocol.h:150
To start progress reporting a $/progress notification with the following payload must be sent.
Definition: Protocol.h:663
bool percentage
Optional progress percentage to display (value 100 is considered 100%).
Definition: Protocol.h:684
bool cancellable
Controls if a cancel button should show to allow the user to cancel the long-running operation.
Definition: Protocol.h:673
std::string title
Mandatory title of the progress operation.
Definition: Protocol.h:668
llvm::json::Value token
The token to be used to report progress.
Definition: Protocol.h:647
Signals the end of progress reporting.
Definition: Protocol.h:721
std::optional< std::string > message
Optional, a final message indicating to for example indicate the outcome of the operation.
Definition: Protocol.h:724
Reporting progress is done using the following payload.
Definition: Protocol.h:689
std::string title
Mandatory title of the progress operation.
Definition: Protocol.h:694
std::optional< unsigned > percentage
Optional progress percentage to display (value 100 is considered 100%).
Definition: Protocol.h:716
std::optional< bool > cancellable
Controls enablement state of a cancel button.
Definition: Protocol.h:701
std::optional< std::string > message
Optional, more detailed associated progress message.
Definition: Protocol.h:708
The edit should either provide changes or documentChanges.
Definition: Protocol.h:1010
std::optional< std::vector< TextDocumentEdit > > documentChanges
Versioned document edits.
Definition: Protocol.h:1018
std::map< std::string, ChangeAnnotation > changeAnnotations
A map of change annotations that can be referenced in AnnotatedTextEdit.
Definition: Protocol.h:1022
std::optional< std::map< std::string, std::vector< TextEdit > > > changes
Holds changes to existing resources.
Definition: Protocol.h:1012
The parameters of a Workspace Symbol Request.
Definition: Protocol.h:1177
std::string query
A query string to filter symbols by.
Definition: Protocol.h:1180
std::optional< int > limit
Max results to return, overriding global default.
Definition: Protocol.h:1184
static bool isEqual(const Range &LHS, const Range &RHS)
Definition: Protocol.h:1998
static unsigned getHashValue(const Range &Val)
Definition: Protocol.h:1994
static void format(const clang::clangd::Position &Pos, raw_ostream &OS, StringRef Style)
Definition: Protocol.h:2004