summaryrefslogtreecommitdiff
path: root/graphics/asymptote/LspCpp/include/LibLsp/lsp/general/lsTextDocumentClientCapabilities.h
diff options
context:
space:
mode:
Diffstat (limited to 'graphics/asymptote/LspCpp/include/LibLsp/lsp/general/lsTextDocumentClientCapabilities.h')
-rw-r--r--graphics/asymptote/LspCpp/include/LibLsp/lsp/general/lsTextDocumentClientCapabilities.h713
1 files changed, 713 insertions, 0 deletions
diff --git a/graphics/asymptote/LspCpp/include/LibLsp/lsp/general/lsTextDocumentClientCapabilities.h b/graphics/asymptote/LspCpp/include/LibLsp/lsp/general/lsTextDocumentClientCapabilities.h
new file mode 100644
index 0000000000..569f203c7a
--- /dev/null
+++ b/graphics/asymptote/LspCpp/include/LibLsp/lsp/general/lsTextDocumentClientCapabilities.h
@@ -0,0 +1,713 @@
+#pragma once
+#include "LibLsp/lsp/method_type.h"
+
+
+#include <stdexcept>
+#include "LibLsp/JsonRpc/message.h"
+#include "LibLsp/lsp/lsDocumentUri.h"
+#include "LibLsp/lsp/lsAny.h"
+#include "LibLsp/lsp/extention/jdtls/searchSymbols.h"
+#include "lsWorkspaceClientCapabilites.h"
+#include "LibLsp/lsp/lsp_completion.h"
+#include "LibLsp/lsp/lsp_diagnostic.h"
+
+
+struct WorkDoneProgressOptions
+{
+ boost::optional<bool>workDoneProgress;
+ MAKE_SWAP_METHOD(WorkDoneProgressOptions, workDoneProgress);
+};
+MAKE_REFLECT_STRUCT(WorkDoneProgressOptions, workDoneProgress);
+
+// Completion options.
+struct lsCompletionOptions:WorkDoneProgressOptions
+{
+ // The server provides support to resolve additional
+ // information for a completion item.
+ boost::optional<bool> resolveProvider = false;
+
+ //
+ // Most tools trigger completion request automatically without explicitly requesting
+ // it using a keyboard shortcut (e.g. Ctrl+Space). Typically they do so when the user
+ // starts to type an identifier. For example if the user types `c` in a JavaScript file
+ // code complete will automatically pop up present `console` besides others as a
+ // completion item. Characters that make up identifiers don't need to be listed here.
+ //
+ // If code complete should automatically be trigger on characters not being valid inside
+ // an identifier (for example `.` in JavaScript) list them in `triggerCharacters`.
+ //
+ // https://github.com/Microsoft/language-server-protocol/issues/138.
+ boost::optional< std::vector<std::string> > triggerCharacters ;
+
+ //
+ // The list of all possible characters that commit a completion. This field can be used
+ // if clients don't support individual commmit characters per completion item. See
+ // `ClientCapabilities.textDocument.completion.completionItem.commitCharactersSupport`
+ //
+ boost::optional< std::vector<std::string> > allCommitCharacters;
+
+ MAKE_SWAP_METHOD(lsCompletionOptions, workDoneProgress, resolveProvider, triggerCharacters, allCommitCharacters);
+};
+MAKE_REFLECT_STRUCT(lsCompletionOptions, workDoneProgress, resolveProvider, triggerCharacters,allCommitCharacters);
+
+
+
+// Save options.
+struct lsSaveOptions {
+ // The client is supposed to include the content on save.
+ bool includeText = false;
+ void swap(lsSaveOptions& arg)noexcept
+ {
+ auto temp = includeText;
+ includeText = arg.includeText;
+ arg.includeText = temp;
+ }
+};
+MAKE_REFLECT_STRUCT(lsSaveOptions, includeText);
+
+// Signature help options.
+struct lsSignatureHelpOptions : WorkDoneProgressOptions {
+ // The characters that trigger signature help automatically.
+ // NOTE: If updating signature help tokens make sure to also update
+ // WorkingFile::FindClosestCallNameInBuffer.
+ std::vector<std::string> triggerCharacters;
+ MAKE_SWAP_METHOD(lsSignatureHelpOptions, workDoneProgress, triggerCharacters);
+};
+MAKE_REFLECT_STRUCT(lsSignatureHelpOptions, workDoneProgress, triggerCharacters);
+
+// Defines how the host (editor) should sync document changes to the language
+// server.
+enum class lsTextDocumentSyncKind {
+ // Documents should not be synced at all.
+ None = 0,
+
+ // Documents are synced by always sending the full content
+ // of the document.
+ Full = 1,
+
+ // Documents are synced by sending the full content on open.
+ // After that only incremental updates to the document are
+ // send.
+ Incremental = 2
+};
+
+#if _WIN32
+MAKE_REFLECT_TYPE_PROXY(lsTextDocumentSyncKind)
+#else
+//#pragma clang diagnostic push
+//#pragma clang diagnostic ignored "-Wunused-function"
+MAKE_REFLECT_TYPE_PROXY(lsTextDocumentSyncKind)
+//#pragma clang diagnostic pop
+#endif
+
+struct lsTextDocumentSyncOptions {
+ // Open and close notifications are sent to the server.
+ boost::optional<bool> openClose ;
+ // Change notificatins are sent to the server. See TextDocumentSyncKind.None,
+ // TextDocumentSyncKind.Full and TextDocumentSyncKindIncremental.
+ boost::optional< lsTextDocumentSyncKind> change ;
+ // Will save notifications are sent to the server.
+ boost::optional<bool> willSave;
+ // Will save wait until requests are sent to the server.
+ boost::optional<bool> willSaveWaitUntil;
+ // Save notifications are sent to the server.
+ boost::optional<lsSaveOptions> save;
+
+ MAKE_SWAP_METHOD(lsTextDocumentSyncOptions,
+ openClose,
+ change,
+ willSave,
+ willSaveWaitUntil,
+ save);
+};
+MAKE_REFLECT_STRUCT(lsTextDocumentSyncOptions,
+ openClose,
+ change,
+ willSave,
+ willSaveWaitUntil,
+ save);
+
+struct SynchronizationCapabilities {
+ // Whether text document synchronization supports dynamic registration.
+ boost::optional<bool> dynamicRegistration;
+
+ // The client supports sending will save notifications.
+ boost::optional<bool> willSave;
+
+ // The client supports sending a will save request and
+ // waits for a response providing text edits which will
+ // be applied to the document before it is saved.
+ boost::optional<bool> willSaveWaitUntil;
+
+ // The client supports did save notifications.
+ boost::optional<bool> didSave;
+
+ MAKE_SWAP_METHOD(SynchronizationCapabilities,
+ dynamicRegistration,
+ willSave,
+ willSaveWaitUntil,
+ didSave);
+};
+MAKE_REFLECT_STRUCT(SynchronizationCapabilities,
+ dynamicRegistration,
+ willSave,
+ willSaveWaitUntil,
+ didSave);
+
+struct CompletionItemKindCapabilities
+{
+ boost::optional<std::vector<lsCompletionItemKind> >valueSet;
+ MAKE_SWAP_METHOD(CompletionItemKindCapabilities, valueSet);
+};
+MAKE_REFLECT_STRUCT(CompletionItemKindCapabilities, valueSet);
+
+struct CompletionItemCapabilities {
+ // Client supports snippets as insert text.
+ //
+ // A snippet can define tab stops and placeholders with `$1`, `$2`
+ // and `${3:foo}`. `$0` defines the final tab stop, it defaults to
+ // the end of the snippet. Placeholders with equal identifiers are linked,
+ // that is typing in one will update others too.
+ boost::optional<bool> snippetSupport;
+
+ // Client supports commit characters on a completion item.
+
+ boost::optional<bool> commitCharactersSupport;
+
+
+ // Client supports the following content formats for the documentation
+ // property. The order describes the preferred format of the client.
+
+ boost::optional< std::vector<std::string> > documentationFormat;
+
+ // Client supports the deprecated property on a completion item.
+
+ boost::optional<bool> deprecatedSupport;
+
+ //
+ // Client supports the preselect property on a completion item.
+ //
+ boost::optional<bool> preselectSupport;
+
+ MAKE_SWAP_METHOD(CompletionItemCapabilities,
+ snippetSupport,
+ commitCharactersSupport,
+ documentationFormat,
+ deprecatedSupport, preselectSupport);
+};
+MAKE_REFLECT_STRUCT(CompletionItemCapabilities,
+ snippetSupport,
+ commitCharactersSupport,
+ documentationFormat,
+ deprecatedSupport, preselectSupport);
+
+
+//
+ // Capabilities specific to the `textDocument/completion`
+ //
+struct CompletionCapabilities {
+ // Whether completion supports dynamic registration.
+ boost::optional<bool> dynamicRegistration;
+
+
+
+ // The client supports the following `CompletionItem` specific
+ // capabilities.
+ boost::optional<CompletionItemCapabilities> completionItem;
+
+ //
+ // The client supports the following `CompletionItemKind` specific
+ // capabilities.
+ //
+ boost::optional<CompletionItemKindCapabilities> completionItemKind;
+
+ //
+ // The client supports sending additional context information for a
+ // `textDocument/completion` request.
+ //
+ boost::optional<bool> contextSupport;
+
+
+ MAKE_SWAP_METHOD(CompletionCapabilities,
+ dynamicRegistration,
+ completionItem, completionItemKind);
+};
+
+MAKE_REFLECT_STRUCT(CompletionCapabilities,
+ dynamicRegistration,
+ completionItem , completionItemKind);
+
+
+struct HoverCapabilities:public DynamicRegistrationCapabilities
+{
+ //
+ // Client supports the following content formats for the content
+ // property. The order describes the preferred format of the client.
+ //
+ // See {@link MarkupKind} for allowed values.
+ //
+ boost::optional<std::vector<std::string>> contentFormat;
+
+ MAKE_SWAP_METHOD(HoverCapabilities, dynamicRegistration, contentFormat);
+};
+MAKE_REFLECT_STRUCT(HoverCapabilities, dynamicRegistration, contentFormat);
+
+//
+ // Client capabilities specific to parameter information.
+ //
+struct ParameterInformationCapabilities {
+ //
+ // The client supports processing label offsets instead of a
+ // simple label string.
+ //
+ // Since 3.14.0
+ //
+ boost::optional<bool> labelOffsetSupport;
+
+ MAKE_SWAP_METHOD(ParameterInformationCapabilities, labelOffsetSupport);
+};
+MAKE_REFLECT_STRUCT(ParameterInformationCapabilities, labelOffsetSupport)
+
+
+struct SignatureInformationCapabilities {
+ //
+ // Client supports the following content formats for the documentation
+ // property. The order describes the preferred format of the client.
+ //
+ // See {@link MarkupKind} for allowed values.
+ //
+ std::vector<std::string> documentationFormat;
+
+ //
+ // Client capabilities specific to parameter information.
+ //
+ ParameterInformationCapabilities parameterInformation;
+
+ MAKE_SWAP_METHOD(SignatureInformationCapabilities, documentationFormat, parameterInformation)
+};
+MAKE_REFLECT_STRUCT(SignatureInformationCapabilities,documentationFormat, parameterInformation)
+
+struct SignatureHelpCapabilities :public DynamicRegistrationCapabilities
+{
+ //
+ // The client supports the following `SignatureInformation`
+ // specific properties.
+ //
+ boost::optional< SignatureInformationCapabilities > signatureInformation;
+
+ MAKE_SWAP_METHOD(SignatureHelpCapabilities, dynamicRegistration, signatureInformation)
+};
+MAKE_REFLECT_STRUCT(SignatureHelpCapabilities, dynamicRegistration, signatureInformation)
+
+struct DocumentSymbolCapabilities :public DynamicRegistrationCapabilities {
+ //
+ // Specific capabilities for the `SymbolKind`.
+ //
+ boost::optional<SymbolKindCapabilities> symbolKind;
+
+ //
+ // The client support hierarchical document symbols.
+ //
+ boost::optional<bool> hierarchicalDocumentSymbolSupport;
+
+ MAKE_SWAP_METHOD(DocumentSymbolCapabilities, dynamicRegistration, symbolKind, hierarchicalDocumentSymbolSupport)
+};
+MAKE_REFLECT_STRUCT(DocumentSymbolCapabilities, dynamicRegistration, symbolKind, hierarchicalDocumentSymbolSupport)
+
+struct DeclarationCapabilities:public DynamicRegistrationCapabilities{
+ //
+ // The client supports additional metadata in the form of declaration links.
+ //
+ boost::optional<bool>linkSupport;
+
+ MAKE_SWAP_METHOD(DeclarationCapabilities, dynamicRegistration, linkSupport);
+};
+MAKE_REFLECT_STRUCT(DeclarationCapabilities, dynamicRegistration, linkSupport)
+
+
+struct CodeActionKindCapabilities
+{
+ //
+ // The code action kind values the client supports. When this
+ // property exists the client also guarantees that it will
+ // handle values outside its set gracefully and falls back
+ // to a default value when unknown.
+ //
+ // See {@link CodeActionKind} for allowed values.
+ //
+ boost::optional< std::vector< std::string> >valueSet;
+
+ MAKE_SWAP_METHOD(CodeActionKindCapabilities, valueSet)
+};
+MAKE_REFLECT_STRUCT(CodeActionKindCapabilities,valueSet)
+
+struct CodeActionLiteralSupportCapabilities
+{
+ boost::optional<CodeActionKindCapabilities> codeActionKind;
+
+ MAKE_SWAP_METHOD(CodeActionLiteralSupportCapabilities, codeActionKind)
+};
+MAKE_REFLECT_STRUCT(CodeActionLiteralSupportCapabilities, codeActionKind)
+
+struct CodeActionCapabilities:public DynamicRegistrationCapabilities{
+ //
+ // The client support code action literals as a valid
+ // response of the `textDocument/codeAction` request.
+ //
+ boost::optional<CodeActionLiteralSupportCapabilities> codeActionLiteralSupport;
+
+ MAKE_SWAP_METHOD(CodeActionCapabilities, dynamicRegistration, codeActionLiteralSupport)
+};
+MAKE_REFLECT_STRUCT(CodeActionCapabilities,dynamicRegistration,codeActionLiteralSupport)
+
+struct RenameCapabilities :public DynamicRegistrationCapabilities {
+ //
+ // The client support code action literals as a valid
+ // response of the `textDocument/codeAction` request.
+ //
+ boost::optional<bool> prepareSupport;
+
+ MAKE_SWAP_METHOD(RenameCapabilities, dynamicRegistration, prepareSupport)
+};
+MAKE_REFLECT_STRUCT(RenameCapabilities, dynamicRegistration, prepareSupport)
+
+struct DiagnosticsTagSupport {
+ /**
+ * The tags supported by the client.
+ */
+ std::vector<DiagnosticTag> valueSet;
+ MAKE_SWAP_METHOD(DiagnosticsTagSupport, valueSet)
+};
+MAKE_REFLECT_STRUCT(DiagnosticsTagSupport, valueSet)
+
+struct PublishDiagnosticsClientCapabilities :public DynamicRegistrationCapabilities {
+ /**
+ * The client support code action literals as a valid
+ * response of the `textDocument/codeAction` request.
+ */
+ boost::optional<bool> relatedInformation;
+
+ /**
+ * Client supports the tag property to provide meta data about a diagnostic.
+ * Clients supporting tags have to handle unknown tags gracefully.
+ *
+ * This property had been added and implemented as boolean before it was
+ * added to the specification as {@link DiagnosticsTagSupport}. In order to
+ * keep this implementation compatible with intermediate clients (including
+ * vscode-language-client < 6.0.0) we add an either type here.
+ *
+ * Since 3.15
+ */
+ boost::optional < std::pair<boost::optional<bool>, boost::optional<DiagnosticsTagSupport> > > tagSupport;
+
+ /**
+ * Whether the client interprets the version property of the
+ * `textDocument/publishDiagnostics` notification's parameter.
+ *
+ * Since 3.15.0
+ */
+ boost::optional<bool> versionSupport;
+
+ /**
+ * Client supports a codeDescription property
+ *
+ * @since 3.16.0
+ */
+ boost::optional<bool> codeDescriptionSupport ;
+
+ /**
+ * Whether code action supports the `data` property which is
+ * preserved between a `textDocument/publishDiagnostics` and
+ * `textDocument/codeAction` request.
+ *
+ * @since 3.16.0
+ */
+ boost::optional<bool> dataSupport ;
+
+
+ MAKE_SWAP_METHOD(PublishDiagnosticsClientCapabilities, dynamicRegistration, relatedInformation, tagSupport,versionSupport,codeDescriptionSupport,dataSupport)
+};
+MAKE_REFLECT_STRUCT(PublishDiagnosticsClientCapabilities, dynamicRegistration, relatedInformation, tagSupport, versionSupport, codeDescriptionSupport, dataSupport)
+
+
+struct FoldingRangeCapabilities :public DynamicRegistrationCapabilities {
+ //
+ // The maximum number of folding ranges that the client prefers to receive per document. The value serves as a
+ // hint, servers are free to follow the limit.
+ //
+ boost::optional<int> rangeLimit;
+
+ //
+ // If set, the client signals that it only supports folding complete lines. If set, client will
+ // ignore specified `startCharacter` and `endCharacter` properties in a FoldingRange.
+ //
+ boost::optional<bool> lineFoldingOnly;
+ MAKE_SWAP_METHOD(FoldingRangeCapabilities, dynamicRegistration, rangeLimit, lineFoldingOnly)
+};
+MAKE_REFLECT_STRUCT(FoldingRangeCapabilities, dynamicRegistration, rangeLimit,lineFoldingOnly)
+
+
+struct SemanticHighlightingCapabilities :public DynamicRegistrationCapabilities {
+ //
+ // The client support code action literals as a valid
+ // response of the `textDocument/codeAction` request.
+ //
+ boost::optional<bool> semanticHighlighting;
+
+ MAKE_SWAP_METHOD(SemanticHighlightingCapabilities, dynamicRegistration, semanticHighlighting)
+};
+MAKE_REFLECT_STRUCT(SemanticHighlightingCapabilities, dynamicRegistration, semanticHighlighting)
+
+struct SemanticTokensClientCapabilitiesRequestsFull {
+
+ //
+ // The client will send the `textDocument/semanticTokens/full/delta` request if
+ // the server provides a corresponding handler.
+ //
+ bool delta = false;
+ MAKE_SWAP_METHOD(SemanticTokensClientCapabilitiesRequestsFull, delta)
+};
+MAKE_REFLECT_STRUCT(SemanticTokensClientCapabilitiesRequestsFull, delta)
+
+struct SemanticTokensClientCapabilities : public DynamicRegistrationCapabilities
+{
+ //export TokenFormat = 'relative';
+ struct lsRequests
+ {
+ //
+ // The client will send the `textDocument/semanticTokens/range` request
+ // if the server provides a corresponding handler.
+ //
+ boost::optional<std::pair< boost::optional<bool>,
+ boost::optional<SemanticTokensClientCapabilitiesRequestsFull>>> range;
+ //
+ // The client will send the `textDocument/semanticTokens/full` request
+ // if the server provides a corresponding handler.
+ //
+ boost::optional<std::pair< boost::optional<bool>, boost::optional<lsp::Any>>> full;
+ MAKE_SWAP_METHOD(lsRequests, range, full)
+ };
+
+ lsRequests requests;
+ //
+ // The token types that the client supports.
+ //
+ std::vector<std::string> tokenTypes;
+
+ //
+ // The token modifiers that the client supports.
+ //
+ std::vector<std::string> tokenModifiers;
+ //
+ // The formats the clients supports.
+ //
+ std::vector<std::string> formats;
+ //
+ // Whether the client supports tokens that can overlap each other.
+ //
+ boost::optional < bool >overlappingTokenSupport;
+
+ //
+ // Whether the client supports tokens that can span multiple lines.
+ //
+ boost::optional < bool > multilineTokenSupport;
+
+ MAKE_SWAP_METHOD(SemanticTokensClientCapabilities, dynamicRegistration,requests, tokenTypes, tokenModifiers,
+ formats, overlappingTokenSupport, multilineTokenSupport)
+
+};
+MAKE_REFLECT_STRUCT(SemanticTokensClientCapabilities::lsRequests, range,full)
+MAKE_REFLECT_STRUCT(SemanticTokensClientCapabilities, dynamicRegistration, requests, tokenTypes, tokenModifiers,
+ formats, overlappingTokenSupport, multilineTokenSupport)
+
+// Text document specific client capabilities.
+struct lsTextDocumentClientCapabilities {
+
+ SynchronizationCapabilities synchronization;
+
+
+ // Capabilities specific to the `textDocument/completion`
+ boost::optional<CompletionCapabilities> completion;
+
+
+
+ // Capabilities specific to the `textDocument/hover`
+ boost::optional<HoverCapabilities> hover;
+
+ // Capabilities specific to the `textDocument/signatureHelp`
+ boost::optional<SignatureHelpCapabilities> signatureHelp;
+
+ // Capabilities specific to the `textDocument/references`
+ boost::optional<DynamicRegistrationCapabilities> references;
+
+
+
+
+
+ // Capabilities specific to the `textDocument/documentHighlight`
+ boost::optional<DynamicRegistrationCapabilities> documentHighlight;
+
+ // Capabilities specific to the `textDocument/documentSymbol`
+ boost::optional<DocumentSymbolCapabilities> documentSymbol;
+
+ // Capabilities specific to the `textDocument/formatting`
+ boost::optional<DynamicRegistrationCapabilities> formatting;
+
+ // Capabilities specific to the `textDocument/rangeFormatting`
+ boost::optional<DynamicRegistrationCapabilities> rangeFormatting;
+
+ // Capabilities specific to the `textDocument/onTypeFormatting`
+ boost::optional<DynamicRegistrationCapabilities> onTypeFormatting;
+
+
+ //
+ // Capabilities specific to the `textDocument/declaration`
+ //
+ // Since 3.14.0
+ //
+ boost::optional< DeclarationCapabilities> declaration;
+
+
+ typedef DeclarationCapabilities DefinitionCapabilities;
+ // Capabilities specific to the `textDocument/definition`
+ boost::optional<DefinitionCapabilities> definition;
+
+
+
+ //
+// Capabilities specific to the `textDocument/typeDefinition`
+//
+// Since 3.6.0
+//
+ typedef DeclarationCapabilities TypeDefinitionCapabilities;
+ boost::optional<TypeDefinitionCapabilities> typeDefinition;
+
+
+ typedef DeclarationCapabilities ImplementationCapabilities;
+ // Capabilities specific to the `textDocument/implementation`
+ boost::optional<ImplementationCapabilities> implementation;
+
+
+ // Capabilities specific to the `textDocument/codeAction`
+ boost::optional<CodeActionCapabilities> codeAction;
+
+
+ // Capabilities specific to the `textDocument/codeLens`
+ boost::optional<DynamicRegistrationCapabilities> codeLens;
+
+ // Capabilities specific to the `textDocument/documentLink`
+ boost::optional<DynamicRegistrationCapabilities> documentLink;
+
+ //
+ // Capabilities specific to the `textDocument/documentColor` and the
+ // `textDocument/colorPresentation` request.
+ //
+ // Since 3.6.0
+ //
+ boost::optional<DynamicRegistrationCapabilities> colorProvider;
+
+ // Capabilities specific to the `textDocument/rename`
+ boost::optional<RenameCapabilities> rename;
+
+//
+// Capabilities specific to `textDocument/publishDiagnostics`.
+//
+ boost::optional<PublishDiagnosticsClientCapabilities> publishDiagnostics;
+
+ //
+// Capabilities specific to `textDocument/foldingRange` requests.
+//
+// Since 3.10.0
+//
+ boost::optional< FoldingRangeCapabilities > foldingRange;
+
+
+ //
+ // Capabilities specific to {@code textDocument/semanticHighlighting}.
+ //
+ boost::optional< SemanticHighlightingCapabilities > semanticHighlightingCapabilities;
+
+ //
+ // Capabilities specific to {@code textDocument/typeHierarchy}.
+ //
+ boost::optional< DynamicRegistrationCapabilities > typeHierarchyCapabilities;
+
+
+
+ //
+// Capabilities specific to `textDocument/selectionRange` requests
+//
+
+ boost::optional< DynamicRegistrationCapabilities > selectionRange;
+
+ //
+ // Capabilities specific to the `textDocument/linkedEditingRange` request.
+ //
+ // @since 3.16.0
+ //
+ boost::optional< DynamicRegistrationCapabilities > linkedEditingRange;
+
+ //
+ // Capabilities specific to the various call hierarchy requests.
+ //
+ // @since 3.16.0
+ //
+ boost::optional< DynamicRegistrationCapabilities > callHierarchy;
+
+ //
+ // Capabilities specific to the various semantic token requests.
+ //
+ // @since 3.16.0
+ //
+ boost::optional< SemanticTokensClientCapabilities > semanticTokens;
+
+ //
+ // Capabilities specific to the `textDocument/moniker` request.
+ //
+ // @since 3.16.0
+ //
+ boost::optional< DynamicRegistrationCapabilities > moniker;
+
+ MAKE_SWAP_METHOD(lsTextDocumentClientCapabilities,
+ synchronization,
+ completion,
+ hover,
+ signatureHelp,
+ implementation,
+ references,
+ documentHighlight,
+ documentSymbol,
+ formatting,
+ rangeFormatting,
+ onTypeFormatting,
+ declaration,
+ definition, typeDefinition, implementation,
+ codeAction,
+ codeLens,
+ documentLink, colorProvider,
+ rename, publishDiagnostics, foldingRange,
+ semanticHighlightingCapabilities, typeHierarchyCapabilities,
+ callHierarchy, selectionRange , linkedEditingRange, semanticTokens, moniker)
+};
+
+
+MAKE_REFLECT_STRUCT(lsTextDocumentClientCapabilities,
+ synchronization,
+ completion,
+ hover,
+ signatureHelp,
+ implementation,
+ references,
+ documentHighlight,
+ documentSymbol,
+ formatting,
+ rangeFormatting,
+ onTypeFormatting,
+ declaration,
+ definition, typeDefinition, implementation,
+ codeAction,
+ codeLens,
+ documentLink, colorProvider,
+ rename, publishDiagnostics, foldingRange,
+ semanticHighlightingCapabilities, typeHierarchyCapabilities,
+ callHierarchy, selectionRange, linkedEditingRange, semanticTokens, moniker)