CbC/CbC_llvm: clang-tools-extra/clangd/Protocol.h comparison

comparison clang-tools-extra/clangd/Protocol.h @ 221:79ff65ed7e25

LLVM12 Original

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 15 Jun 2021 19:15:29 +0900
parents	0572611fdcc8
children	c4bab56944e8

comparison

equal deleted inserted replaced

-:42394fc6a535
+:79ff65ed7e25
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
 #include "URI.h"
 #include "index/SymbolID.h"
+#include "support/MemoryTree.h"
 #include "clang/Index/IndexSymbol.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 #include <bitset>
 std::string File;
 };
 /// Serialize/deserialize \p URIForFile to/from a string URI.
 llvm::json::Value toJSON(const URIForFile &U);
-bool fromJSON(const llvm::json::Value &, URIForFile &);
+bool fromJSON(const llvm::json::Value &, URIForFile &, llvm::json::Path);
 struct TextDocumentIdentifier {
 /// The text document's URI.
 URIForFile uri;
 };
 llvm::json::Value toJSON(const TextDocumentIdentifier &);
-bool fromJSON(const llvm::json::Value &, TextDocumentIdentifier &);
+bool fromJSON(const llvm::json::Value &, TextDocumentIdentifier &,
+llvm::json::Path);
 struct VersionedTextDocumentIdentifier : public TextDocumentIdentifier {
 /// The version number of this document. If a versioned text document
 /// identifier is sent from the server to the client and the file is not open
 /// in the editor (the server has not received an open notification before)
 ///
 /// clangd extension: versions are optional, and synthesized if missing.
 llvm::Optional<std::int64_t> version;
 };
 llvm::json::Value toJSON(const VersionedTextDocumentIdentifier &);
-bool fromJSON(const llvm::json::Value &, VersionedTextDocumentIdentifier &);
+bool fromJSON(const llvm::json::Value &, VersionedTextDocumentIdentifier &,
+llvm::json::Path);
 struct Position {
 /// Line position in a document (zero-based).
 int line = 0;
 friend bool operator<=(const Position &LHS, const Position &RHS) {
 return std::tie(LHS.line, LHS.character) <=
 std::tie(RHS.line, RHS.character);
 }
 };
-bool fromJSON(const llvm::json::Value &, Position &);
+bool fromJSON(const llvm::json::Value &, Position &, llvm::json::Path);
 llvm::json::Value toJSON(const Position &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Position &);
 struct Range {
 /// The range's start position.
 bool contains(Position Pos) const { return start <= Pos && Pos < end; }
 bool contains(Range Rng) const {
 return start <= Rng.start && Rng.end <= end;
 }
 };
-bool fromJSON(const llvm::json::Value &, Range &);
+bool fromJSON(const llvm::json::Value &, Range &, llvm::json::Path);
 llvm::json::Value toJSON(const Range &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Range &);
 struct Location {
 /// The text document's URI.
 std::string newText;
 };
 inline bool operator==(const TextEdit &L, const TextEdit &R) {
 return std::tie(L.newText, L.range) == std::tie(R.newText, R.range);
 }
-bool fromJSON(const llvm::json::Value &, TextEdit &);
+bool fromJSON(const llvm::json::Value &, TextEdit &, llvm::json::Path);
 llvm::json::Value toJSON(const TextEdit &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const TextEdit &);
 struct TextDocumentItem {
 /// The text document's URI.
 llvm::Optional<int64_t> version;
 /// The content of the opened text document.
 std::string text;
 };
-bool fromJSON(const llvm::json::Value &, TextDocumentItem &);
+bool fromJSON(const llvm::json::Value &, TextDocumentItem &, llvm::json::Path);
 enum class TraceLevel {
 Off = 0,
 Messages = 1,
 Verbose = 2,
 };
-bool fromJSON(const llvm::json::Value &E, TraceLevel &Out);
+bool fromJSON(const llvm::json::Value &E, TraceLevel &Out, llvm::json::Path);
 struct NoParams {};
-inline bool fromJSON(const llvm::json::Value &, NoParams &) { return true; }
+inline llvm::json::Value toJSON(const NoParams &) { return nullptr; }
+inline bool fromJSON(const llvm::json::Value &, NoParams &, llvm::json::Path) {
+return true;
+}
 using InitializedParams = NoParams;
-using ShutdownParams = NoParams;
-using ExitParams = NoParams;
 /// Defines how the host (editor) should sync document changes to the language
 /// server.
 enum class TextDocumentSyncKind {
 /// Documents should not be synced at all.
 Struct = 22,
 Event = 23,
 Operator = 24,
 TypeParameter = 25,
 };
-bool fromJSON(const llvm::json::Value &, CompletionItemKind &);
+bool fromJSON(const llvm::json::Value &, CompletionItemKind &,
+llvm::json::Path);
 constexpr auto CompletionItemKindMin =
 static_cast<size_t>(CompletionItemKind::Text);
 constexpr auto CompletionItemKindMax =
 static_cast<size_t>(CompletionItemKind::TypeParameter);
 using CompletionItemKindBitset = std::bitset<CompletionItemKindMax + 1>;
-bool fromJSON(const llvm::json::Value &, CompletionItemKindBitset &);
+bool fromJSON(const llvm::json::Value &, CompletionItemKindBitset &,
+llvm::json::Path);
 CompletionItemKind
 adjustKindToCapability(CompletionItemKind Kind,
 CompletionItemKindBitset &SupportedCompletionItemKinds);
 /// A symbol kind.
 Struct = 23,
 Event = 24,
 Operator = 25,
 TypeParameter = 26
 };
-bool fromJSON(const llvm::json::Value &, SymbolKind &);
+bool fromJSON(const llvm::json::Value &, SymbolKind &, llvm::json::Path);
 constexpr auto SymbolKindMin = static_cast<size_t>(SymbolKind::File);
 constexpr auto SymbolKindMax = static_cast<size_t>(SymbolKind::TypeParameter);
 using SymbolKindBitset = std::bitset<SymbolKindMax + 1>;
-bool fromJSON(const llvm::json::Value &, SymbolKindBitset &);
+bool fromJSON(const llvm::json::Value &, SymbolKindBitset &, llvm::json::Path);
 SymbolKind adjustKindToCapability(SymbolKind Kind,
 SymbolKindBitset &supportedSymbolKinds);
 // Convert a index::SymbolKind to clangd::SymbolKind (LSP)
 // Note, some are not perfect matches and should be improved when this LSP
 UTF8,
 // Length counts codepoints in unicode text. (Clangd extension).
 UTF32,
 };
 llvm::json::Value toJSON(const OffsetEncoding &);
-bool fromJSON(const llvm::json::Value &, OffsetEncoding &);
+bool fromJSON(const llvm::json::Value &, OffsetEncoding &, llvm::json::Path);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, OffsetEncoding);
 // Describes the content type that a client supports in various result literals
 // like `Hover`, `ParameterInfo` or `CompletionItem`.
 enum class MarkupKind {
 PlainText,
 Markdown,
 };
-bool fromJSON(const llvm::json::Value &, MarkupKind &);
+bool fromJSON(const llvm::json::Value &, MarkupKind &, llvm::json::Path);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, MarkupKind);
 // This struct doesn't mirror LSP!
 // The protocol defines deeply nested structures for client capabilities.
 // Instead of mapping them all, this just parses out the bits we care about.
 /// We support the textDocument/semanticTokens request in any case.
 /// textDocument.semanticTokens
 bool SemanticTokens = false;
 /// Client supports Theia semantic highlighting extension.
 /// https://github.com/microsoft/vscode-languageserver-node/pull/367
-/// This will be ignored if the client also supports semanticTokens.
+/// clangd no longer supports this, we detect it just to log a warning.
 /// textDocument.semanticHighlightingCapabilities.semanticHighlighting
-/// FIXME: drop this support once clients support LSP 3.16 Semantic Tokens.
 bool TheiaSemanticHighlighting = false;
 /// Supported encodings for LSP character offsets. (clangd extension).
 llvm::Optional<std::vector<OffsetEncoding>> offsetEncoding;
 /// The client supports implicit $/progress work-done progress streams,
 /// without a preceding window/workDoneProgress/create.
 /// This is a clangd extension.
 /// window.implicitWorkDoneProgressCreate
 bool ImplicitProgressCreation = false;
-};
-bool fromJSON(const llvm::json::Value &, ClientCapabilities &);
+/// Whether the client claims to cancel stale requests.
+/// general.staleRequestSupport.cancel
+bool CancelsStaleRequests = false;
+/// Whether the client implementation supports a refresh request sent from the
+/// server to the client.
+bool SemanticTokenRefreshSupport = false;
+};
+bool fromJSON(const llvm::json::Value &, ClientCapabilities &,
+llvm::json::Path);
 /// Clangd extension that's used in the 'compilationDatabaseChanges' in
 /// workspace/didChangeConfiguration to record updates to the in-memory
 /// compilation database.
 struct ClangdCompileCommand {
 std::string workingDirectory;
 std::vector<std::string> compilationCommand;
 };
-bool fromJSON(const llvm::json::Value &, ClangdCompileCommand &);
+bool fromJSON(const llvm::json::Value &, ClangdCompileCommand &,
+llvm::json::Path);
 /// Clangd extension: parameters configurable at any time, via the
 /// `workspace/didChangeConfiguration` notification.
 /// LSP defines this type as `any`.
 struct ConfigurationSettings {
 // Changes to the in-memory compilation database.
 // The key of the map is a file name.
 std::map<std::string, ClangdCompileCommand> compilationDatabaseChanges;
 };
-bool fromJSON(const llvm::json::Value &, ConfigurationSettings &);
+bool fromJSON(const llvm::json::Value &, ConfigurationSettings &,
+llvm::json::Path);
 /// Clangd extension: parameters configurable at `initialize` time.
 /// LSP defines this type as `any`.
 struct InitializationOptions {
 // What we can change throught the didChangeConfiguration request, we can
 std::vector<std::string> fallbackFlags;
 /// Clients supports show file status for textDocument/clangd.fileStatus.
 bool FileStatus = false;
 };
-bool fromJSON(const llvm::json::Value &, InitializationOptions &);
+bool fromJSON(const llvm::json::Value &, InitializationOptions &,
+llvm::json::Path);
 struct InitializeParams {
 /// The process Id of the parent process that started
 /// the server. Is null if the process has not been started by another
 /// process. If the parent process is not alive then the server should exit
 // User provided initialization options.
 // initializationOptions?: any;
 /// The capabilities provided by the client (editor or tool)
 ClientCapabilities capabilities;
+/// The same data as capabilities, but not parsed (to expose to modules).
+llvm::json::Object rawCapabilities;
 /// The initial trace setting. If omitted trace is disabled ('off').
 llvm::Optional<TraceLevel> trace;
 /// User-provided initialization options.
 InitializationOptions initializationOptions;
 };
-bool fromJSON(const llvm::json::Value &, InitializeParams &);
+bool fromJSON(const llvm::json::Value &, InitializeParams &, llvm::json::Path);
 struct WorkDoneProgressCreateParams {
 /// The token to be used to report progress.
 llvm::json::Value token = nullptr;
 };
 /// If not provided infinite progress is assumed and clients are allowed
 /// to ignore the `percentage` value in subsequent in report notifications.
 ///
 /// The value should be steadily rising. Clients are free to ignore values
 /// that are not following this rule.
-llvm::Optional<double> percentage;
+llvm::Optional<unsigned> percentage;
 };
 llvm::json::Value toJSON(const WorkDoneProgressReport &);
 //
 /// Signals the end of progress reporting.
 struct WorkDoneProgressEnd {
 struct DidOpenTextDocumentParams {
 /// The document that was opened.
 TextDocumentItem textDocument;
 };
-bool fromJSON(const llvm::json::Value &, DidOpenTextDocumentParams &);
+bool fromJSON(const llvm::json::Value &, DidOpenTextDocumentParams &,
+llvm::json::Path);
 struct DidCloseTextDocumentParams {
 /// The document that was closed.
 TextDocumentIdentifier textDocument;
 };
-bool fromJSON(const llvm::json::Value &, DidCloseTextDocumentParams &);
+bool fromJSON(const llvm::json::Value &, DidCloseTextDocumentParams &,
+llvm::json::Path);
 struct DidSaveTextDocumentParams {
 /// The document that was saved.
 TextDocumentIdentifier textDocument;
 };
-bool fromJSON(const llvm::json::Value &, DidSaveTextDocumentParams &);
+bool fromJSON(const llvm::json::Value &, DidSaveTextDocumentParams &,
+llvm::json::Path);
 struct TextDocumentContentChangeEvent {
 /// The range of the document that changed.
 llvm::Optional<Range> range;
 llvm::Optional<int> rangeLength;
 /// The new text of the range/document.
 std::string text;
 };
-bool fromJSON(const llvm::json::Value &, TextDocumentContentChangeEvent &);
+bool fromJSON(const llvm::json::Value &, TextDocumentContentChangeEvent &,
+llvm::json::Path);
 struct DidChangeTextDocumentParams {
 /// The document that did change. The version number points
 /// to the version after all provided content changes have
 /// been applied.
 /// This is useful to defeat clangd's assumption that missing headers will
 /// stay missing.
 /// This is a clangd extension.
 bool forceRebuild = false;
 };
-bool fromJSON(const llvm::json::Value &, DidChangeTextDocumentParams &);
+bool fromJSON(const llvm::json::Value &, DidChangeTextDocumentParams &,
+llvm::json::Path);
 enum class FileChangeType {
 /// The file got created.
 Created = 1,
 /// The file got changed.
 Changed = 2,
 /// The file got deleted.
 Deleted = 3
 };
-bool fromJSON(const llvm::json::Value &E, FileChangeType &Out);
+bool fromJSON(const llvm::json::Value &E, FileChangeType &Out,
+llvm::json::Path);
 struct FileEvent {
 /// The file's URI.
 URIForFile uri;
 /// The change type.
 FileChangeType type = FileChangeType::Created;
 };
-bool fromJSON(const llvm::json::Value &, FileEvent &);
+bool fromJSON(const llvm::json::Value &, FileEvent &, llvm::json::Path);
 struct DidChangeWatchedFilesParams {
 /// The actual file events.
 std::vector<FileEvent> changes;
 };
-bool fromJSON(const llvm::json::Value &, DidChangeWatchedFilesParams &);
+bool fromJSON(const llvm::json::Value &, DidChangeWatchedFilesParams &,
+llvm::json::Path);
 struct DidChangeConfigurationParams {
 ConfigurationSettings settings;
 };
-bool fromJSON(const llvm::json::Value &, DidChangeConfigurationParams &);
+bool fromJSON(const llvm::json::Value &, DidChangeConfigurationParams &,
+llvm::json::Path);
 // Note: we do not parse FormattingOptions for *FormattingParams.
 // In general, we use a clang-format style detected from common mechanisms
 // (.clang-format files and the -fallback-style flag).
 // It would be possible to override these with FormatOptions, but:
 TextDocumentIdentifier textDocument;
 /// The range to format
 Range range;
 };
-bool fromJSON(const llvm::json::Value &, DocumentRangeFormattingParams &);
+bool fromJSON(const llvm::json::Value &, DocumentRangeFormattingParams &,
+llvm::json::Path);
 struct DocumentOnTypeFormattingParams {
 /// The document to format.
 TextDocumentIdentifier textDocument;
 Position position;
 /// The character that has been typed.
 std::string ch;
 };
-bool fromJSON(const llvm::json::Value &, DocumentOnTypeFormattingParams &);
+bool fromJSON(const llvm::json::Value &, DocumentOnTypeFormattingParams &,
+llvm::json::Path);
 struct DocumentFormattingParams {
 /// The document to format.
 TextDocumentIdentifier textDocument;
 };
-bool fromJSON(const llvm::json::Value &, DocumentFormattingParams &);
+bool fromJSON(const llvm::json::Value &, DocumentFormattingParams &,
+llvm::json::Path);
 struct DocumentSymbolParams {
 // The text document to find symbols in.
 TextDocumentIdentifier textDocument;
 };
-bool fromJSON(const llvm::json::Value &, DocumentSymbolParams &);
+bool fromJSON(const llvm::json::Value &, DocumentSymbolParams &,
+llvm::json::Path);
 /// Represents a related message and source code location for a diagnostic.
 /// This should be used to point to code locations that cause or related to a
 /// diagnostics, e.g when duplicating a symbol in a scope.
 struct DiagnosticRelatedInformation {
 /// Clangd extension: code actions related to this diagnostic.
 /// Only with capability textDocument.publishDiagnostics.codeActionsInline.
 /// (These actions can also be obtained using textDocument/codeAction).
 llvm::Optional<std::vector<CodeAction>> codeActions;
+/// A data entry field that is preserved between a
+/// `textDocument/publishDiagnostics` notification
+/// and`textDocument/codeAction` request.
+/// Mutating users should associate their data with a unique key they can use
+/// to retrieve later on.
+llvm::json::Object data;
 };
 llvm::json::Value toJSON(const Diagnostic &);
 /// A LSP-specific comparator used to find diagnostic in a container like
 /// std:map.
 struct LSPDiagnosticCompare {
 bool operator()(const Diagnostic &LHS, const Diagnostic &RHS) const {
 return std::tie(LHS.range, LHS.message) < std::tie(RHS.range, RHS.message);
 }
 };
-bool fromJSON(const llvm::json::Value &, Diagnostic &);
+bool fromJSON(const llvm::json::Value &, Diagnostic &, llvm::json::Path);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Diagnostic &);
 struct PublishDiagnosticsParams {
 /// The URI for which diagnostic information is reported.
 URIForFile uri;
 llvm::Optional<int64_t> version;
 };
 llvm::json::Value toJSON(const PublishDiagnosticsParams &);
 struct CodeActionContext {
-/// An array of diagnostics.
+/// An array of diagnostics known on the client side overlapping the range
+/// provided to the `textDocument/codeAction` request. They are provided so
+/// that the server knows which errors are currently presented to the user for
+/// the given range. There is no guarantee that these accurately reflect the
+/// error state of the resource. The primary parameter to compute code actions
+/// is the provided range.
 std::vector<Diagnostic> diagnostics;
-};
-bool fromJSON(const llvm::json::Value &, CodeActionContext &);
+/// Requested kind of actions to return.
+///
+/// Actions not of this kind are filtered out by the client before being
+/// shown. So servers can omit computing them.
+std::vector<std::string> only;
+};
+bool fromJSON(const llvm::json::Value &, CodeActionContext &, llvm::json::Path);
 struct CodeActionParams {
 /// The document in which the command was invoked.
 TextDocumentIdentifier textDocument;
 Range range;
 /// Context carrying additional information.
 CodeActionContext context;
 };
-bool fromJSON(const llvm::json::Value &, CodeActionParams &);
+bool fromJSON(const llvm::json::Value &, CodeActionParams &, llvm::json::Path);
 struct WorkspaceEdit {
 /// Holds changes to existing resources.
-llvm::Optional<std::map<std::string, std::vector<TextEdit>>> changes;
+std::map<std::string, std::vector<TextEdit>> changes;
 /// Note: "documentChanges" is not currently used because currently there is
 /// no support for versioned edits.
 };
-bool fromJSON(const llvm::json::Value &, WorkspaceEdit &);
+bool fromJSON(const llvm::json::Value &, WorkspaceEdit &, llvm::json::Path);
 llvm::json::Value toJSON(const WorkspaceEdit &WE);
 /// Arguments for the 'applyTweak' command. The server sends these commands as a
 /// response to the textDocument/codeAction request. The client can later send a
 /// command back to the server if the user requests to execute a particular code
 /// A selection provided by the client on a textDocument/codeAction request.
 Range selection;
 /// ID of the tweak that should be executed. Corresponds to Tweak::id().
 std::string tweakID;
 };
-bool fromJSON(const llvm::json::Value &, TweakArgs &);
+bool fromJSON(const llvm::json::Value &, TweakArgs &, llvm::json::Path);
 llvm::json::Value toJSON(const TweakArgs &A);
-/// Exact commands are not specified in the protocol so we define the
-/// ones supported by Clangd here. The protocol specifies the command arguments
-/// to be "any[]" but to make this safer and more manageable, each command we
-/// handle maps to a certain llvm::Optional of some struct to contain its
-/// arguments. Different commands could reuse the same llvm::Optional as
-/// arguments but a command that needs different arguments would simply add a
-/// new llvm::Optional and not use any other ones. In practice this means only
-/// one argument type will be parsed and set.
 struct ExecuteCommandParams {
-// Command to apply fix-its. Uses WorkspaceEdit as argument.
+/// The identifier of the actual command handler.
-const static llvm::StringLiteral CLANGD_APPLY_FIX_COMMAND;
-// Command to apply the code action. Uses TweakArgs as argument.
-const static llvm::StringLiteral CLANGD_APPLY_TWEAK;
-/// The command identifier, e.g. CLANGD_APPLY_FIX_COMMAND
 std::string command;
-// Arguments
+// This is `arguments?: []any` in LSP.
-llvm::Optional<WorkspaceEdit> workspaceEdit;
+// All clangd's commands accept a single argument (or none => null).
-llvm::Optional<TweakArgs> tweakArgs;
+llvm::json::Value argument = nullptr;
 };
-bool fromJSON(const llvm::json::Value &, ExecuteCommandParams &);
+bool fromJSON(const llvm::json::Value &, ExecuteCommandParams &,
+llvm::json::Path);
 struct Command : public ExecuteCommandParams {
 std::string title;
 };
 llvm::json::Value toJSON(const Command &C);
 const static llvm::StringLiteral INFO_KIND;
 /// The diagnostics that this code action resolves.
 llvm::Optional<std::vector<Diagnostic>> diagnostics;
+/// Marks this as a preferred action. Preferred actions are used by the
+/// `auto fix` command and can be targeted by keybindings.
+/// A quick fix should be marked preferred if it properly addresses the
+/// underlying error. A refactoring should be marked preferred if it is the
+/// most reasonable choice of actions to take.
+bool isPreferred = false;
 /// The workspace edit this code action performs.
 llvm::Optional<WorkspaceEdit> edit;
 /// A command this code action executes. If a code action provides an edit
 /// and a command, first the edit is executed and then the command.
 /// The kind of this symbol.
 SymbolKind kind;
 /// Indicates if this symbol is deprecated.
-bool deprecated;
+bool deprecated = false;
 /// The range enclosing this symbol not including leading/trailing whitespace
 /// but everything else like comments. This information is typically used to
 /// determine if the clients cursor is inside the symbol to reveal in the
 /// symbol in the UI.
 /// The location of this symbol.
 Location location;
 /// The name of the symbol containing this symbol.
 std::string containerName;
+/// The score that clangd calculates to rank the returned symbols.
+/// This excludes the fuzzy-matching score between `name` and the query.
+/// (Specifically, the last ::-separated component).
+/// This can be used to re-rank results as the user types, using client-side
+/// fuzzy-matching (that score should be multiplied with this one).
+/// This is a clangd extension, set only for workspace/symbol responses.
+llvm::Optional<float> score;
 };
 llvm::json::Value toJSON(const SymbolInformation &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SymbolInformation &);
 /// Represents information about identifier.
 /// Unlike SymbolID, it is variable-length and somewhat human-readable.
 /// It is a common representation across several clang tools.
 /// (See USRGeneration.h)
 std::string USR;
-llvm::Optional<SymbolID> ID;
+SymbolID ID;
 };
 llvm::json::Value toJSON(const SymbolDetails &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SymbolDetails &);
 bool operator==(const SymbolDetails &, const SymbolDetails &);
 /// The parameters of a Workspace Symbol Request.
 struct WorkspaceSymbolParams {
-/// A non-empty query string
+/// A query string to filter symbols by.
+/// Clients may send an empty string here to request all the symbols.
 std::string query;
-};
-bool fromJSON(const llvm::json::Value &, WorkspaceSymbolParams &);
+/// Max results to return, overriding global default. 0 means no limit.
+/// Clangd extension.
+llvm::Optional<int> limit;
+};
+bool fromJSON(const llvm::json::Value &, WorkspaceSymbolParams &,
+llvm::json::Path);
 struct ApplyWorkspaceEditParams {
 WorkspaceEdit edit;
 };
 llvm::json::Value toJSON(const ApplyWorkspaceEditParams &);
 struct ApplyWorkspaceEditResponse {
 bool applied = true;
 llvm::Optional<std::string> failureReason;
 };
-bool fromJSON(const llvm::json::Value &, ApplyWorkspaceEditResponse &);
+bool fromJSON(const llvm::json::Value &, ApplyWorkspaceEditResponse &,
+llvm::json::Path);
 struct TextDocumentPositionParams {
 /// The text document.
 TextDocumentIdentifier textDocument;
 /// The position inside the text document.
 Position position;
 };
-bool fromJSON(const llvm::json::Value &, TextDocumentPositionParams &);
+bool fromJSON(const llvm::json::Value &, TextDocumentPositionParams &,
+llvm::json::Path);
 enum class CompletionTriggerKind {
 /// Completion was triggered by typing an identifier (24x7 code
 /// complete), manual invocation (e.g Ctrl+Space) or via API.
 Invoked = 1,
 CompletionTriggerKind triggerKind = CompletionTriggerKind::Invoked;
 /// The trigger character (a single character) that has trigger code complete.
 /// Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
 std::string triggerCharacter;
 };
-bool fromJSON(const llvm::json::Value &, CompletionContext &);
+bool fromJSON(const llvm::json::Value &, CompletionContext &, llvm::json::Path);
 struct CompletionParams : TextDocumentPositionParams {
 CompletionContext context;
-};
-bool fromJSON(const llvm::json::Value &, CompletionParams &);
+/// Max results to return, overriding global default. 0 means no limit.
+/// Clangd extension.
+llvm::Optional<int> limit;
+};
+bool fromJSON(const llvm::json::Value &, CompletionParams &, llvm::json::Path);
 struct MarkupContent {
 MarkupKind kind = MarkupKind::PlainText;
 std::string value;
 };
 std::vector<TextEdit> additionalTextEdits;
 /// Indicates if this item is deprecated.
 bool deprecated = false;
-/// This is Clangd extension.
+/// The score that clangd calculates to rank the returned completions.
-/// The score that Clangd calculates to rank completion items. This score can
+/// This excludes the fuzzy-match between `filterText` and the partial word.
-/// be used to adjust the ranking on the client side.
+/// This can be used to re-rank results as the user types, using client-side
-/// NOTE: This excludes fuzzy matching score which is typically calculated on
+/// fuzzy-matching (that score should be multiplied with this one).
-/// the client side.
+/// This is a clangd extension.
 float score = 0.f;
 // TODO: Add custom commitCharacters for some of the completion items. For
 // example, it makes sense to use () only for the functions.
 // TODO(krasimir): The following optional fields defined by the language
 Position position;
 /// The new name of the symbol.
 std::string newName;
 };
-bool fromJSON(const llvm::json::Value &, RenameParams &);
+bool fromJSON(const llvm::json::Value &, RenameParams &, llvm::json::Path);
 enum class DocumentHighlightKind { Text = 1, Read = 2, Write = 3 };
 /// A document highlight is a range inside a text document which deserves
 /// special attention. Usually a document highlight is visualized by changing
 };
 llvm::json::Value toJSON(const DocumentHighlight &DH);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DocumentHighlight &);
 enum class TypeHierarchyDirection { Children = 0, Parents = 1, Both = 2 };
-bool fromJSON(const llvm::json::Value &E, TypeHierarchyDirection &Out);
+bool fromJSON(const llvm::json::Value &E, TypeHierarchyDirection &Out,
+llvm::json::Path);
 /// The type hierarchy params is an extension of the
 /// `TextDocumentPositionsParams` with optional properties which can be used to
 /// eagerly resolve the item when requesting from the server.
 struct TypeHierarchyParams : public TextDocumentPositionParams {
 int resolve = 0;
 /// The direction of the hierarchy levels to resolve.
 TypeHierarchyDirection direction = TypeHierarchyDirection::Parents;
 };
-bool fromJSON(const llvm::json::Value &, TypeHierarchyParams &);
+bool fromJSON(const llvm::json::Value &, TypeHierarchyParams &,
+llvm::json::Path);
 struct TypeHierarchyItem {
 /// The human readable name of the hierarchy item.
 std::string name;
 /// If this type hierarchy item is resolved, it contains the direct children
 /// of the current item. Could be empty if the item does not have any
 /// descendants. If not defined, the children have not been resolved.
 llvm::Optional<std::vector<TypeHierarchyItem>> children;
-/// An optional 'data' filed, which can be used to identify a type hierarchy
+/// An optional 'data' field, which can be used to identify a type hierarchy
 /// item in a resolve request.
 llvm::Optional<std::string> data;
 };
 llvm::json::Value toJSON(const TypeHierarchyItem &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const TypeHierarchyItem &);
-bool fromJSON(const llvm::json::Value &, TypeHierarchyItem &);
+bool fromJSON(const llvm::json::Value &, TypeHierarchyItem &, llvm::json::Path);
 /// Parameters for the `typeHierarchy/resolve` request.
 struct ResolveTypeHierarchyItemParams {
 /// The item to resolve.
 TypeHierarchyItem item;
 int resolve;
 /// The direction of the hierarchy levels to resolve.
 TypeHierarchyDirection direction;
 };
-bool fromJSON(const llvm::json::Value &, ResolveTypeHierarchyItemParams &);
+bool fromJSON(const llvm::json::Value &, ResolveTypeHierarchyItemParams &,
+llvm::json::Path);
+enum class SymbolTag { Deprecated = 1 };
+llvm::json::Value toJSON(SymbolTag);
+/// The parameter of a `textDocument/prepareCallHierarchy` request.
+struct CallHierarchyPrepareParams : public TextDocumentPositionParams {};
+/// Represents programming constructs like functions or constructors
+/// in the context of call hierarchy.
+struct CallHierarchyItem {
+/// The name of this item.
+std::string name;
+/// The kind of this item.
+SymbolKind kind;
+/// Tags for this item.
+std::vector<SymbolTag> tags;
+/// More detaill for this item, e.g. the signature of a function.
+std::string detail;
+/// The resource identifier of this item.
+URIForFile uri;
+/// The range enclosing this symbol not including leading / trailing
+/// whitespace but everything else, e.g. comments and code.
+Range range;
+/// The range that should be selected and revealed when this symbol
+/// is being picked, e.g. the name of a function.
+/// Must be contained by `Rng`.
+Range selectionRange;
+/// An optional 'data' field, which can be used to identify a call
+/// hierarchy item in an incomingCalls or outgoingCalls request.
+std::string data;
+};
+llvm::json::Value toJSON(const CallHierarchyItem &);
+bool fromJSON(const llvm::json::Value &, CallHierarchyItem &, llvm::json::Path);
+/// The parameter of a `callHierarchy/incomingCalls` request.
+struct CallHierarchyIncomingCallsParams {
+CallHierarchyItem item;
+};
+bool fromJSON(const llvm::json::Value &, CallHierarchyIncomingCallsParams &,
+llvm::json::Path);
+/// Represents an incoming call, e.g. a caller of a method or constructor.
+struct CallHierarchyIncomingCall {
+/// The item that makes the call.
+CallHierarchyItem from;
+/// The range at which the calls appear.
+/// This is relative to the caller denoted by `From`.
+std::vector<Range> fromRanges;
+};
+llvm::json::Value toJSON(const CallHierarchyIncomingCall &);
+/// The parameter of a `callHierarchy/outgoingCalls` request.
+struct CallHierarchyOutgoingCallsParams {
+CallHierarchyItem item;
+};
+bool fromJSON(const llvm::json::Value &, CallHierarchyOutgoingCallsParams &,
+llvm::json::Path);
+/// Represents an outgoing call, e.g. calling a getter from a method or
+/// a method from a constructor etc.
+struct CallHierarchyOutgoingCall {
+/// The item that is called.
+CallHierarchyItem to;
+/// The range at which this item is called.
+/// This is the range relative to the caller, and not `To`.
+std::vector<Range> fromRanges;
+};
+llvm::json::Value toJSON(const CallHierarchyOutgoingCall &);
+/// The parameter of a `textDocument/inlayHints` request.
+struct InlayHintsParams {
+/// The text document for which inlay hints are requested.
+TextDocumentIdentifier textDocument;
+};
+bool fromJSON(const llvm::json::Value &, InlayHintsParams &, llvm::json::Path);
+/// A set of predefined hint kinds.
+enum class InlayHintKind {
+/// The hint corresponds to parameter information.
+/// An example of a parameter hint is a hint in this position:
+///    func(^arg);
+/// which shows the name of the corresponding parameter.
+ParameterHint,
+/// The hint corresponds to information about a deduced type.
+/// An example of a type hint is a hint in this position:
+///    auto var ^ = expr;
+/// which shows the deduced type of the variable.
+TypeHint,
+/// Other ideas for hints that are not currently implemented:
+///
+/// * Chaining hints, showing the types of intermediate expressions
+///   in a chain of function calls.
+/// * Hints indicating implicit conversions or implicit constructor calls.
+};
+llvm::json::Value toJSON(InlayHintKind);
+/// An annotation to be displayed inline next to a range of source code.
+struct InlayHint {
+/// The range of source code to which the hint applies.
+/// We provide the entire range, rather than just the endpoint
+/// relevant to `position` (e.g. the start of the range for
+/// InlayHintPosition::Before), to give clients the flexibility
+/// to make choices like only displaying the hint while the cursor
+/// is over the range, rather than displaying it all the time.
+Range range;
+/// The type of hint.
+InlayHintKind kind;
+/// The label that is displayed in the editor.
+std::string label;
+};
+llvm::json::Value toJSON(const InlayHint &);
+struct ReferenceContext {
+/// Include the declaration of the current symbol.
+bool includeDeclaration = false;
+};
 struct ReferenceParams : public TextDocumentPositionParams {
-// For now, no options like context.includeDeclaration are supported.
+ReferenceContext context;
 };
-bool fromJSON(const llvm::json::Value &, ReferenceParams &);
+bool fromJSON(const llvm::json::Value &, ReferenceParams &, llvm::json::Path);
 /// Clangd extension: indicates the current state of the file in clangd,
 /// sent from server via the `textDocument/clangd.fileStatus` notification.
 struct FileStatus {
 /// The text document's URI.
 // the client will include the result id in the next semantic token request.
 // A server can then instead of computing all semantic tokens again simply
 // send a delta.
 std::string resultId;
-/// The actual tokens. For a detailed description about how the data is
+/// The actual tokens.
-/// structured pls see
+std::vector<SemanticToken> tokens; // encoded as a flat integer array.
-/// https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L71
-std::vector<SemanticToken> tokens;
 };
 llvm::json::Value toJSON(const SemanticTokens &);
+/// Body of textDocument/semanticTokens/full request.
 struct SemanticTokensParams {
 /// The text document.
 TextDocumentIdentifier textDocument;
 };
-bool fromJSON(const llvm::json::Value &, SemanticTokensParams &);
+bool fromJSON(const llvm::json::Value &, SemanticTokensParams &,
+llvm::json::Path);
+/// Body of textDocument/semanticTokens/full/delta request.
 /// Requests the changes in semantic tokens since a previous response.
-struct SemanticTokensEditsParams {
+struct SemanticTokensDeltaParams {
 /// The text document.
 TextDocumentIdentifier textDocument;
 /// The previous result id.
 std::string previousResultId;
 };
-bool fromJSON(const llvm::json::Value &Params, SemanticTokensEditsParams &R);
+bool fromJSON(const llvm::json::Value &Params, SemanticTokensDeltaParams &R,
+llvm::json::Path);
 /// Describes a a replacement of a contiguous range of semanticTokens.
 struct SemanticTokensEdit {
 // LSP specifies `start` and `deleteCount` which are relative to the array
 // encoding of the previous tokens.
 // We use token counts instead, and translate when serializing this struct.
 unsigned startToken = 0;
 unsigned deleteTokens = 0;
-std::vector<SemanticToken> tokens;
+std::vector<SemanticToken> tokens; // encoded as a flat integer array
 };
 llvm::json::Value toJSON(const SemanticTokensEdit &);
-/// This models LSP SemanticTokensEdits | SemanticTokens, which is the result of
+/// This models LSP SemanticTokensDelta | SemanticTokens, which is the result of
-/// textDocument/semanticTokens/edits.
+/// textDocument/semanticTokens/full/delta.
-struct SemanticTokensOrEdits {
+struct SemanticTokensOrDelta {
 std::string resultId;
 /// Set if we computed edits relative to a previous set of tokens.
 llvm::Optional<std::vector<SemanticTokensEdit>> edits;
 /// Set if we computed a fresh set of tokens.
-llvm::Optional<std::vector<SemanticToken>> tokens;
+llvm::Optional<std::vector<SemanticToken>> tokens; // encoded as integer array
 };
-llvm::json::Value toJSON(const SemanticTokensOrEdits &);
+llvm::json::Value toJSON(const SemanticTokensOrDelta &);
-/// Represents a semantic highlighting information that has to be applied on a
-/// specific line of the text document.
-struct TheiaSemanticHighlightingInformation {
-/// The line these highlightings belong to.
-int Line = 0;
-/// The base64 encoded string of highlighting tokens.
-std::string Tokens;
-/// Is the line in an inactive preprocessor branch?
-/// This is a clangd extension.
-/// An inactive line can still contain highlighting tokens as well;
-/// clients should combine line style and token style if possible.
-bool IsInactive = false;
-};
-bool operator==(const TheiaSemanticHighlightingInformation &Lhs,
-const TheiaSemanticHighlightingInformation &Rhs);
-llvm::json::Value
-toJSON(const TheiaSemanticHighlightingInformation &Highlighting);
-/// Parameters for the semantic highlighting (server-side) push notification.
-struct TheiaSemanticHighlightingParams {
-/// The textdocument these highlightings belong to.
-VersionedTextDocumentIdentifier TextDocument;
-/// The lines of highlightings that should be sent.
-std::vector<TheiaSemanticHighlightingInformation> Lines;
-};
-llvm::json::Value toJSON(const TheiaSemanticHighlightingParams &Highlighting);
 struct SelectionRangeParams {
 /// The text document.
 TextDocumentIdentifier textDocument;
 /// The positions inside the text document.
 std::vector<Position> positions;
 };
-bool fromJSON(const llvm::json::Value &, SelectionRangeParams &);
+bool fromJSON(const llvm::json::Value &, SelectionRangeParams &,
+llvm::json::Path);
 struct SelectionRange {
 /**
 * The range of this selection range.
 */
 /// Parameters for the document link request.
 struct DocumentLinkParams {
 /// The document to provide document links for.
 TextDocumentIdentifier textDocument;
 };
-bool fromJSON(const llvm::json::Value &, DocumentLinkParams &);
+bool fromJSON(const llvm::json::Value &, DocumentLinkParams &,
+llvm::json::Path);
 /// A range in a text document that links to an internal or external resource,
 /// like another text document or a web site.
 struct DocumentLink {
 /// The range this link applies to.
 return !(LHS == RHS);
 }
 };
 llvm::json::Value toJSON(const DocumentLink &DocumentLink);
+// FIXME(kirillbobyrev): Add FoldingRangeClientCapabilities so we can support
+// per-line-folding editors.
+struct FoldingRangeParams {
+TextDocumentIdentifier textDocument;
+};
+bool fromJSON(const llvm::json::Value &, FoldingRangeParams &,
+llvm::json::Path);
+/// Stores information about a region of code that can be folded.
+struct FoldingRange {
+unsigned startLine = 0;
+unsigned startCharacter;
+unsigned endLine = 0;
+unsigned endCharacter;
+llvm::Optional<std::string> kind;
+};
+llvm::json::Value toJSON(const FoldingRange &Range);
+/// Keys starting with an underscore(_) represent leaves, e.g. _total or _self
+/// for memory usage of whole subtree or only that specific node in bytes. All
+/// other keys represents children. An example:
+///   {
+///     "_self": 0,
+///     "_total": 8,
+///     "child1": {
+///       "_self": 4,
+///       "_total": 4,
+///     }
+///     "child2": {
+///       "_self": 2,
+///       "_total": 4,
+///       "child_deep": {
+///         "_self": 2,
+///         "_total": 2,
+///       }
+///     }
+///   }
+llvm::json::Value toJSON(const MemoryTree &MT);
+/// Payload for textDocument/ast request.
+/// This request is a clangd extension.
+struct ASTParams {
+/// The text document.
+TextDocumentIdentifier textDocument;
+/// The position of the node to be dumped.
+/// The highest-level node that entirely contains the range will be returned.
+/// If no range is given, the root translation unit node will be returned.
+llvm::Optional<Range> range;
+};
+bool fromJSON(const llvm::json::Value &, ASTParams &, llvm::json::Path);
+/// Simplified description of a clang AST node.
+/// This is clangd's internal representation of C++ code.
+struct ASTNode {
+/// The general kind of node, such as "expression"
+/// Corresponds to the base AST node type such as Expr.
+std::string role;
+/// The specific kind of node this is, such as "BinaryOperator".
+/// This is usually a concrete node class (with Expr etc suffix dropped).
+/// When there's no hierarchy (e.g. TemplateName), the variant (NameKind).
+std::string kind;
+/// Brief additional information, such as "||" for the particular operator.
+/// The information included depends on the node kind, and may be empty.
+std::string detail;
+/// A one-line dump of detailed information about the node.
+/// This includes role/kind/description information, but is rather cryptic.
+/// It is similar to the output from `clang -Xclang -ast-dump`.
+/// May be empty for certain types of nodes.
+std::string arcana;
+/// The range of the original source file covered by this node.
+/// May be missing for implicit nodes, or those created by macro expansion.
+llvm::Optional<Range> range;
+/// Nodes nested within this one, such as the operands of a BinaryOperator.
+std::vector<ASTNode> children;
+};
+llvm::json::Value toJSON(const ASTNode &);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ASTNode &);
 } // namespace clangd
 } // namespace clang
 namespace llvm {
 template <> struct format_provider<clang::clangd::Position> {

Mercurial > hg > CbC > CbC_llvm

comparison clang-tools-extra/clangd/Protocol.h @ 221:79ff65ed7e25