mirror of
https://github.com/neovim/neovim.git
synced 2025-01-01 17:23:36 -07:00
5d633546bf
Declaration, type-definition, and implementation capabilities were previously disabled if the client received table output from the server capabilities. The workDoneProgress capability is sent for many servers for all supported capabilities as part of this table. Default to setting capability to table instead of false.
1079 lines
38 KiB
Lua
1079 lines
38 KiB
Lua
-- Protocol for the Microsoft Language Server Protocol (mslsp)
|
||
|
||
local if_nil = vim.F.if_nil
|
||
|
||
local protocol = {}
|
||
|
||
--[=[
|
||
---@private
|
||
--- Useful for interfacing with:
|
||
--- https://github.com/microsoft/language-server-protocol/raw/gh-pages/_specifications/specification-3-14.md
|
||
function transform_schema_comments()
|
||
nvim.command [[silent! '<,'>g/\/\*\*\|\*\/\|^$/d]]
|
||
nvim.command [[silent! '<,'>s/^\(\s*\) \* \=\(.*\)/\1--\2/]]
|
||
end
|
||
---@private
|
||
function transform_schema_to_table()
|
||
transform_schema_comments()
|
||
nvim.command [[silent! '<,'>s/: \S\+//]]
|
||
nvim.command [[silent! '<,'>s/export const //]]
|
||
nvim.command [[silent! '<,'>s/export namespace \(\S*\)\s*{/protocol.\1 = {/]]
|
||
nvim.command [[silent! '<,'>s/namespace \(\S*\)\s*{/protocol.\1 = {/]]
|
||
end
|
||
--]=]
|
||
|
||
local constants = {
|
||
DiagnosticSeverity = {
|
||
-- Reports an error.
|
||
Error = 1;
|
||
-- Reports a warning.
|
||
Warning = 2;
|
||
-- Reports an information.
|
||
Information = 3;
|
||
-- Reports a hint.
|
||
Hint = 4;
|
||
};
|
||
|
||
DiagnosticTag = {
|
||
-- Unused or unnecessary code
|
||
Unnecessary = 1;
|
||
-- Deprecated or obsolete code
|
||
Deprecated = 2;
|
||
};
|
||
|
||
MessageType = {
|
||
-- An error message.
|
||
Error = 1;
|
||
-- A warning message.
|
||
Warning = 2;
|
||
-- An information message.
|
||
Info = 3;
|
||
-- A log message.
|
||
Log = 4;
|
||
};
|
||
|
||
-- The file event type.
|
||
FileChangeType = {
|
||
-- The file got created.
|
||
Created = 1;
|
||
-- The file got changed.
|
||
Changed = 2;
|
||
-- The file got deleted.
|
||
Deleted = 3;
|
||
};
|
||
|
||
-- The kind of a completion entry.
|
||
CompletionItemKind = {
|
||
Text = 1;
|
||
Method = 2;
|
||
Function = 3;
|
||
Constructor = 4;
|
||
Field = 5;
|
||
Variable = 6;
|
||
Class = 7;
|
||
Interface = 8;
|
||
Module = 9;
|
||
Property = 10;
|
||
Unit = 11;
|
||
Value = 12;
|
||
Enum = 13;
|
||
Keyword = 14;
|
||
Snippet = 15;
|
||
Color = 16;
|
||
File = 17;
|
||
Reference = 18;
|
||
Folder = 19;
|
||
EnumMember = 20;
|
||
Constant = 21;
|
||
Struct = 22;
|
||
Event = 23;
|
||
Operator = 24;
|
||
TypeParameter = 25;
|
||
};
|
||
|
||
-- How a completion was triggered
|
||
CompletionTriggerKind = {
|
||
-- Completion was triggered by typing an identifier (24x7 code
|
||
-- complete), manual invocation (e.g Ctrl+Space) or via API.
|
||
Invoked = 1;
|
||
-- Completion was triggered by a trigger character specified by
|
||
-- the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
|
||
TriggerCharacter = 2;
|
||
-- Completion was re-triggered as the current completion list is incomplete.
|
||
TriggerForIncompleteCompletions = 3;
|
||
};
|
||
|
||
-- A document highlight kind.
|
||
DocumentHighlightKind = {
|
||
-- A textual occurrence.
|
||
Text = 1;
|
||
-- Read-access of a symbol, like reading a variable.
|
||
Read = 2;
|
||
-- Write-access of a symbol, like writing to a variable.
|
||
Write = 3;
|
||
};
|
||
|
||
-- A symbol kind.
|
||
SymbolKind = {
|
||
File = 1;
|
||
Module = 2;
|
||
Namespace = 3;
|
||
Package = 4;
|
||
Class = 5;
|
||
Method = 6;
|
||
Property = 7;
|
||
Field = 8;
|
||
Constructor = 9;
|
||
Enum = 10;
|
||
Interface = 11;
|
||
Function = 12;
|
||
Variable = 13;
|
||
Constant = 14;
|
||
String = 15;
|
||
Number = 16;
|
||
Boolean = 17;
|
||
Array = 18;
|
||
Object = 19;
|
||
Key = 20;
|
||
Null = 21;
|
||
EnumMember = 22;
|
||
Struct = 23;
|
||
Event = 24;
|
||
Operator = 25;
|
||
TypeParameter = 26;
|
||
};
|
||
|
||
-- Represents reasons why a text document is saved.
|
||
TextDocumentSaveReason = {
|
||
-- Manually triggered, e.g. by the user pressing save, by starting debugging,
|
||
-- or by an API call.
|
||
Manual = 1;
|
||
-- Automatic after a delay.
|
||
AfterDelay = 2;
|
||
-- When the editor lost focus.
|
||
FocusOut = 3;
|
||
};
|
||
|
||
ErrorCodes = {
|
||
-- Defined by JSON RPC
|
||
ParseError = -32700;
|
||
InvalidRequest = -32600;
|
||
MethodNotFound = -32601;
|
||
InvalidParams = -32602;
|
||
InternalError = -32603;
|
||
serverErrorStart = -32099;
|
||
serverErrorEnd = -32000;
|
||
ServerNotInitialized = -32002;
|
||
UnknownErrorCode = -32001;
|
||
-- Defined by the protocol.
|
||
RequestCancelled = -32800;
|
||
ContentModified = -32801;
|
||
};
|
||
|
||
-- Describes the content type that a client supports in various
|
||
-- result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
|
||
--
|
||
-- Please note that `MarkupKinds` must not start with a `$`. This kinds
|
||
-- are reserved for internal usage.
|
||
MarkupKind = {
|
||
-- Plain text is supported as a content format
|
||
PlainText = 'plaintext';
|
||
-- Markdown is supported as a content format
|
||
Markdown = 'markdown';
|
||
};
|
||
|
||
ResourceOperationKind = {
|
||
-- Supports creating new files and folders.
|
||
Create = 'create';
|
||
-- Supports renaming existing files and folders.
|
||
Rename = 'rename';
|
||
-- Supports deleting existing files and folders.
|
||
Delete = 'delete';
|
||
};
|
||
|
||
FailureHandlingKind = {
|
||
-- Applying the workspace change is simply aborted if one of the changes provided
|
||
-- fails. All operations executed before the failing operation stay executed.
|
||
Abort = 'abort';
|
||
-- All operations are executed transactionally. That means they either all
|
||
-- succeed or no changes at all are applied to the workspace.
|
||
Transactional = 'transactional';
|
||
-- If the workspace edit contains only textual file changes they are executed transactionally.
|
||
-- If resource changes (create, rename or delete file) are part of the change the failure
|
||
-- handling strategy is abort.
|
||
TextOnlyTransactional = 'textOnlyTransactional';
|
||
-- The client tries to undo the operations already executed. But there is no
|
||
-- guarantee that this succeeds.
|
||
Undo = 'undo';
|
||
};
|
||
|
||
-- Known error codes for an `InitializeError`;
|
||
InitializeError = {
|
||
-- If the protocol version provided by the client can't be handled by the server.
|
||
-- @deprecated This initialize error got replaced by client capabilities. There is
|
||
-- no version handshake in version 3.0x
|
||
unknownProtocolVersion = 1;
|
||
};
|
||
|
||
-- Defines how the host (editor) should sync document changes to the language server.
|
||
TextDocumentSyncKind = {
|
||
-- 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;
|
||
};
|
||
|
||
WatchKind = {
|
||
-- Interested in create events.
|
||
Create = 1;
|
||
-- Interested in change events
|
||
Change = 2;
|
||
-- Interested in delete events
|
||
Delete = 4;
|
||
};
|
||
|
||
-- Defines whether the insert text in a completion item should be interpreted as
|
||
-- plain text or a snippet.
|
||
InsertTextFormat = {
|
||
-- The primary text to be inserted is treated as a plain string.
|
||
PlainText = 1;
|
||
-- The primary text to be inserted is treated as a snippet.
|
||
--
|
||
-- 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.
|
||
Snippet = 2;
|
||
};
|
||
|
||
-- A set of predefined code action kinds
|
||
CodeActionKind = {
|
||
-- Empty kind.
|
||
Empty = '';
|
||
-- Base kind for quickfix actions
|
||
QuickFix = 'quickfix';
|
||
-- Base kind for refactoring actions
|
||
Refactor = 'refactor';
|
||
-- Base kind for refactoring extraction actions
|
||
--
|
||
-- Example extract actions:
|
||
--
|
||
-- - Extract method
|
||
-- - Extract function
|
||
-- - Extract variable
|
||
-- - Extract interface from class
|
||
-- - ...
|
||
RefactorExtract = 'refactor.extract';
|
||
-- Base kind for refactoring inline actions
|
||
--
|
||
-- Example inline actions:
|
||
--
|
||
-- - Inline function
|
||
-- - Inline variable
|
||
-- - Inline constant
|
||
-- - ...
|
||
RefactorInline = 'refactor.inline';
|
||
-- Base kind for refactoring rewrite actions
|
||
--
|
||
-- Example rewrite actions:
|
||
--
|
||
-- - Convert JavaScript function to class
|
||
-- - Add or remove parameter
|
||
-- - Encapsulate field
|
||
-- - Make method static
|
||
-- - Move method to base class
|
||
-- - ...
|
||
RefactorRewrite = 'refactor.rewrite';
|
||
-- Base kind for source actions
|
||
--
|
||
-- Source code actions apply to the entire file.
|
||
Source = 'source';
|
||
-- Base kind for an organize imports source action
|
||
SourceOrganizeImports = 'source.organizeImports';
|
||
};
|
||
}
|
||
|
||
for k, v in pairs(constants) do
|
||
local tbl = vim.deepcopy(v)
|
||
vim.tbl_add_reverse_lookup(tbl)
|
||
protocol[k] = tbl
|
||
end
|
||
|
||
--[=[
|
||
--Text document specific client capabilities.
|
||
export interface TextDocumentClientCapabilities {
|
||
synchronization?: {
|
||
--Whether text document synchronization supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
--The client supports sending will save notifications.
|
||
willSave?: boolean;
|
||
--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.
|
||
willSaveWaitUntil?: boolean;
|
||
--The client supports did save notifications.
|
||
didSave?: boolean;
|
||
}
|
||
--Capabilities specific to the `textDocument/completion`
|
||
completion?: {
|
||
--Whether completion supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
--The client supports the following `CompletionItem` specific
|
||
--capabilities.
|
||
completionItem?: {
|
||
--The 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.
|
||
snippetSupport?: boolean;
|
||
--The client supports commit characters on a completion item.
|
||
commitCharactersSupport?: boolean
|
||
--The client supports the following content formats for the documentation
|
||
--property. The order describes the preferred format of the client.
|
||
documentationFormat?: MarkupKind[];
|
||
--The client supports the deprecated property on a completion item.
|
||
deprecatedSupport?: boolean;
|
||
--The client supports the preselect property on a completion item.
|
||
preselectSupport?: boolean;
|
||
}
|
||
completionItemKind?: {
|
||
--The completion item 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.
|
||
--
|
||
--If this property is not present the client only supports
|
||
--the completion items kinds from `Text` to `Reference` as defined in
|
||
--the initial version of the protocol.
|
||
valueSet?: CompletionItemKind[];
|
||
},
|
||
--The client supports to send additional context information for a
|
||
--`textDocument/completion` request.
|
||
contextSupport?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/hover`
|
||
hover?: {
|
||
--Whether hover supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
--The client supports the follow content formats for the content
|
||
--property. The order describes the preferred format of the client.
|
||
contentFormat?: MarkupKind[];
|
||
};
|
||
--Capabilities specific to the `textDocument/signatureHelp`
|
||
signatureHelp?: {
|
||
--Whether signature help supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
--The client supports the following `SignatureInformation`
|
||
--specific properties.
|
||
signatureInformation?: {
|
||
--The client supports the follow content formats for the documentation
|
||
--property. The order describes the preferred format of the client.
|
||
documentationFormat?: MarkupKind[];
|
||
--Client capabilities specific to parameter information.
|
||
parameterInformation?: {
|
||
--The client supports processing label offsets instead of a
|
||
--simple label string.
|
||
--
|
||
--Since 3.14.0
|
||
labelOffsetSupport?: boolean;
|
||
}
|
||
};
|
||
};
|
||
--Capabilities specific to the `textDocument/references`
|
||
references?: {
|
||
--Whether references supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/documentHighlight`
|
||
documentHighlight?: {
|
||
--Whether document highlight supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/documentSymbol`
|
||
documentSymbol?: {
|
||
--Whether document symbol supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
--Specific capabilities for the `SymbolKind`.
|
||
symbolKind?: {
|
||
--The symbol 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.
|
||
--
|
||
--If this property is not present the client only supports
|
||
--the symbol kinds from `File` to `Array` as defined in
|
||
--the initial version of the protocol.
|
||
valueSet?: SymbolKind[];
|
||
}
|
||
--The client supports hierarchical document symbols.
|
||
hierarchicalDocumentSymbolSupport?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/formatting`
|
||
formatting?: {
|
||
--Whether formatting supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/rangeFormatting`
|
||
rangeFormatting?: {
|
||
--Whether range formatting supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/onTypeFormatting`
|
||
onTypeFormatting?: {
|
||
--Whether on type formatting supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/declaration`
|
||
declaration?: {
|
||
--Whether declaration supports dynamic registration. If this is set to `true`
|
||
--the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
|
||
--return value for the corresponding server capability as well.
|
||
dynamicRegistration?: boolean;
|
||
--The client supports additional metadata in the form of declaration links.
|
||
--
|
||
--Since 3.14.0
|
||
linkSupport?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/definition`.
|
||
--
|
||
--Since 3.14.0
|
||
definition?: {
|
||
--Whether definition supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
--The client supports additional metadata in the form of definition links.
|
||
linkSupport?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/typeDefinition`
|
||
--
|
||
--Since 3.6.0
|
||
typeDefinition?: {
|
||
--Whether typeDefinition supports dynamic registration. If this is set to `true`
|
||
--the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
|
||
--return value for the corresponding server capability as well.
|
||
dynamicRegistration?: boolean;
|
||
--The client supports additional metadata in the form of definition links.
|
||
--
|
||
--Since 3.14.0
|
||
linkSupport?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/implementation`.
|
||
--
|
||
--Since 3.6.0
|
||
implementation?: {
|
||
--Whether implementation supports dynamic registration. If this is set to `true`
|
||
--the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
|
||
--return value for the corresponding server capability as well.
|
||
dynamicRegistration?: boolean;
|
||
--The client supports additional metadata in the form of definition links.
|
||
--
|
||
--Since 3.14.0
|
||
linkSupport?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/codeAction`
|
||
codeAction?: {
|
||
--Whether code action supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
--The client support code action literals as a valid
|
||
--response of the `textDocument/codeAction` request.
|
||
--
|
||
--Since 3.8.0
|
||
codeActionLiteralSupport?: {
|
||
--The code action kind is support with the following value
|
||
--set.
|
||
codeActionKind: {
|
||
--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.
|
||
valueSet: CodeActionKind[];
|
||
};
|
||
};
|
||
};
|
||
--Capabilities specific to the `textDocument/codeLens`
|
||
codeLens?: {
|
||
--Whether code lens supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/documentLink`
|
||
documentLink?: {
|
||
--Whether document link supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--Capabilities specific to the `textDocument/documentColor` and the
|
||
--`textDocument/colorPresentation` request.
|
||
--
|
||
--Since 3.6.0
|
||
colorProvider?: {
|
||
--Whether colorProvider supports dynamic registration. If this is set to `true`
|
||
--the client supports the new `(ColorProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions)`
|
||
--return value for the corresponding server capability as well.
|
||
dynamicRegistration?: boolean;
|
||
}
|
||
--Capabilities specific to the `textDocument/rename`
|
||
rename?: {
|
||
--Whether rename supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
--The client supports testing for validity of rename operations
|
||
--before execution.
|
||
prepareSupport?: boolean;
|
||
};
|
||
--Capabilities specific to `textDocument/publishDiagnostics`.
|
||
publishDiagnostics?: {
|
||
--Whether the clients accepts diagnostics with related information.
|
||
relatedInformation?: boolean;
|
||
--Client supports the tag property to provide meta data about a diagnostic.
|
||
--Clients supporting tags have to handle unknown tags gracefully.
|
||
--Since 3.15.0
|
||
tagSupport?: {
|
||
--The tags supported by this client
|
||
valueSet: DiagnosticTag[];
|
||
};
|
||
};
|
||
--Capabilities specific to `textDocument/foldingRange` requests.
|
||
--
|
||
--Since 3.10.0
|
||
foldingRange?: {
|
||
--Whether implementation supports dynamic registration for folding range providers. If this is set to `true`
|
||
--the client supports the new `(FoldingRangeProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions)`
|
||
--return value for the corresponding server capability as well.
|
||
dynamicRegistration?: boolean;
|
||
--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.
|
||
rangeLimit?: number;
|
||
--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.
|
||
lineFoldingOnly?: boolean;
|
||
};
|
||
}
|
||
--]=]
|
||
|
||
--[=[
|
||
--Workspace specific client capabilities.
|
||
export interface WorkspaceClientCapabilities {
|
||
--The client supports applying batch edits to the workspace by supporting
|
||
--the request 'workspace/applyEdit'
|
||
applyEdit?: boolean;
|
||
--Capabilities specific to `WorkspaceEdit`s
|
||
workspaceEdit?: {
|
||
--The client supports versioned document changes in `WorkspaceEdit`s
|
||
documentChanges?: boolean;
|
||
--The resource operations the client supports. Clients should at least
|
||
--support 'create', 'rename' and 'delete' files and folders.
|
||
resourceOperations?: ResourceOperationKind[];
|
||
--The failure handling strategy of a client if applying the workspace edit
|
||
--fails.
|
||
failureHandling?: FailureHandlingKind;
|
||
};
|
||
--Capabilities specific to the `workspace/didChangeConfiguration` notification.
|
||
didChangeConfiguration?: {
|
||
--Did change configuration notification supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
|
||
didChangeWatchedFiles?: {
|
||
--Did change watched files notification supports dynamic registration. Please note
|
||
--that the current protocol doesn't support static configuration for file changes
|
||
--from the server side.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--Capabilities specific to the `workspace/symbol` request.
|
||
symbol?: {
|
||
--Symbol request supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
--Specific capabilities for the `SymbolKind` in the `workspace/symbol` request.
|
||
symbolKind?: {
|
||
--The symbol 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.
|
||
--
|
||
--If this property is not present the client only supports
|
||
--the symbol kinds from `File` to `Array` as defined in
|
||
--the initial version of the protocol.
|
||
valueSet?: SymbolKind[];
|
||
}
|
||
};
|
||
--Capabilities specific to the `workspace/executeCommand` request.
|
||
executeCommand?: {
|
||
--Execute command supports dynamic registration.
|
||
dynamicRegistration?: boolean;
|
||
};
|
||
--The client has support for workspace folders.
|
||
--
|
||
--Since 3.6.0
|
||
workspaceFolders?: boolean;
|
||
--The client supports `workspace/configuration` requests.
|
||
--
|
||
--Since 3.6.0
|
||
configuration?: boolean;
|
||
}
|
||
--]=]
|
||
|
||
--- Gets a new ClientCapabilities object describing the LSP client
|
||
--- capabilities.
|
||
function protocol.make_client_capabilities()
|
||
return {
|
||
textDocument = {
|
||
synchronization = {
|
||
dynamicRegistration = false;
|
||
|
||
-- TODO(ashkan) Send textDocument/willSave before saving (BufWritePre)
|
||
willSave = false;
|
||
|
||
-- TODO(ashkan) Implement textDocument/willSaveWaitUntil
|
||
willSaveWaitUntil = false;
|
||
|
||
-- Send textDocument/didSave after saving (BufWritePost)
|
||
didSave = true;
|
||
};
|
||
codeAction = {
|
||
dynamicRegistration = false;
|
||
|
||
codeActionLiteralSupport = {
|
||
codeActionKind = {
|
||
valueSet = (function()
|
||
local res = vim.tbl_values(protocol.CodeActionKind)
|
||
table.sort(res)
|
||
return res
|
||
end)();
|
||
};
|
||
};
|
||
};
|
||
completion = {
|
||
dynamicRegistration = false;
|
||
completionItem = {
|
||
-- Until we can actually expand snippet, move cursor and allow for true snippet experience,
|
||
-- this should be disabled out of the box.
|
||
-- However, users can turn this back on if they have a snippet plugin.
|
||
snippetSupport = false;
|
||
|
||
commitCharactersSupport = false;
|
||
preselectSupport = false;
|
||
deprecatedSupport = false;
|
||
documentationFormat = { protocol.MarkupKind.Markdown; protocol.MarkupKind.PlainText };
|
||
};
|
||
completionItemKind = {
|
||
valueSet = (function()
|
||
local res = {}
|
||
for k in ipairs(protocol.CompletionItemKind) do
|
||
if type(k) == 'number' then table.insert(res, k) end
|
||
end
|
||
return res
|
||
end)();
|
||
};
|
||
|
||
-- TODO(tjdevries): Implement this
|
||
contextSupport = false;
|
||
};
|
||
declaration = {
|
||
linkSupport = true;
|
||
};
|
||
definition = {
|
||
linkSupport = true;
|
||
};
|
||
implementation = {
|
||
linkSupport = true;
|
||
};
|
||
typeDefinition = {
|
||
linkSupport = true;
|
||
};
|
||
hover = {
|
||
dynamicRegistration = false;
|
||
contentFormat = { protocol.MarkupKind.Markdown; protocol.MarkupKind.PlainText };
|
||
};
|
||
signatureHelp = {
|
||
dynamicRegistration = false;
|
||
signatureInformation = {
|
||
activeParameterSupport = true;
|
||
documentationFormat = { protocol.MarkupKind.Markdown; protocol.MarkupKind.PlainText };
|
||
parameterInformation = {
|
||
labelOffsetSupport = true;
|
||
};
|
||
};
|
||
};
|
||
references = {
|
||
dynamicRegistration = false;
|
||
};
|
||
documentHighlight = {
|
||
dynamicRegistration = false
|
||
};
|
||
documentSymbol = {
|
||
dynamicRegistration = false;
|
||
symbolKind = {
|
||
valueSet = (function()
|
||
local res = {}
|
||
for k in ipairs(protocol.SymbolKind) do
|
||
if type(k) == 'number' then table.insert(res, k) end
|
||
end
|
||
return res
|
||
end)();
|
||
};
|
||
hierarchicalDocumentSymbolSupport = true;
|
||
};
|
||
rename = {
|
||
dynamicRegistration = false;
|
||
prepareSupport = true;
|
||
};
|
||
publishDiagnostics = {
|
||
relatedInformation = true;
|
||
tagSupport = {
|
||
valueSet = (function()
|
||
local res = {}
|
||
for k in ipairs(protocol.DiagnosticTag) do
|
||
if type(k) == 'number' then table.insert(res, k) end
|
||
end
|
||
return res
|
||
end)();
|
||
};
|
||
};
|
||
};
|
||
workspace = {
|
||
symbol = {
|
||
dynamicRegistration = false;
|
||
symbolKind = {
|
||
valueSet = (function()
|
||
local res = {}
|
||
for k in ipairs(protocol.SymbolKind) do
|
||
if type(k) == 'number' then table.insert(res, k) end
|
||
end
|
||
return res
|
||
end)();
|
||
};
|
||
hierarchicalWorkspaceSymbolSupport = true;
|
||
};
|
||
workspaceFolders = true;
|
||
applyEdit = true;
|
||
workspaceEdit = {
|
||
resourceOperations = {'rename', 'create', 'delete',},
|
||
};
|
||
};
|
||
callHierarchy = {
|
||
dynamicRegistration = false;
|
||
};
|
||
experimental = nil;
|
||
window = {
|
||
workDoneProgress = true;
|
||
showMessage = {
|
||
messageActionItem = {
|
||
additionalPropertiesSupport = false;
|
||
};
|
||
};
|
||
showDocument = {
|
||
support = false;
|
||
};
|
||
};
|
||
}
|
||
end
|
||
|
||
--[=[
|
||
export interface DocumentFilter {
|
||
--A language id, like `typescript`.
|
||
language?: string;
|
||
--A Uri [scheme](#Uri.scheme), like `file` or `untitled`.
|
||
scheme?: string;
|
||
--A glob pattern, like `*.{ts,js}`.
|
||
--
|
||
--Glob patterns can have the following syntax:
|
||
--- `*` to match one or more characters in a path segment
|
||
--- `?` to match on one character in a path segment
|
||
--- `**` to match any number of path segments, including none
|
||
--- `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
|
||
--- `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
|
||
--- `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
|
||
pattern?: string;
|
||
}
|
||
--]=]
|
||
|
||
--[[
|
||
--Static registration options to be returned in the initialize request.
|
||
interface StaticRegistrationOptions {
|
||
--The id used to register the request. The id can be used to deregister
|
||
--the request again. See also Registration#id.
|
||
id?: string;
|
||
}
|
||
|
||
export interface DocumentFilter {
|
||
--A language id, like `typescript`.
|
||
language?: string;
|
||
--A Uri [scheme](#Uri.scheme), like `file` or `untitled`.
|
||
scheme?: string;
|
||
--A glob pattern, like `*.{ts,js}`.
|
||
--
|
||
--Glob patterns can have the following syntax:
|
||
--- `*` to match one or more characters in a path segment
|
||
--- `?` to match on one character in a path segment
|
||
--- `**` to match any number of path segments, including none
|
||
--- `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
|
||
--- `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
|
||
--- `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
|
||
pattern?: string;
|
||
}
|
||
export type DocumentSelector = DocumentFilter[];
|
||
export interface TextDocumentRegistrationOptions {
|
||
--A document selector to identify the scope of the registration. If set to null
|
||
--the document selector provided on the client side will be used.
|
||
documentSelector: DocumentSelector | null;
|
||
}
|
||
|
||
--Code Action options.
|
||
export interface CodeActionOptions {
|
||
--CodeActionKinds that this server may return.
|
||
--
|
||
--The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server
|
||
--may list out every specific kind they provide.
|
||
codeActionKinds?: CodeActionKind[];
|
||
}
|
||
|
||
interface ServerCapabilities {
|
||
--Defines how text documents are synced. Is either a detailed structure defining each notification or
|
||
--for backwards compatibility the TextDocumentSyncKind number. If omitted it defaults to `TextDocumentSyncKind.None`.
|
||
textDocumentSync?: TextDocumentSyncOptions | number;
|
||
--The server provides hover support.
|
||
hoverProvider?: boolean;
|
||
--The server provides completion support.
|
||
completionProvider?: CompletionOptions;
|
||
--The server provides signature help support.
|
||
signatureHelpProvider?: SignatureHelpOptions;
|
||
--The server provides goto definition support.
|
||
definitionProvider?: boolean;
|
||
--The server provides Goto Type Definition support.
|
||
--
|
||
--Since 3.6.0
|
||
typeDefinitionProvider?: boolean | (TextDocumentRegistrationOptions & StaticRegistrationOptions);
|
||
--The server provides Goto Implementation support.
|
||
--
|
||
--Since 3.6.0
|
||
implementationProvider?: boolean | (TextDocumentRegistrationOptions & StaticRegistrationOptions);
|
||
--The server provides find references support.
|
||
referencesProvider?: boolean;
|
||
--The server provides document highlight support.
|
||
documentHighlightProvider?: boolean;
|
||
--The server provides document symbol support.
|
||
documentSymbolProvider?: boolean;
|
||
--The server provides workspace symbol support.
|
||
workspaceSymbolProvider?: boolean;
|
||
--The server provides code actions. The `CodeActionOptions` return type is only
|
||
--valid if the client signals code action literal support via the property
|
||
--`textDocument.codeAction.codeActionLiteralSupport`.
|
||
codeActionProvider?: boolean | CodeActionOptions;
|
||
--The server provides code lens.
|
||
codeLensProvider?: CodeLensOptions;
|
||
--The server provides document formatting.
|
||
documentFormattingProvider?: boolean;
|
||
--The server provides document range formatting.
|
||
documentRangeFormattingProvider?: boolean;
|
||
--The server provides document formatting on typing.
|
||
documentOnTypeFormattingProvider?: DocumentOnTypeFormattingOptions;
|
||
--The server provides rename support. RenameOptions may only be
|
||
--specified if the client states that it supports
|
||
--`prepareSupport` in its initial `initialize` request.
|
||
renameProvider?: boolean | RenameOptions;
|
||
--The server provides document link support.
|
||
documentLinkProvider?: DocumentLinkOptions;
|
||
--The server provides color provider support.
|
||
--
|
||
--Since 3.6.0
|
||
colorProvider?: boolean | ColorProviderOptions | (ColorProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions);
|
||
--The server provides folding provider support.
|
||
--
|
||
--Since 3.10.0
|
||
foldingRangeProvider?: boolean | FoldingRangeProviderOptions | (FoldingRangeProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions);
|
||
--The server provides go to declaration support.
|
||
--
|
||
--Since 3.14.0
|
||
declarationProvider?: boolean | (TextDocumentRegistrationOptions & StaticRegistrationOptions);
|
||
--The server provides execute command support.
|
||
executeCommandProvider?: ExecuteCommandOptions;
|
||
--Workspace specific server capabilities
|
||
workspace?: {
|
||
--The server supports workspace folder.
|
||
--
|
||
--Since 3.6.0
|
||
workspaceFolders?: {
|
||
* The server has support for workspace folders
|
||
supported?: boolean;
|
||
* Whether the server wants to receive workspace folder
|
||
* change notifications.
|
||
*
|
||
* If a strings is provided the string is treated as a ID
|
||
* under which the notification is registered on the client
|
||
* side. The ID can be used to unregister for these events
|
||
* using the `client/unregisterCapability` request.
|
||
changeNotifications?: string | boolean;
|
||
}
|
||
}
|
||
--Experimental server capabilities.
|
||
experimental?: any;
|
||
}
|
||
--]]
|
||
|
||
--- Creates a normalized object describing LSP server capabilities.
|
||
function protocol.resolve_capabilities(server_capabilities)
|
||
local general_properties = {}
|
||
local text_document_sync_properties
|
||
do
|
||
local TextDocumentSyncKind = protocol.TextDocumentSyncKind
|
||
local textDocumentSync = server_capabilities.textDocumentSync
|
||
if textDocumentSync == nil then
|
||
-- Defaults if omitted.
|
||
text_document_sync_properties = {
|
||
text_document_open_close = false;
|
||
text_document_did_change = TextDocumentSyncKind.None;
|
||
-- text_document_did_change = false;
|
||
text_document_will_save = false;
|
||
text_document_will_save_wait_until = false;
|
||
text_document_save = false;
|
||
text_document_save_include_text = false;
|
||
}
|
||
elseif type(textDocumentSync) == 'number' then
|
||
-- Backwards compatibility
|
||
if not TextDocumentSyncKind[textDocumentSync] then
|
||
return nil, "Invalid server TextDocumentSyncKind for textDocumentSync"
|
||
end
|
||
text_document_sync_properties = {
|
||
text_document_open_close = true;
|
||
text_document_did_change = textDocumentSync;
|
||
text_document_will_save = false;
|
||
text_document_will_save_wait_until = false;
|
||
text_document_save = true;
|
||
text_document_save_include_text = false;
|
||
}
|
||
elseif type(textDocumentSync) == 'table' then
|
||
text_document_sync_properties = {
|
||
text_document_open_close = if_nil(textDocumentSync.openClose, false);
|
||
text_document_did_change = if_nil(textDocumentSync.change, TextDocumentSyncKind.None);
|
||
text_document_will_save = if_nil(textDocumentSync.willSave, false);
|
||
text_document_will_save_wait_until = if_nil(textDocumentSync.willSaveWaitUntil, false);
|
||
text_document_save = if_nil(textDocumentSync.save, false);
|
||
text_document_save_include_text = if_nil(type(textDocumentSync.save) == 'table'
|
||
and textDocumentSync.save.includeText, false);
|
||
}
|
||
else
|
||
return nil, string.format("Invalid type for textDocumentSync: %q", type(textDocumentSync))
|
||
end
|
||
end
|
||
general_properties.completion = server_capabilities.completionProvider ~= nil
|
||
general_properties.hover = server_capabilities.hoverProvider or false
|
||
general_properties.goto_definition = server_capabilities.definitionProvider or false
|
||
general_properties.find_references = server_capabilities.referencesProvider or false
|
||
general_properties.document_highlight = server_capabilities.documentHighlightProvider or false
|
||
general_properties.document_symbol = server_capabilities.documentSymbolProvider or false
|
||
general_properties.workspace_symbol = server_capabilities.workspaceSymbolProvider or false
|
||
general_properties.document_formatting = server_capabilities.documentFormattingProvider or false
|
||
general_properties.document_range_formatting = server_capabilities.documentRangeFormattingProvider or false
|
||
general_properties.call_hierarchy = server_capabilities.callHierarchyProvider or false
|
||
general_properties.execute_command = server_capabilities.executeCommandProvider ~= nil
|
||
|
||
if server_capabilities.renameProvider == nil then
|
||
general_properties.rename = false
|
||
elseif type(server_capabilities.renameProvider) == 'boolean' then
|
||
general_properties.rename = server_capabilities.renameProvider
|
||
else
|
||
general_properties.rename = true
|
||
end
|
||
|
||
if server_capabilities.codeLensProvider == nil then
|
||
general_properties.code_lens = false
|
||
general_properties.code_lens_resolve = false
|
||
elseif type(server_capabilities.codeLensProvider) == 'table' then
|
||
general_properties.code_lens = true
|
||
general_properties.code_lens_resolve = server_capabilities.codeLensProvider.resolveProvider or false
|
||
else
|
||
error("The server sent invalid codeLensProvider")
|
||
end
|
||
|
||
if server_capabilities.codeActionProvider == nil then
|
||
general_properties.code_action = false
|
||
elseif type(server_capabilities.codeActionProvider) == 'boolean'
|
||
or type(server_capabilities.codeActionProvider) == 'table' then
|
||
general_properties.code_action = server_capabilities.codeActionProvider
|
||
else
|
||
error("The server sent invalid codeActionProvider")
|
||
end
|
||
|
||
if server_capabilities.declarationProvider == nil then
|
||
general_properties.declaration = false
|
||
elseif type(server_capabilities.declarationProvider) == 'boolean' then
|
||
general_properties.declaration = server_capabilities.declarationProvider
|
||
elseif type(server_capabilities.declarationProvider) == 'table' then
|
||
general_properties.declaration = server_capabilities.declarationProvider
|
||
else
|
||
error("The server sent invalid declarationProvider")
|
||
end
|
||
|
||
if server_capabilities.typeDefinitionProvider == nil then
|
||
general_properties.type_definition = false
|
||
elseif type(server_capabilities.typeDefinitionProvider) == 'boolean' then
|
||
general_properties.type_definition = server_capabilities.typeDefinitionProvider
|
||
elseif type(server_capabilities.typeDefinitionProvider) == 'table' then
|
||
general_properties.type_definition = server_capabilities.typeDefinitionProvider
|
||
else
|
||
error("The server sent invalid typeDefinitionProvider")
|
||
end
|
||
|
||
if server_capabilities.implementationProvider == nil then
|
||
general_properties.implementation = false
|
||
elseif type(server_capabilities.implementationProvider) == 'boolean' then
|
||
general_properties.implementation = server_capabilities.implementationProvider
|
||
elseif type(server_capabilities.implementationProvider) == 'table' then
|
||
general_properties.implementation = server_capabilities.implementationProvider
|
||
else
|
||
error("The server sent invalid implementationProvider")
|
||
end
|
||
|
||
local workspace = server_capabilities.workspace
|
||
local workspace_properties = {}
|
||
if workspace == nil or workspace.workspaceFolders == nil then
|
||
-- Defaults if omitted.
|
||
workspace_properties = {
|
||
workspace_folder_properties = {
|
||
supported = false;
|
||
changeNotifications=false;
|
||
}
|
||
}
|
||
elseif type(workspace.workspaceFolders) == 'table' then
|
||
workspace_properties = {
|
||
workspace_folder_properties = {
|
||
supported = if_nil(workspace.workspaceFolders.supported, false);
|
||
changeNotifications = if_nil(workspace.workspaceFolders.changeNotifications, false);
|
||
|
||
}
|
||
}
|
||
else
|
||
error("The server sent invalid workspace")
|
||
end
|
||
|
||
local signature_help_properties
|
||
if server_capabilities.signatureHelpProvider == nil then
|
||
signature_help_properties = {
|
||
signature_help = false;
|
||
signature_help_trigger_characters = {};
|
||
}
|
||
elseif type(server_capabilities.signatureHelpProvider) == 'table' then
|
||
signature_help_properties = {
|
||
signature_help = true;
|
||
-- The characters that trigger signature help automatically.
|
||
signature_help_trigger_characters = server_capabilities.signatureHelpProvider.triggerCharacters or {};
|
||
}
|
||
else
|
||
error("The server sent invalid signatureHelpProvider")
|
||
end
|
||
|
||
return vim.tbl_extend("error"
|
||
, text_document_sync_properties
|
||
, signature_help_properties
|
||
, workspace_properties
|
||
, general_properties
|
||
)
|
||
end
|
||
|
||
return protocol
|
||
-- vim:sw=2 ts=2 et
|