Language Server Protocol Spezifikation - 3.15
Dieses Dokument beschreibt die Version 3.15.x des Language Server Protocol. Eine Implementierung für Node der Version 3.15.x des Protokolls finden Sie hier.
Hinweis: Änderungen an dieser Spezifikation können über einen Pull Request gegen dieses Markdown- Dokument vorgenommen werden.
Was ist neu in 3.15
Alle neuen Funktionen von 3.15 sind mit dem entsprechenden Text „since version 3.15“ oder in JSDoc mit der Annotation @since 3.15.0 gekennzeichnet. Wichtige neue Funktionen sind
- allgemeine Fortschrittsunterstützung, Fortschritt der geleisteten Arbeit und Fortschritt teilweiser Ergebnisse
- Unterstützung für Auswahlbereiche
Basisprotokoll
Das Basisprotokoll besteht aus einem Header- und einem Inhaltsteil (vergleichbar mit HTTP). Der Header- und Inhaltsteil werden durch ein „\r\n“ getrennt.
Header-Teil
Der Header-Teil besteht aus Header-Feldern. Jedes Header-Feld besteht aus einem Namen und einem Wert, getrennt durch „: “ (ein Doppelpunkt und ein Leerzeichen). Die Struktur der Header-Felder entspricht dem HTTP-Standard. Jedes Header-Feld wird mit „\r\n“ abgeschlossen. Da das letzte Header-Feld und die gesamte Header-Sektion jeweils mit „\r\n“ abgeschlossen werden und mindestens ein Header obligatorisch ist, bedeutet dies, dass zwei „\r\n“-Sequenzen immer unmittelbar vor dem Inhaltsteil einer Nachricht stehen.
Aktuell werden folgende Header-Felder unterstützt
| Name des Header-Feldes | Wert-Typ | Beschreibung |
|---|---|---|
| Content-Length | number | Die Länge des Inhaltsteils in Bytes. Dieser Header ist erforderlich. |
| Content-Type | string | Der MIME-Typ des Inhaltsteils. Standardmäßig `application/vscode-jsonrpc; charset=utf-8` |
Der Header-Teil wird mit der ‚ascii‘-Kodierung codiert. Dies schließt die ‚\r\n‘, die den Header- und den Inhaltsteil trennen, mit ein.
Inhaltsteil
Enthält den eigentlichen Inhalt der Nachricht. Der Inhaltsteil einer Nachricht verwendet JSON-RPC, um Anfragen, Antworten und Benachrichtigungen zu beschreiben. Der Inhaltsteil wird mit dem im Feld `Content-Type` angegebenen Zeichensatz codiert. Er standardmäßig auf utf-8, was derzeit die einzige unterstützte Codierung ist. Wenn ein Server oder Client einen Header mit einer anderen Codierung als utf-8 empfängt, sollte er mit einem Fehler antworten.
(Frühere Versionen des Protokolls verwendeten die Zeichenkette utf8, was keine korrekte Codierungszeichenkette gemäß der Spezifikation ist.) Aus Gründen der Abwärtskompatibilität wird dringend empfohlen, dass ein Client und ein Server die Zeichenkette utf8 als utf-8 behandeln.
Beispiel
Content-Length: ...\r\n
\r\n
{
"jsonrpc": "2.0",
"id": 1,
"method": "textDocument/didOpen",
"params": {
...
}
}
Basisprotokoll JSON-Strukturen
Die folgenden TypeScript-Definitionen beschreiben das Basis JSON-RPC-Protokoll
Abstrakte Nachricht
Eine allgemeine Nachricht gemäß JSON-RPC. Das Language Server Protocol verwendet immer „2.0“ als jsonrpc-Version.
interface Message {
jsonrpc: string;
}
Anfrage-Nachricht
Eine Anfrage-Nachricht zur Beschreibung einer Anfrage zwischen Client und Server. Jede verarbeitete Anfrage muss eine Antwort an den Absender der Anfrage zurücksenden.
interface RequestMessage extends Message {
/**
* The request id.
*/
id: number | string;
/**
* The method to be invoked.
*/
method: string;
/**
* The method's params.
*/
params?: array | object;
}
Antwort-Nachricht
Eine Antwortnachricht, die als Ergebnis einer Anfrage gesendet wird. Wenn eine Anfrage keinen Ergebniswert liefert, muss der Empfänger einer Anfrage immer noch eine Antwortnachricht zurückgeben, um der JSON RPC-Spezifikation zu entsprechen. Die Ergebnis-Eigenschaft der Antwortnachricht sollte in diesem Fall auf null gesetzt werden, um eine erfolgreiche Anfrage zu signalisieren.
interface ResponseMessage extends Message {
/**
* The request id.
*/
id: number | string | null;
/**
* The result of a request. This member is REQUIRED on success.
* This member MUST NOT exist if there was an error invoking the method.
*/
result?: string | number | boolean | object | null;
/**
* The error object in case a request fails.
*/
error?: ResponseError;
}
interface ResponseError {
/**
* A number indicating the error type that occurred.
*/
code: number;
/**
* A string providing a short description of the error.
*/
message: string;
/**
* A primitive or structured value that contains additional
* information about the error. Can be omitted.
*/
data?: string | number | boolean | array | object | null;
}
export namespace ErrorCodes {
// Defined by JSON RPC
export const ParseError: number = -32700;
export const InvalidRequest: number = -32600;
export const MethodNotFound: number = -32601;
export const InvalidParams: number = -32602;
export const InternalError: number = -32603;
export const serverErrorStart: number = -32099;
export const serverErrorEnd: number = -32000;
export const ServerNotInitialized: number = -32002;
export const UnknownErrorCode: number = -32001;
// Defined by the protocol.
export const RequestCancelled: number = -32800;
export const ContentModified: number = -32801;
}
Benachrichtigungs-Nachricht
Eine Benachrichtigungs-Nachricht. Eine verarbeitete Benachrichtigungs-Nachricht darf keine Antwort zurücksenden. Sie funktionieren wie Ereignisse.
interface NotificationMessage extends Message {
/**
* The method to be invoked.
*/
method: string;
/**
* The notification's params.
*/
params?: array | object;
}
$ Benachrichtigungen und Anfragen
Benachrichtigungen und Anfragen, deren Methoden mit '$/' beginnen, sind nachrichten, die von der Protokollimplementierung abhängen und möglicherweise nicht in allen Clients oder Servern implementiert werden können. Wenn die Serverimplementierung beispielsweise eine einzelne, synchrone Programmiersprache verwendet, kann ein Server wenig tun, um auf eine '$/cancelRequest'-Benachrichtigung zu reagieren. Wenn ein Server oder Client Benachrichtigungen empfängt, die mit '$/' beginnen, kann er die Benachrichtigung ignorieren. Wenn ein Server oder Client eine Anfrage empfängt, die mit '$/' beginnt, muss er die Anfrage mit dem Fehlercode MethodNotFound (z. B. -32601) ablehnen.
Unterstützung für Abbruch (
)
Das Basisprotokoll bietet Unterstützung für den Abbruch von Anfragen. Um eine Anfrage abzubrechen, wird eine Benachrichtigungsnachricht mit den folgenden Eigenschaften gesendet
Benachrichtigung:
- Methode: ‚$/cancelRequest‘
- params:
CancelParams, wie folgt definiert
interface CancelParams {
/**
* The request id to cancel.
*/
id: number | string;
}
Eine abgebrochene Anfrage muss immer noch vom Server zurückgegeben und eine Antwort gesendet werden. Sie darf nicht offen / hängend bleiben. Dies steht im Einklang mit dem JSON RPC-Protokoll, das verlangt, dass jede Anfrage eine Antwort zurücksendet. Darüber hinaus ermöglicht es die Rückgabe von Teilergebnissen bei Abbruch. Wenn die Anfrage eine Fehlerantwort bei Abbruch zurückgibt, wird empfohlen, den Fehlercode auf ErrorCodes.RequestCancelled zu setzen.
Fortschrittsunterstützung ( )
Seit Version 3.15.0
Das Basisprotokoll bietet auch die Unterstützung zur allgemeinen Fortschrittsmeldung. Dieser Mechanismus kann verwendet werden, um jede Art von Fortschritt zu melden, einschließlich des Fortschritts der geleisteten Arbeit (wird normalerweise verwendet, um den Fortschritt in der Benutzeroberfläche mit einer Fortschrittsanzeige zu melden) und des Fortschritts teilweiser Ergebnisse zur Unterstützung des Streamings von Ergebnissen.
Eine Fortschrittsbenachrichtigung hat die folgenden Eigenschaften
Benachrichtigung:
- Methode: ‚$/progress‘
- params:
ProgressParams, wie folgt definiert
type ProgressToken = number | string;
interface ProgressParams<T> {
/**
* The progress token provided by the client or server.
*/
token: ProgressToken;
/**
* The progress data.
*/
value: T;
}
Der Fortschritt wird gegen ein Token gemeldet. Das Token unterscheidet sich von der Anfragedatenbank-ID, was es ermöglicht, Fortschritte "out of band" zu melden und auch für Benachrichtigungen.
Language Server Protocol
Das Language Server Protocol definiert eine Reihe von JSON-RPC-Anfrage-, Antwort- und Benachrichtigungsnachrichten, die über das obige Basisprotokoll ausgetauscht werden. Dieser Abschnitt beginnt mit der Beschreibung der grundlegenden JSON-Strukturen, die im Protokoll verwendet werden. Das Dokument verwendet TypeScript-Schnittstellen, um diese zu beschreiben. Basierend auf den grundlegenden JSON-Strukturen werden die tatsächlichen Anfragen mit ihren Antworten und die Benachrichtigungen beschrieben.
Im Allgemeinen unterstützt das Language Server Protocol JSON-RPC-Nachrichten, das hier definierte Basisprotokoll verwendet jedoch eine Konvention, dass die an Anfrage-/Benachrichtigungsnachrichten übergebenen Parameter vom Typ object sein sollten (sofern überhaupt übergeben). Dies schließt jedoch nicht die Verwendung von Array-Parametertypen in benutzerdefinierten Nachrichten aus.
Das Protokoll geht derzeit davon aus, dass ein Server ein Werkzeug bedient. Derzeit gibt es keine Unterstützung im Protokoll, um einen Server für verschiedene Werkzeuge freizugeben. Eine solche Freigabe würde ein zusätzliches Protokoll erfordern, z. B. um ein Dokument zu sperren und gleichzeitige Bearbeitungen zu unterstützen.
Grundlegende JSON-Strukturen
URI
URIs werden als Zeichenketten übertragen. Das URI-Format ist in http://tools.ietf.org/html/rfc3986 definiert.
foo://example.com:8042/over/there?name=ferret#nose
\_/ \______________/\_________/ \_________/ \__/
| | | | |
scheme authority path query fragment
| _____________________|__
/ \ / \
urn:example:animal:ferret:nose
Wir pflegen auch ein Node-Modul, um eine Zeichenkette in die URI-Komponenten scheme, authority, path, query und fragment zu zerlegen. Das GitHub-Repository ist https://github.com/Microsoft/vscode-uri das npm-Modul ist https://www.npmjs.com/package/vscode-uri.
Viele der Interfaces enthalten Felder, die der URI eines Dokuments entsprechen. Zur Verdeutlichung wird der Typ eines solchen Feldes als DocumentUri deklariert. Über das Netzwerk wird es weiterhin als Zeichenkette übertragen, aber dies garantiert, dass der Inhalt dieser Zeichenkette als gültige URI geparst werden kann.
type DocumentUri = string;
Textdokumente
Das aktuelle Protokoll ist auf Textdokumente zugeschnitten, deren Inhalt als Zeichenkette dargestellt werden kann. Es gibt derzeit keine Unterstützung für Binärdokumente. Eine Position innerhalb eines Dokuments (siehe Positionsdefinition unten) wird als nullbasierter Zeilen- und Zeichen-Offset ausgedrückt. Die Offsets basieren auf einer UTF-16-Zeichenkettenrepräsentation. In einer Zeichenkette der Form a𐐀b ist der Zeichen-Offset des Zeichens a 0, der Zeichen-Offset von 𐐀 ist 1 und der Zeichen-Offset von b ist 3, da 𐐀 in UTF-16 mit zwei Codeeinheiten dargestellt wird. Um sicherzustellen, dass sowohl Client als auch Server die Zeichenkette in dieselbe Zeilenrepräsentation aufteilen, legt das Protokoll die folgenden Zeilenende-Sequenzen fest: '\n', '\r\n' und '\r'.
Positionen sind zeilenendzeichen-agnostisch. Sie können also keine Position angeben, die \r|\n oder \n| angibt, wobei | den Zeichen-Offset darstellt.
export const EOL: string[] = ['\n', '\r\n', '\r'];
Position
Position in einem Textdokument, ausgedrückt als nullbasierte Zeile und nullbasierter Zeichen-Offset. Eine Position liegt zwischen zwei Zeichen, wie ein „Einfüge“-Cursor in einem Editor. Sonderwerte wie z. B. -1, um das Ende einer Zeile zu bezeichnen, werden nicht unterstützt.
interface Position {
/**
* Line position in a document (zero-based).
*/
line: number;
/**
* Character offset on a line in a document (zero-based). Assuming that the
* line is represented as a string, the `character` value represents the gap
* between the `character` and `character + 1`.
*
* If the character value is greater than the line length it defaults back
* to the line length.
*/
character: number;
}
Range
Ein Bereich in einem Textdokument, der als (nullbasierte) Start- und Endpositionen ausgedrückt wird. Ein Bereich ist vergleichbar mit einer Auswahl in einem Editor. Daher ist die Endposition exklusiv. Wenn Sie einen Bereich angeben möchten, der eine Zeile einschließlich der Zeilenende-Zeichen enthält, verwenden Sie eine Endposition, die den Anfang der nächsten Zeile angibt. Zum Beispiel
{
start: { line: 5, character: 23 },
end : { line: 6, character: 0 }
}
interface Range {
/**
* The range's start position.
*/
start: Position;
/**
* The range's end position.
*/
end: Position;
}
Location
Repräsentiert einen Ort innerhalb einer Ressource, z. B. eine Zeile in einer Textdatei.
interface Location {
uri: DocumentUri;
range: Range;
}
LocationLink
Repräsentiert einen Link zwischen einer Quell- und einer Zielposition.
interface LocationLink {
/**
* Span of the origin of this link.
*
* Used as the underlined span for mouse interaction.
* Defaults to the word range at the mouse position.
*/
originSelectionRange?: Range;
/**
* The target resource identifier of this link.
*/
targetUri: DocumentUri;
/**
* The full target range of this link.
* For example, if the target is a symbol, then target range is the range
* enclosing this symbol not including leading/trailing whitespace but
* everything else like comments.
* This information is typically used to highlight the range in the editor.
*/
targetRange: Range;
/**
* The range that should be selected and revealed when this link is being
* followed, for example, the name of a function.
* Must be contained by the `targetRange`.
* See also `DocumentSymbol#range`
*/
targetSelectionRange: Range;
}
Diagnostic
Repräsentiert eine Diagnose, wie z. B. einen Compilerfehler oder eine Warnung. Diagnoseobjekte sind nur im Gültigkeitsbereich einer Ressource gültig.
export interface Diagnostic {
/**
* The range at which the message applies.
*/
range: Range;
/**
* The diagnostic's severity. Can be omitted. If omitted it is up to the
* client to interpret diagnostics as error, warning, info or hint.
*/
severity?: DiagnosticSeverity;
/**
* The diagnostic's code, which might appear in the user interface.
*/
code?: number | string;
/**
* A human-readable string describing the source of this
* diagnostic, e.g. 'typescript' or 'super lint'.
*/
source?: string;
/**
* The diagnostic's message.
*/
message: string;
/**
* Additional metadata about the diagnostic.
*
* @since 3.15.0
*/
tags?: DiagnosticTag[];
/**
* An array of related diagnostic information, e.g. when symbol-names within
* a scope collide all definitions can be marked via this property.
*/
relatedInformation?: DiagnosticRelatedInformation[];
}
Das Protokoll unterstützt derzeit die folgenden Diagnose-Schweregrade und Tags
export namespace DiagnosticSeverity {
/**
* Reports an error.
*/
export const Error: 1 = 1;
/**
* Reports a warning.
*/
export const Warning: 2 = 2;
/**
* Reports an information.
*/
export const Information: 3 = 3;
/**
* Reports a hint.
*/
export const Hint: 4 = 4;
}
export type DiagnosticSeverity = 1 | 2 | 3 | 4;
/**
* The diagnostic tags.
*
* @since 3.15.0
*/
export namespace DiagnosticTag {
/**
* Unused or unnecessary code.
*
* Clients are allowed to render diagnostics with this tag faded out
* instead of having an error squiggle.
*/
export const Unnecessary: 1 = 1;
/**
* Deprecated or obsolete code.
*
* Clients are allowed to rendered diagnostics with this tag strike through.
*/
export const Deprecated: 2 = 2;
}
export type DiagnosticTag = 1 | 2;
DiagnosticRelatedInformation ist wie folgt definiert
/**
* Represents a related message and source code location for a diagnostic.
* This should be used to point to code locations that cause or are related
* to a diagnostics, for example, when duplicating a symbol in a scope.
*/
export interface DiagnosticRelatedInformation {
/**
* The location of this related diagnostic information.
*/
location: Location;
/**
* The message of this related diagnostic information.
*/
message: string;
}
Befehl
Repräsentiert einen Verweis auf einen Befehl. Bietet einen Titel, der zur Darstellung eines Befehls in der Benutzeroberfläche verwendet wird. Befehle werden durch eine Zeichenkettenkennung identifiziert. Der empfohlene Weg zur Handhabung von Befehlen ist die Implementierung ihrer Ausführung auf der Serverseite, wenn der Client und der Server die entsprechenden Capabilities bereitstellen. Alternativ könnte der Tool-Erweiterungscode den Befehl behandeln. Das Protokoll spezifiziert derzeit keine bekannten Befehle.
interface Command {
/**
* Title of the command, like `save`.
*/
title: string;
/**
* The identifier of the actual command handler.
*/
command: string;
/**
* Arguments that the command handler should be
* invoked with.
*/
arguments?: any[];
}
TextEdit
Eine Textbearbeitung, die auf ein Textdokument angewendet werden kann.
interface TextEdit {
/**
* The range of the text document to be manipulated. To insert
* text into a document create a range where start === end.
*/
range: Range;
/**
* The string to be inserted. For delete operations use an
* empty string.
*/
newText: string;
}
TextEdit[]
Komplexe Textmanipulationen werden mit einem Array von TextEdits beschrieben, die eine einzelne Änderung am Dokument darstellen.
Alle TextEdit-Bereiche beziehen sich auf Positionen im Dokument, auf dem sie berechnet werden. Sie bewegen ein Dokument also von Zustand S1 nach S2, ohne einen Zwischenzustand zu beschreiben. TextEdit-Bereiche dürfen sich niemals überlappen, d. h. kein Teil des ursprünglichen Dokuments darf von mehr als einem Edit bearbeitet werden. Es ist jedoch möglich, dass mehrere Edits dieselbe Startposition haben: mehrere Einfügungen oder beliebig viele Einfügungen gefolgt von einer einzigen Lösch- oder Ersetzungsbearbeitung. Wenn mehrere Einfügungen dieselbe Position haben, definiert die Reihenfolge im Array die Reihenfolge, in der die eingefügten Zeichenketten im resultierenden Text erscheinen.
TextDocumentEdit
Beschreibt textuelle Änderungen an einem einzelnen Textdokument. Das Textdokument wird als VersionedTextDocumentIdentifier bezeichnet, damit Clients die Textdokumentversion vor der Anwendung einer Bearbeitung überprüfen können. Ein TextDocumentEdit beschreibt alle Änderungen an einer Version Si, und nachdem sie angewendet wurden, wechselt das Dokument zur Version Si+1. Der Ersteller eines TextDocumentEdit muss das Array von Bearbeitungen nicht sortieren oder eine Art von Reihenfolge vornehmen. Die Bearbeitungen müssen jedoch nicht überlappend sein.
export interface TextDocumentEdit {
/**
* The text document to change.
*/
textDocument: VersionedTextDocumentIdentifier;
/**
* The edits to be applied.
*/
edits: TextEdit[];
}
File Resource changes
Neu in Version 3.13
Datei-Ressourcenänderungen erlauben es Servern, Dateien und Ordner über den Client zu erstellen, umzubenennen und zu löschen. Beachten Sie, dass die Namen sich auf Dateien beziehen, die Operationen jedoch auf Dateien und Ordner angewendet werden sollen. Dies entspricht der Namensgebung in anderen Teilen des Language Server Protocols (siehe File Watcher, die Dateien und Ordner beobachten können). Die entsprechenden Änderungs-Literale sehen wie folgt aus
/**
* Options to create a file.
*/
export interface CreateFileOptions {
/**
* Overwrite existing file. Overwrite wins over `ignoreIfExists`
*/
overwrite?: boolean;
/**
* Ignore if exists.
*/
ignoreIfExists?: boolean;
}
/**
* Create file operation
*/
export interface CreateFile {
/**
* A create
*/
kind: 'create';
/**
* The resource to create.
*/
uri: DocumentUri;
/**
* Additional options
*/
options?: CreateFileOptions;
}
/**
* Rename file options
*/
export interface RenameFileOptions {
/**
* Overwrite target if existing. Overwrite wins over `ignoreIfExists`
*/
overwrite?: boolean;
/**
* Ignores if target exists.
*/
ignoreIfExists?: boolean;
}
/**
* Rename file operation
*/
export interface RenameFile {
/**
* A rename
*/
kind: 'rename';
/**
* The old (existing) location.
*/
oldUri: DocumentUri;
/**
* The new location.
*/
newUri: DocumentUri;
/**
* Rename options.
*/
options?: RenameFileOptions;
}
/**
* Delete file options
*/
export interface DeleteFileOptions {
/**
* Delete the content recursively if a folder is denoted.
*/
recursive?: boolean;
/**
* Ignore the operation if the file doesn't exist.
*/
ignoreIfNotExists?: boolean;
}
/**
* Delete file operation
*/
export interface DeleteFile {
/**
* A delete
*/
kind: 'delete';
/**
* The file to delete.
*/
uri: DocumentUri;
/**
* Delete options.
*/
options?: DeleteFileOptions;
}
WorkspaceEdit
Eine Workspace-Bearbeitung repräsentiert Änderungen an vielen Ressourcen, die im Workspace verwaltet werden. Die Bearbeitung sollte entweder changes oder documentChanges bereitstellen. Wenn der Client versionierte Dokumentbearbeitungen verarbeiten kann und documentChanges vorhanden sind, werden letztere gegenüber changes bevorzugt.
export interface WorkspaceEdit {
/**
* Holds changes to existing resources.
*/
changes?: { [uri: DocumentUri]: TextEdit[]; };
/**
* The client capability `workspace.workspaceEdit.resourceOperations`
* determines whether document changes are either an array of
* `TextDocumentEdit`s to express changes to different text documents,
* where each text document edit addresses a specific version
* of a text document, or it can contains the above `TextDocumentEdit`s
* mixed with create, rename, and delete file / folder operations.
*
* Whether a client supports versioned document edits is expressed via
* `workspace.workspaceEdit.documentChanges` client capability.
*
* If a client doesn't support `documentChanges` or
* `workspace.workspaceEdit.resourceOperations`, then only plain
* `TextEdit`s using the `changes` property are supported.
*/
documentChanges?: (
TextDocumentEdit[] |
(TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[]
);
}
WorkspaceEditClientCapabilities
Neu in Version 3.13:
ResourceOperationKindundFailureHandlingKindsowie die Client-Capabilityworkspace.workspaceEdit.resourceOperationssowieworkspace.workspaceEdit.failureHandling.
Die Fähigkeiten eines Arbeitsbereich-Bearbeitungsereignisses haben sich im Laufe der Zeit entwickelt. Clients können ihre Unterstützung mit der folgenden Client-Fähigkeit beschreiben
- Eigenschaftspfad (optional):
workspace.workspaceEdit - Eigenschaftstyp:
WorkspaceEditClientCapabilities, wie folgt definiert
export interface WorkspaceEditClientCapabilities {
/**
* 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.
*
* @since 3.13.0
*/
resourceOperations?: ResourceOperationKind[];
/**
* The failure handling strategy of a client if applying the workspace edit
* fails.
*
* @since 3.13.0
*/
failureHandling?: FailureHandlingKind;
}
/**
* The kind of resource operations supported by the client.
*/
export type ResourceOperationKind = 'create' | 'rename' | 'delete';
export namespace ResourceOperationKind {
/**
* Supports creating new files and folders.
*/
export const Create: ResourceOperationKind = 'create';
/**
* Supports renaming existing files and folders.
*/
export const Rename: ResourceOperationKind = 'rename';
/**
* Supports deleting existing files and folders.
*/
export const Delete: ResourceOperationKind = 'delete';
}
export type FailureHandlingKind = 'abort' | 'transactional' | 'undo'
| 'textOnlyTransactional';
export namespace FailureHandlingKind {
/**
* Applying the workspace change is simply aborted if one of the changes
* provided fails.
* All operations executed before the failing operation stay executed.
*/
export const Abort: FailureHandlingKind = 'abort';
/**
* All operations are executed transactional. That means they either all
* succeed or no changes at all are applied to the workspace.
*/
export const Transactional: FailureHandlingKind = '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.
*/
export const TextOnlyTransactional: FailureHandlingKind
= 'textOnlyTransactional';
/**
* The client tries to undo the operations already executed. But there is no
* guarantee that this is succeeding.
*/
export const Undo: FailureHandlingKind = 'undo';
}
TextDocumentIdentifier
Textdokumente werden über eine URI identifiziert. Auf Protokollebene werden URIs als Zeichenketten übergeben. Die entsprechende JSON-Struktur sieht wie folgt aus
interface TextDocumentIdentifier {
/**
* The text document's URI.
*/
uri: DocumentUri;
}
TextDocumentItem
Ein Element zur Übertragung eines Textdokuments vom Client zum Server.
interface TextDocumentItem {
/**
* The text document's URI.
*/
uri: DocumentUri;
/**
* The text document's language identifier.
*/
languageId: string;
/**
* The version number of this document (it will increase after each
* change, including undo/redo).
*/
version: number;
/**
* The content of the opened text document.
*/
text: string;
}
Textdokumente haben eine Sprachkennung, um ein Dokument auf der Serverseite zu identifizieren, wenn es mehr als eine Sprache verarbeitet, um eine Neuinterpretation der Dateierweiterung zu vermeiden. Wenn ein Dokument auf eine der unten aufgeführten Programmiersprachen verweist, wird empfohlen, dass Clients diese IDs verwenden.
| Sprache | Bezeichner |
|---|---|
| ABAP | abap |
| Windows Bat | bat |
| BibTeX | bibtex |
| Clojure | clojure |
| Coffeescript | coffeescript |
| C | c |
| C++ | cpp |
| C# | csharp |
| CSS | css |
| Diff | diff |
| Dart | dart |
| Dockerfile | dockerfile |
| Elixir | elixir |
| Erlang | erlang |
| F# | fsharp |
| Git |
git-commit und git-rebase |
| Go | go |
| Groovy | groovy |
| Handlebars | handlebars |
| HTML | html |
| Ini | ini |
| Java | java |
| JavaScript | javascript |
| JavaScript React | javascriptreact |
| JSON | json |
| LaTeX | latex |
| Less | less |
| Lua | lua |
| Makefile | makefile |
| Markdown | markdown |
| Objective-C | objective-c |
| Objective-C++ | objective-cpp |
| Perl | perl |
| Perl 6 | perl6 |
| PHP | php |
| Powershell | powershell |
| Pug | jade |
| Python | python |
| R | r |
| Razor (cshtml) | razor |
| Ruby | ruby |
| Rust | rust |
| SCSS |
scss (Syntax mit geschweiften Klammern), sass (eingezogene Syntax) |
| Scala | scala |
| ShaderLab | shaderlab |
| Shell Script (Bash) | shellscript |
| SQL | sql |
| Swift | swift |
| TypeScript | typescript |
| TypeScript React | typescriptreact |
| TeX | tex |
| Visual Basic | vb |
| XML | xml |
| XSL | xsl |
| YAML | yaml |
VersionedTextDocumentIdentifier
Ein Identifikator zur Bezeichnung einer bestimmten Version eines Textdokuments.
interface VersionedTextDocumentIdentifier extends 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), the server can send `null` to
* indicate that the version is known and the content on disk is the
* master (as specified with document content ownership).
*
* The version number of a document will increase after each change,
* including undo/redo. The number doesn't need to be consecutive.
*/
version: number | null;
}
TextDocumentPositionParams
War in Version 1.0 TextDocumentPosition mit inline-Parametern.
Ein Parameter-Literal, das in Anfragen verwendet wird, um ein Textdokument und eine Position innerhalb dieses Dokuments zu übergeben.
interface TextDocumentPositionParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The position inside the text document.
*/
position: Position;
}
DocumentFilter
Ein Dokumentfilter bezeichnet ein Dokument anhand von Eigenschaften wie language, scheme oder pattern. Ein Beispiel ist ein Filter, der für TypeScript-Dateien auf der Festplatte gilt. Ein weiteres Beispiel ist ein Filter, der für JSON-Dateien mit dem Namen package.json gilt.
{ language: 'typescript', scheme: 'file' }
{ language: 'json', pattern: '**/package.json' }
export interface DocumentFilter {
/**
* A language id, like `typescript`.
*/
language?: string;
/**
* A 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;
}
Ein Dokumentselektor ist die Kombination aus einem oder mehreren Dokumentfiltern.
export type DocumentSelector = DocumentFilter[];
Statische Registrierungsoptionen
Statische Registrierungsoptionen können verwendet werden, um ein Feature im Initialisierungsergebnis mit einer gegebenen Server-Steuerungs-ID zu registrieren, um das Feature später abmelden zu können.
/**
* Static registration options to be returned in the initialize request.
*/
export 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;
}
Textdokument-Registrierungsoptionen
Optionen zur dynamischen Registrierung für Anfragen für eine Reihe von Textdokumenten.
/**
* General text document registration options.
*/
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;
}
MarkupContent
Ein MarkupContent-Literal repräsentiert einen Zeichenkettenwert, dessen Inhalt in verschiedenen Formaten dargestellt werden kann. Derzeit werden die Formate plaintext und markdown unterstützt. Ein MarkupContent wird normalerweise in Dokumentationseigenschaften von Ergebnis-Literalen wie CompletionItem oder SignatureInformation verwendet. Wenn das Format markdown ist, kann der Inhalt umgebende Codeblöcke enthalten, wie in GitHub-Problemen
/**
* 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.
*/
export namespace MarkupKind {
/**
* Plain text is supported as a content format
*/
export const PlainText: 'plaintext' = 'plaintext';
/**
* Markdown is supported as a content format
*/
export const Markdown: 'markdown' = 'markdown';
}
export type MarkupKind = 'plaintext' | 'markdown';
/**
* A `MarkupContent` literal represents a string value, which content is
* interpreted base on its kind flag.
* Currently the protocol supports `plaintext` and `markdown` as markup kinds.
*
* If the kind is `markdown`, then the value can contain fenced code blocks
* like in GitHub issues.
*
* An example how such a string is constructed using JavaScript / TypeScript:
* ```typescript
* let markdown: MarkdownContent = {
* kind: MarkupKind.Markdown,
* value: [
* '# Header',
* 'Some text',
* '```typescript',
* 'someCode();',
* '```'
* ].join('\n')
* };
* ```
*
* *Please Note* that clients might sanitize the returned Markdown.
* A client could decide to remove HTML from the Markdown to avoid
* script execution.
*/
export interface MarkupContent {
/**
* The type of the Markup
*/
kind: MarkupKind;
/**
* The content itself
*/
value: string;
}
Work Done Progress
Seit Version 3.15.0
Work Done Progress wird über die generische Benachrichtigung $/progress gemeldet. Der Wert-Payload einer Work Done Progress-Benachrichtigung kann drei verschiedene Formen haben.
Work Done Progress Begin
Um die Fortschrittsmeldung zu starten, muss eine $/progress-Benachrichtigung mit dem folgenden Payload gesendet werden
export interface WorkDoneProgressBegin {
kind: 'begin';
/**
* Mandatory title of the progress operation. Used to briefly inform about
* the kind of operation being performed.
*
* Examples: "Indexing" or "Linking dependencies".
*/
title: string;
/**
* Controls if a cancel button should show to allow the user to cancel the
* long running operation.
* Clients that don't support cancellation can ignore the setting.
*/
cancellable?: boolean;
/**
* Optional, more detailed associated progress message. Contains
* complementary information to the `title`.
*
* Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
* If unset, the previous progress message (if any) is still valid.
*/
message?: string;
/**
* Optional progress percentage to display (value 100 is considered 100%).
* 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.
*/
percentage?: number;
}
Work Done Progress Report
Die Fortschrittsmeldung erfolgt über den folgenden Payload
export interface WorkDoneProgressReport {
kind: 'report';
/**
* Controls enablement state of a cancel button. T
* This property is only valid if a cancel button is requested in
* the `WorkDoneProgressStart` payload.
*
* Clients that don't support cancellation or don't support controlling
* the button's enablement state are allowed to ignore the setting.
*/
cancellable?: boolean;
/**
* Optional, more detailed associated progress message. Contains
* complementary information to the `title`.
*
* Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
* If unset, the previous progress message (if any) is still valid.
*/
message?: string;
/**
* Optional progress percentage to display (value 100 is considered 100%).
* 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.
*/
percentage?: number;
}
Work Done Progress End
Das Ende der Fortschrittsmeldung wird über den folgenden Payload signalisiert
export interface WorkDoneProgressEnd {
kind: 'end';
/**
* Optional, a final message indicating to for example indicate the outcome
* of the operation.
*/
message?: string;
}
Initiierung von Work Done Progress
Work Done Progress kann auf zwei verschiedene Arten initiiert werden
- durch den Absender einer Anfrage (meist Clients) über die vordefinierte
workDoneToken-Eigenschaft im Parameter-Literal der Anfrage. Das Dokument wird diese Art von Fortschritt als vom Client initiierte Fortschrittsmeldung bezeichnen. - durch einen Server über die Anfrage
window/workDoneProgress/create. Das Dokument wird diese Art von Fortschritt als vom Server initiierte Fortschrittsmeldung bezeichnen.
Vom Client initiierter Fortschritt
Betrachten Sie einen Client, der eine textDocument/reference-Anfrage an einen Server sendet und der Client die Meldung von Work Done Progress für diese Anfrage akzeptiert. Um dies dem Server zu signalisieren, würde der Client eine workDoneToken-Eigenschaft zu den Parameter des Referenz-Anfrage hinzufügen. Etwas wie dies
{
"textDocument": {
"uri": "file:///folder/file.ts"
},
"position": {
"line": 9,
"character": 5
},
"context": {
"includeDeclaration": true
},
// The token used to report work done progress.
"workDoneToken": "1d546990-40a3-4b77-b134-46622995f6ae"
}
Die entsprechende Typdefinition für die Parameter-Eigenschaft sieht wie folgt aus
export interface WorkDoneProgressParams {
/**
* An optional token that a server can use to report work done progress.
*/
workDoneToken?: ProgressToken;
}
Ein Server verwendet das workDoneToken, um Fortschritte für die spezifische textDocument/reference zu melden. Für die obige Anfrage sieht der $/progress-Benachrichtigungs-Payload wie folgt aus
{
"token": "1d546990-40a3-4b77-b134-46622995f6ae",
"value": {
"kind": "begin",
"title": "Finding references for A#foo",
"cancellable": false,
"message": "Processing file X.ts",
"percentage": 0
}
}
Es gibt keine spezifische Client-Capability, die signalisiert, ob ein Client ein Fortschrittstoken pro Anfrage sendet. Der Grund dafür ist, dass dies bei vielen Clients kein statischer Aspekt ist und sich sogar für jede Anfrageinstanz desselben Anfragetyps ändern kann. Daher wird die Capability bei jeder Anfrageinstanz durch das Vorhandensein einer workDoneToken-Eigenschaft signalisiert.
Um zu vermeiden, dass Clients eine Fortschrittsüberwachungs-Benutzeroberfläche einrichten, bevor sie eine Anfrage senden, der Server aber tatsächlich keinen Fortschritt meldet, muss ein Server die allgemeine Unterstützung für die Fortschrittsmeldung von Arbeit in den entsprechenden Serverfähigkeiten signalisieren. Für das obige Beispiel des Auffindens von Referenzen würde ein Server eine solche Unterstützung signalisieren, indem er die Eigenschaft referencesProvider in den Serverfähigkeiten wie folgt setzt
{
"referencesProvider": {
"workDoneProgress": true
}
}
Die entsprechende Typdefinition für die Serverfähigkeit sieht wie folgt aus
export interface WorkDoneProgressOptions {
workDoneProgress?: boolean;
}
Vom Server initiierter Fortschritt
Server können auch die Fortschrittsmeldung über die Anfrage window/workDoneProgress/create initiieren. Dies ist nützlich, wenn der Server den Fortschritt außerhalb einer Anfrage melden muss (z. B. wenn der Server eine Datenbank neu indizieren muss). Das zurückgegebene Token kann dann verwendet werden, um den Fortschritt mit denselben Benachrichtigungen zu melden, die auch für clientinitiierte Fortschritte verwendet werden.
Um das Protokoll abwärtskompatibel zu halten, dürfen Server die window/workDoneProgress/create-Anfrage nur verwenden, wenn der Client die entsprechende Unterstützung über die Clientfähigkeit window.workDoneProgress signalisiert, die wie folgt definiert ist
/**
* Window specific client capabilities.
*/
window?: {
/**
* Whether client supports server initiated progress using the
* `window/workDoneProgress/create` request.
*/
workDoneProgress?: boolean;
}
Teilergebnis-Fortschritt
Seit Version 3.15.0
Teilergebnisse werden ebenfalls über die allgemeine $/progress-Benachrichtigung gemeldet. Die Wertnutzlast einer teilweisen Ergebnisbenachrichtigung ist in den meisten Fällen dieselbe wie das Endergebnis. Zum Beispiel hat die Anfrage workspace/symbol SymbolInformation[] als Ergebnistyp. Das Teilergebnis ist daher ebenfalls vom Typ SymbolInformation[]. Ob ein Client Benachrichtigungen über Teilergebnisse für eine Anfrage akzeptiert, wird signalisiert, indem ein partialResultToken zu den Anfrageparametern hinzugefügt wird. Zum Beispiel könnte eine Anfrage textDocument/reference, die sowohl Arbeit geleistet als auch Teilergebnisse unterstützt, wie folgt aussehen
{
"textDocument": {
"uri": "file:///folder/file.ts"
},
"position": {
"line": 9,
"character": 5
},
"context": {
"includeDeclaration": true
},
// The token used to report work done progress.
"workDoneToken": "1d546990-40a3-4b77-b134-46622995f6ae",
// The token used to report partial result progress.
"partialResultToken": "5f6f349e-4f81-4a3b-afff-ee04bff96804"
}
Der partialResultToken wird dann verwendet, um Teilergebnisse für die Suche nach Referenzen zu melden.
Wenn ein Server Teilergebnisse über ein entsprechendes $/progress meldet, muss das gesamte Ergebnis über n $/progress-Benachrichtigungen gemeldet werden. Die endgültige Antwort muss in Bezug auf die Ergebniswerte leer sein. Dies vermeidet Verwirrung darüber, wie das Endergebnis interpretiert werden soll, z. B. als weiteres Teilergebnis oder als ersetzendes Ergebnis.
Wenn die Antwort fehlerhaft ist, sollten die bereitgestellten Teilergebnisse wie folgt behandelt werden
- Der
codeist gleichRequestCancelled: Der Client ist frei, die bereitgestellten Ergebnisse zu verwenden, sollte aber klarstellen, dass die Anfrage abgebrochen wurde und möglicherweise unvollständig ist. - In allen anderen Fällen sollten die bereitgestellten Teilergebnisse nicht verwendet werden.
PartialResultParams
Ein Parameter-Literal, das verwendet wird, um einen Teilergebnis-Token zu übergeben.
export interface PartialResultParams {
/**
* An optional token that a server can use to report partial results
* (for example, streaming) to the client.
*/
partialResultToken?: ProgressToken;
}
Tatsächliches Protokoll
Dieser Abschnitt dokumentiert das tatsächliche Language Server Protocol. Er verwendet das folgende Format
- Eine Kopfzeile, die die Anfrage beschreibt
- Ein optionaler Abschnitt *Client-Fähigkeit*, der die Client-Fähigkeit der Anfrage beschreibt. Dies beinhaltet den Pfad der Client-Fähigkeitseigenschaft und die JSON-Struktur.
- ein optionaler Abschnitt Server Capability, der die Serverfähigkeit der Anfrage beschreibt. Dies umfasst den Pfad der Serverfähigkeiten-Eigenschaft und die JSON-Struktur.
- Ein Abschnitt *Anfrage*, der das Format der gesendeten Anfrage beschreibt. Die Methode ist eine Zeichenkette, die die Anfrage identifiziert, die Parameter werden mit einer TypeScript-Schnittstelle dokumentiert. Es wird auch dokumentiert, ob die Anfrage Work Done-Fortschritt und Partial Result-Fortschritt unterstützt.
- Ein Abschnitt *Antwort*, der das Format der Antwort beschreibt. Das Ergebnis-Element beschreibt die zurückgegebenen Daten im Erfolgsfall. Das optionale Teilergebnis-Element beschreibt die zurückgegebenen Daten einer Teilergebnis-Benachrichtigung. Die error.data beschreibt die zurückgegebenen Daten im Fehlerfall. Bitte denken Sie daran, dass die Antwort im Fehlerfall bereits ein error.code und ein error.message Feld enthält. Diese Felder werden nur angegeben, wenn das Protokoll die Verwendung bestimmter Fehlercodes oder Nachrichten erzwingt. In Fällen, in denen der Server diese Werte frei wählen kann, werden sie hier nicht aufgeführt.
- ein Abschnitt Registration Options, der die Registrierungsoption beschreibt, wenn die Anfrage oder Benachrichtigung dynamische Fähigkeitsregistrierung unterstützt.
Reihenfolge von Anfragen, Benachrichtigungen und Antworten
Antworten auf Anfragen sollten ungefähr in der gleichen Reihenfolge gesendet werden, in der die Anfragen auf der Server- oder Clientseite erscheinen. Wenn also ein Server beispielsweise eine textDocument/completion-Anfrage und dann eine textDocument/signatureHelp-Anfrage empfängt, wird er normalerweise zuerst die Antwort für textDocument/completion und dann die Antwort für textDocument/signatureHelp zurückgeben.
Der Server kann jedoch entscheiden, eine parallele Ausführungsstrategie zu verwenden und Antworten in einer anderen Reihenfolge als die empfangenen Anfragen zurückzugeben. Der Server kann dies tun, solange diese Neuanordnung die Korrektheit der Antworten nicht beeinträchtigt. Zum Beispiel ist die Neuanordnung der Ergebnisse von textDocument/completion und textDocument/signatureHelp zulässig, da jede dieser Anfragen normalerweise die Ausgabe der anderen nicht beeinflusst. Auf der anderen Seite sollte der Server wahrscheinlich keine textDocument/definition- und textDocument/rename-Anfragen neu ordnen, da die Ausführung der letzteren das Ergebnis der ersteren beeinflussen kann.
Serverlebensdauer
Die aktuelle Protokollspezifikation besagt, dass die Lebensdauer eines Servers vom Client verwaltet wird (z. B. ein Tool wie VS Code oder Emacs). Es liegt am Client zu entscheiden, wann ein Server gestartet (prozessbezogen) und wann er heruntergefahren werden soll.
Initialize-Anfrage (
)
Die initialize-Anfrage wird als erste Anfrage vom Client an den Server gesendet. Wenn der Server vor der initialize-Anfrage eine Anfrage oder Benachrichtigung empfängt, sollte er wie folgt vorgehen
- Bei einer Anfrage sollte die Antwort ein Fehler mit
code: -32002sein. Die Nachricht kann vom Server gewählt werden. - Benachrichtigungen sollten verworfen werden, mit Ausnahme der exit-Benachrichtigung. Dies ermöglicht das Beenden eines Servers ohne eine initialize-Anfrage.
Bis der Server auf die initialize-Anfrage mit einem InitializeResult geantwortet hat, darf der Client keine zusätzlichen Anfragen oder Benachrichtigungen an den Server senden. Zusätzlich darf der Server keine Anfragen oder Benachrichtigungen an den Client senden, bis er mit einem InitializeResult geantwortet hat, mit Ausnahme, dass während der initialize-Anfrage der Server die Benachrichtigungen window/showMessage, window/logMessage und telemetry/event sowie die Anfrage window/showMessageRequest an den Client senden darf. Wenn der Client einen Fortschritts-Token in den Initialisierungsparametern setzt (z. B. die Eigenschaft workDoneToken), darf der Server diesen Token (und nur diesen Token) über die $/progress-Benachrichtigung vom Server an den Client verwenden.
Die initialize-Anfrage darf nur einmal gesendet werden.
Anfrage:
- method: ‘initialize’
- params:
InitializeParams, wie folgt definiert
interface InitializeParams extends WorkDoneProgressParams {
/**
* 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
* (see exit notification) its process.
*/
processId: number | null;
/**
* Information about the client
*
* @since 3.15.0
*/
clientInfo?: {
/**
* The name of the client as defined by the client.
*/
name: string;
/**
* The client's version as defined by the client.
*/
version?: string;
};
/**
* The rootPath of the workspace. Is null
* if no folder is open.
*
* @deprecated in favour of rootUri.
*/
rootPath?: string | null;
/**
* The rootUri of the workspace. Is null if no
* folder is open. If both `rootPath` and `rootUri` are set
* `rootUri` wins.
*/
rootUri: DocumentUri | null;
/**
* User provided initialization options.
*/
initializationOptions?: any;
/**
* The capabilities provided by the client (editor or tool)
*/
capabilities: ClientCapabilities;
/**
* The initial trace setting. If omitted trace is disabled ('off').
*/
trace?: 'off' | 'messages' | 'verbose';
/**
* The workspace folders configured in the client when the server starts.
* This property is only available if the client supports workspace folders.
* It can be `null` if the client supports workspace folders but none are
* configured.
*
* @since 3.6.0
*/
workspaceFolders?: WorkspaceFolder[] | null;
}
Dabei sind ClientCapabilities und TextDocumentClientCapabilities wie folgt definiert
TextDocumentClientCapabilities definieren die Fähigkeiten, die der Editor/das Tool für Textdokumente bietet.
/**
* Text document specific client capabilities.
*/
export interface TextDocumentClientCapabilities {
synchronization?: TextDocumentSyncClientCapabilities;
/**
* Capabilities specific to the `textDocument/completion` request.
*/
completion?: CompletionClientCapabilities;
/**
* Capabilities specific to the `textDocument/hover` request.
*/
hover?: HoverClientCapabilities;
/**
* Capabilities specific to the `textDocument/signatureHelp` request.
*/
signatureHelp?: SignatureHelpClientCapabilities;
/**
* Capabilities specific to the `textDocument/declaration` request.
*
* @since 3.14.0
*/
declaration?: DeclarationClientCapabilities;
/**
* Capabilities specific to the `textDocument/definition` request.
*/
definition?: DefinitionClientCapabilities;
/**
* Capabilities specific to the `textDocument/typeDefinition` request.
*
* @since 3.6.0
*/
typeDefinition?: TypeDefinitionClientCapabilities;
/**
* Capabilities specific to the `textDocument/implementation` request.
*
* @since 3.6.0
*/
implementation?: ImplementationClientCapabilities;
/**
* Capabilities specific to the `textDocument/references` request.
*/
references?: ReferenceClientCapabilities;
/**
* Capabilities specific to the `textDocument/documentHighlight` request.
*/
documentHighlight?: DocumentHighlightClientCapabilities;
/**
* Capabilities specific to the `textDocument/documentSymbol` request.
*/
documentSymbol?: DocumentSymbolClientCapabilities;
/**
* Capabilities specific to the `textDocument/codeAction` request.
*/
codeAction?: CodeActionClientCapabilities;
/**
* Capabilities specific to the `textDocument/codeLens` request.
*/
codeLens?: CodeLensClientCapabilities;
/**
* Capabilities specific to the `textDocument/documentLink` request.
*/
documentLink?: DocumentLinkClientCapabilities;
/**
* Capabilities specific to the `textDocument/documentColor` and the
* `textDocument/colorPresentation` request.
*
* @since 3.6.0
*/
colorProvider?: DocumentColorClientCapabilities;
/**
* Capabilities specific to the `textDocument/formatting` request.
*/
formatting?: DocumentFormattingClientCapabilities
/**
* Capabilities specific to the `textDocument/rangeFormatting` request.
*/
rangeFormatting?: DocumentRangeFormattingClientCapabilities;
/** request.
* Capabilities specific to the `textDocument/onTypeFormatting` request.
*/
onTypeFormatting?: DocumentOnTypeFormattingClientCapabilities;
/**
* Capabilities specific to the `textDocument/rename` request.
*/
rename?: RenameClientCapabilities;
/**
* Capabilities specific to the `textDocument/publishDiagnostics`
* notification.
*/
publishDiagnostics?: PublishDiagnosticsClientCapabilities;
/**
* Capabilities specific to the `textDocument/foldingRange` request.
*
* @since 3.10.0
*/
foldingRange?: FoldingRangeClientCapabilities;
/**
* Capabilities specific to the `textDocument/selectionRange` request.
*
* @since 3.15.0
*/
selectionRange?: SelectionRangeClientCapabilities;
}
ClientCapabilities definieren die Fähigkeiten für dynamische Registrierung, Workspace- und Textdokument-Features, die der Client unterstützt. Das experimental kann verwendet werden, um experimentelle, in Entwicklung befindliche Fähigkeiten zu übergeben. Für zukünftige Kompatibilität kann ein ClientCapabilities-Objektliteral mehr Eigenschaften aufweisen als derzeit definiert. Server, die ein ClientCapabilities-Objektliteral mit unbekannten Eigenschaften erhalten, sollten diese Eigenschaften ignorieren. Eine fehlende Eigenschaft sollte als Abwesenheit der Fähigkeit interpretiert werden. Wenn eine fehlende Eigenschaft normalerweise Untereigenschaften definiert, sollten alle fehlenden Untereigenschaften als Abwesenheit der entsprechenden Fähigkeit interpretiert werden.
Client-Fähigkeiten wurden mit Version 3.0 des Protokolls eingeführt. Sie beschreiben daher nur Fähigkeiten, die in 3.x oder später eingeführt wurden. Fähigkeiten, die bereits in Version 2.x des Protokolls vorhanden waren, sind für Clients weiterhin obligatorisch. Clients können sich nicht von der Bereitstellung dieser Fähigkeiten abmelden. Selbst wenn ein Client ClientCapabilities.textDocument.synchronization weglässt, ist der Client immer noch verpflichtet, Textsynchronisierungsfunktionen (z. B. open-, changed- und close-Benachrichtigungen) bereitzustellen.
interface ClientCapabilities {
/**
* Workspace specific client capabilities.
*/
workspace?: {
/**
* The client supports applying batch edits
* to the workspace by supporting the request
* 'workspace/applyEdit'
*/
applyEdit?: boolean;
/**
* Capabilities specific to `WorkspaceEdit`s
*/
workspaceEdit?: WorkspaceEditClientCapabilities;
/**
* Capabilities specific to the `workspace/didChangeConfiguration`
* notification.
*/
didChangeConfiguration?: DidChangeConfigurationClientCapabilities;
/**
* Capabilities specific to the `workspace/didChangeWatchedFiles`
* notification.
*/
didChangeWatchedFiles?: DidChangeWatchedFilesClientCapabilities;
/**
* Capabilities specific to the `workspace/symbol` request.
*/
symbol?: WorkspaceSymbolClientCapabilities;
/**
* Capabilities specific to the `workspace/executeCommand` request.
*/
executeCommand?: ExecuteCommandClientCapabilities;
/**
* 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;
};
/**
* Text document specific client capabilities.
*/
textDocument?: TextDocumentClientCapabilities;
/**
* Window specific client capabilities.
*/
window?: {
/**
* Whether client supports handling progress notifications.
* If set, servers are allowed to report in `workDoneProgress` property
* in the request specific server capabilities.
*
* Since 3.15.0
*/
workDoneProgress?: boolean;
}
/**
* Experimental client capabilities.
*/
experimental?: any;
}
Antwort:
- result:
InitializeResult, wie folgt definiert
interface InitializeResult {
/**
* The capabilities the language server provides.
*/
capabilities: ServerCapabilities;
/**
* Information about the server.
*
* @since 3.15.0
*/
serverInfo?: {
/**
* The name of the server as defined by the server.
*/
name: string;
/**
* The server's version as defined by the server.
*/
version?: string;
};
}
- error.code
/**
* Known error codes for an `InitializeError`;
*/
export namespace InitializeError {
/**
* If the protocol version provided by the client can't be handled by
* the server.
* @deprecated This initialize error was replaced by client capabilities.
* There is no version handshake in version 3.0x
*/
export const unknownProtocolVersion: number = 1;
}
- error.data
interface InitializeError {
/**
* Indicates whether the client execute the following retry logic:
* (1) show the message provided by the ResponseError to the user
* (2) user selects retry or cancel
* (3) if user selected retry the initialize method is sent again.
*/
retry: boolean;
}
Der Server kann folgende Fähigkeiten signalisieren
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 completion support.
*/
completionProvider?: CompletionOptions;
/**
* The server provides hover support.
*/
hoverProvider?: boolean | HoverOptions;
/**
* The server provides signature help support.
*/
signatureHelpProvider?: SignatureHelpOptions;
/**
* The server provides go to declaration support.
*
* @since 3.14.0
*/
declarationProvider?: boolean | DeclarationOptions
| DeclarationRegistrationOptions;
/**
* The server provides goto definition support.
*/
definitionProvider?: boolean | DefinitionOptions;
/**
* The server provides goto type definition support.
*
* @since 3.6.0
*/
typeDefinitionProvider?: boolean | TypeDefinitionOptions
| TypeDefinitionRegistrationOptions;
/**
* The server provides goto implementation support.
*
* @since 3.6.0
*/
implementationProvider?: boolean | ImplementationOptions
| ImplementationRegistrationOptions;
/**
* The server provides find references support.
*/
referencesProvider?: boolean | ReferenceOptions;
/**
* The server provides document highlight support.
*/
documentHighlightProvider?: boolean | DocumentHighlightOptions;
/**
* The server provides document symbol support.
*/
documentSymbolProvider?: boolean | DocumentSymbolOptions;
/**
* 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 CodeLens.
*/
codeLensProvider?: CodeLensOptions;
/**
* The server provides document link support.
*/
documentLinkProvider?: DocumentLinkOptions;
/**
* The server provides color provider support.
*
* @since 3.6.0
*/
colorProvider?: boolean | DocumentColorOptions
| DocumentColorRegistrationOptions;
/**
* The server provides document formatting.
*/
documentFormattingProvider?: boolean | DocumentFormattingOptions;
/**
* The server provides document range formatting.
*/
documentRangeFormattingProvider?: boolean | DocumentRangeFormattingOptions;
/**
* 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 folding provider support.
*
* @since 3.10.0
*/
foldingRangeProvider?: boolean | FoldingRangeOptions
| FoldingRangeRegistrationOptions;
/**
* The server provides execute command support.
*/
executeCommandProvider?: ExecuteCommandOptions;
/**
* The server provides selection range support.
*
* @since 3.15.0
*/
selectionRangeProvider?: boolean | SelectionRangeOptions
| SelectionRangeRegistrationOptions;
/**
* The server provides workspace symbol support.
*/
workspaceSymbolProvider?: boolean | WorkspaceSymbolOptions;
/**
* Workspace specific server capabilities
*/
workspace?: {
/**
* The server supports workspace folder.
*
* @since 3.6.0
*/
workspaceFolders?: WorkspaceFoldersServerCapabilities;
}
/**
* Experimental server capabilities.
*/
experimental?: any;
}
Initialized-Benachrichtigung ()
Die initialized-Benachrichtigung wird vom Client an den Server gesendet, nachdem der Client das Ergebnis der initialize-Anfrage erhalten hat, aber bevor der Client andere Anfragen oder Benachrichtigungen an den Server sendet. Der Server kann die initialized-Benachrichtigung beispielsweise verwenden, um dynamisch Fähigkeiten zu registrieren. Die initialized-Benachrichtigung darf nur einmal gesendet werden.
Benachrichtigung:
- method: ‘initialized’
- params:
InitializedParams, wie folgt definiert
interface InitializedParams {
}
Shutdown-Anfrage ()
Die shutdown-Anfrage wird vom Client an den Server gesendet. Sie fordert den Server auf, herunterzufahren, aber nicht zu beenden (andernfalls wird die Antwort möglicherweise nicht korrekt an den Client geliefert). Es gibt eine separate exit-Benachrichtigung, die den Server auffordert, zu beenden. Clients dürfen keine anderen Benachrichtigungen als exit oder Anfragen an einen Server senden, an den sie eine shutdown-Anfrage gesendet haben. Wenn ein Server nach einer shutdown-Anfrage Anfragen empfängt, sollten diese mit InvalidRequest abgelehnt werden.
Anfrage:
- method: ‘shutdown’
- params: void
Antwort:
- result: null
- error: code und message werden gesetzt, wenn während der shutdown-Anfrage ein Fehler auftritt.
Exit-Benachrichtigung ()
Eine Benachrichtigung, die den Server auffordert, seinen Prozess zu beenden. Der Server sollte mit dem Erfolgs-Code 0 beenden, wenn die shutdown-Anfrage zuvor empfangen wurde; andernfalls mit dem Fehler-Code 1.
Benachrichtigung:
- method: ‘exit’
- params: void
ShowMessage-Benachrichtigung ()
Die show message-Benachrichtigung wird von einem Server an einen Client gesendet, um den Client aufzufordern, eine bestimmte Nachricht in der Benutzeroberfläche anzuzeigen.
Benachrichtigung:
- method: ‘window/showMessage’
- params:
ShowMessageParams, wie folgt definiert
interface ShowMessageParams {
/**
* The message type. See {@link MessageType}.
*/
type: number;
/**
* The actual message.
*/
message: string;
}
Dabei ist der Typ wie folgt definiert
export namespace MessageType {
/**
* An error message.
*/
export const Error = 1;
/**
* A warning message.
*/
export const Warning = 2;
/**
* An information message.
*/
export const Info = 3;
/**
* A log message.
*/
export const Log = 4;
}
ShowMessage-Anfrage (
)
Die show message request-Anfrage wird von einem Server an einen Client gesendet, um den Client aufzufordern, eine bestimmte Nachricht in der Benutzeroberfläche anzuzeigen. Neben der show message-Benachrichtigung ermöglicht die Anfrage, Aktionen zu übergeben und auf eine Antwort vom Client zu warten.
Anfrage:
- method: ‘window/showMessageRequest’
- params:
ShowMessageRequestParams, wie folgt definiert
Antwort:
- result: das ausgewählte
MessageActionItem|null, wenn keines ausgewählt wurde. - error: code und message werden gesetzt, wenn während der Anzeige einer Nachricht ein Fehler auftritt.
interface ShowMessageRequestParams {
/**
* The message type. See {@link MessageType}
*/
type: number;
/**
* The actual message
*/
message: string;
/**
* The message action items to present.
*/
actions?: MessageActionItem[];
}
Dabei ist das MessageActionItem wie folgt definiert
interface MessageActionItem {
/**
* A short title like 'Retry', 'Open Log' etc.
*/
title: string;
}
LogMessage-Benachrichtigung ()
Die log message-Benachrichtigung wird vom Server an den Client gesendet, um den Client aufzufordern, eine bestimmte Nachricht zu protokollieren.
Benachrichtigung:
- method: ‘window/logMessage’
- params:
LogMessageParams, wie folgt definiert
interface LogMessageParams {
/**
* The message type. See {@link MessageType}
*/
type: number;
/**
* The actual message
*/
message: string;
}
Erstellen von Arbeitsfortschritt ()
Die window/workDoneProgress/create-Anfrage wird vom Server an den Client gesendet, um den Client aufzufordern, einen Work Done-Fortschritt zu erstellen.
Anfrage:
- method: ‘window/workDoneProgress/create’
- params:
WorkDoneProgressCreateParams, wie folgt definiert
export interface WorkDoneProgressCreateParams {
/**
* The token to be used to report progress.
*/
token: ProgressToken;
}
Antwort:
- result: void
- error: code und message werden gesetzt, wenn während der
window/workDoneProgress/create-Anfrage ein Fehler auftritt. Bei einem Fehler darf der Server keine Fortschrittsbenachrichtigung mit dem inWorkDoneProgressCreateParamsbereitgestellten Token senden.
Abbrechen eines Arbeitsfortschritts ()
Die Benachrichtigung window/workDoneProgress/cancel wird vom Client an den Server gesendet, um einen auf der Serverseite über window/workDoneProgress/create initiierten Fortschritt abzubrechen.
Benachrichtigung:
- method: ‘window/workDoneProgress/cancel’
- params:
WorkDoneProgressCancelParams, wie folgt definiert
export interface WorkDoneProgressCancelParams {
/**
* The token to be used to report progress.
*/
token: ProgressToken;
}
Telemetry-Benachrichtigung ()
Die Telemetrie-Benachrichtigung wird vom Server an den Client gesendet, um den Client aufzufordern, ein Telemetrieereignis zu protokollieren.
Benachrichtigung:
- method: ‘telemetry/event’
- params: ‘any’
Capability registrieren ()
Die client/registerCapability-Anfrage wird vom Server an den Client gesendet, um eine neue Fähigkeit auf der Clientseite zu registrieren. Nicht alle Clients müssen die dynamische Fähigkeitsregistrierung unterstützen. Ein Client wählt über die dynamicRegistration-Eigenschaft bei den spezifischen Client-Fähigkeiten eine Option. Ein Client kann sogar eine dynamische Registrierung für Fähigkeit A, aber nicht für Fähigkeit B bereitstellen (siehe TextDocumentClientCapabilities als Beispiel).
Server dürfen dieselbe Fähigkeit nicht sowohl statisch über das initialize-Ergebnis als auch dynamisch für denselben Dokumentselektor registrieren. Wenn ein Server sowohl statische als auch dynamische Registrierung unterstützen möchte, muss er die Client-Fähigkeit in der initialize-Anfrage prüfen und die Fähigkeit nur statisch registrieren, wenn der Client keine dynamische Registrierung für diese Fähigkeit unterstützt.
Anfrage:
- method: ‘client/registerCapability’
- params:
RegistrationParams
Dabei ist RegistrationParams wie folgt definiert
/**
* General parameters to register for a capability.
*/
export interface Registration {
/**
* The id used to register the request. The id can be used to deregister
* the request again.
*/
id: string;
/**
* The method / capability to register for.
*/
method: string;
/**
* Options necessary for the registration.
*/
registerOptions?: any;
}
export interface RegistrationParams {
registrations: Registration[];
}
Da die meisten Registrierungsoptionen die Angabe eines Dokumentselektors erfordern, gibt es eine Basis-Schnittstelle, die verwendet werden kann. Siehe TextDocumentRegistrationOptions.
Eine Beispiel-JSON-RPC-Nachricht zur dynamischen Registrierung für das textDocument/willSaveWaitUntil-Feature auf der Clientseite sieht wie folgt aus (nur Details angezeigt)
{
"method": "client/registerCapability",
"params": {
"registrations": [
{
"id": "79eee87c-c409-4664-8102-e03263673f6f",
"method": "textDocument/willSaveWaitUntil",
"registerOptions": {
"documentSelector": [
{ "language": "javascript" }
]
}
}
]
}
}
Diese Nachricht wird vom Server an den Client gesendet und nachdem der Client die Anfrage erfolgreich ausgeführt hat, werden weitere textDocument/willSaveWaitUntil-Anfragen für JavaScript-Textdokumente vom Client an den Server gesendet.
Antwort:
- result: void.
- error: code und message werden gesetzt, wenn während der Anfrage ein Fehler auftritt.
Capability abmelden ()
Die client/unregisterCapability-Anfrage wird vom Server an den Client gesendet, um eine zuvor registrierte Fähigkeit abzumelden.
Anfrage:
- method: ‘client/unregisterCapability’
- params:
UnregistrationParams
Dabei ist UnregistrationParams wie folgt definiert
/**
* General parameters to unregister a capability.
*/
export interface Unregistration {
/**
* The id used to unregister the request or notification. Usually an id
* provided during the register request.
*/
id: string;
/**
* The method / capability to unregister for.
*/
method: string;
}
export interface UnregistrationParams {
// This should correctly be named `unregistrations`. However changing this
// is a breaking change and needs to wait until we deliver a 4.x version
// of the specification.
unregisterations: Unregistration[];
}
Ein Beispiel für eine JSON-RPC-Nachricht zur Abmeldung des oben registrierten textDocument/willSaveWaitUntil-Features sieht so aus
{
"method": "client/unregisterCapability",
"params": {
"unregisterations": [
{
"id": "79eee87c-c409-4664-8102-e03263673f6f",
"method": "textDocument/willSaveWaitUntil"
}
]
}
}
Antwort:
- result: void.
- error: code und message werden gesetzt, wenn während der Anfrage ein Fehler auftritt.
Workspace-Ordner-Anfrage ()
Seit Version 3.6.0
Viele Tools unterstützen mehr als einen Stammordner pro Workspace. Beispiele hierfür sind die Multi-Root-Unterstützung von VS Code, die Projektordner-Unterstützung von Atom oder die Projektunterstützung von Sublime. Wenn ein Client-Workspace aus mehreren Wurzeln besteht, muss ein Server dies normalerweise wissen. Das Protokoll geht bisher von einem Stammordner aus, der dem Server über die rootUri-Eigenschaft der InitializeParams mitgeteilt wird. Wenn der Client Workspace-Ordner unterstützt und diese über die entsprechende workspaceFolders-Client-Fähigkeit ankündigt, enthalten die InitializeParams eine zusätzliche Eigenschaft workspaceFolders mit den konfigurierten Workspace-Ordnern beim Start des Servers.
Die workspace/workspaceFolders-Anfrage wird vom Server an den Client gesendet, um die aktuell offene Liste der Workspace-Ordner abzurufen. Gibt null in der Antwort zurück, wenn nur eine einzelne Datei im Tool geöffnet ist. Gibt ein leeres Array zurück, wenn ein Workspace geöffnet ist, aber keine Ordner konfiguriert sind.
Client Capability:
- property path (optional):
workspace.workspaceFolders - property type:
boolean
Server-Fähigkeit:
- property path (optional):
workspace.workspaceFolders - property type:
WorkspaceFoldersServerCapabilities, wie folgt definiert
export interface WorkspaceFoldersServerCapabilities {
/**
* The server has support for workspace folders
*/
supported?: boolean;
/**
* Whether the server wants to receive workspace folder
* change notifications.
*
* If a string is provided, the string is treated as an 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;
}
Anfrage:
- method: ‘workspace/workspaceFolders’
- params: none
Antwort:
- result:
WorkspaceFolder[] | null, wie folgt definiert
export interface WorkspaceFolder {
/**
* The associated URI for this workspace folder.
*/
uri: DocumentUri;
/**
* The name of the workspace folder. Used to refer to this
* workspace folder in the user interface.
*/
name: string;
}
- error: code und message werden gesetzt, wenn während der
workspace/workspaceFolders-Anfrage ein Fehler auftritt
DidChangeWorkspaceFolders-Benachrichtigung ()
Seit Version 3.6.0
Die Benachrichtigung workspace/didChangeWorkspaceFolders wird vom Client an den Server gesendet, um den Server über Änderungen an der Konfiguration von Arbeitsbereichsordnern zu informieren. Die Benachrichtigung wird standardmäßig gesendet, wenn sowohl die *Client-Fähigkeit* workspace.workspaceFolders als auch die *Server-Fähigkeit* workspace.workspaceFolders.supported wahr sind; oder wenn der Server sich selbst registriert hat, um diese Benachrichtigung zu erhalten. Um sich für workspace/didChangeWorkspaceFolders zu registrieren, senden Sie eine client/registerCapability-Anfrage vom Server an den Client. Der Registrierungsparameter muss ein registrations-Element der folgenden Form enthalten, wobei id eine eindeutige ID ist, die zum Abmelden der Fähigkeit verwendet wird (das Beispiel verwendet eine UUID)
{
id: "28c6150c-bd7b-11e7-abc4-cec278b6b50a",
method: "workspace/didChangeWorkspaceFolders"
}
Benachrichtigung:
- method: ‘workspace/didChangeWorkspaceFolders’
- params:
DidChangeWorkspaceFoldersParams, wie folgt definiert
export interface DidChangeWorkspaceFoldersParams {
/**
* The actual workspace folder change event.
*/
event: WorkspaceFoldersChangeEvent;
}
/**
* The workspace folder change event.
*/
export interface WorkspaceFoldersChangeEvent {
/**
* The array of added workspace folders
*/
added: WorkspaceFolder[];
/**
* The array of the removed workspace folders
*/
removed: WorkspaceFolder[];
}
DidChangeConfiguration-Benachrichtigung ()
Eine Benachrichtigung, die vom Client an den Server gesendet wird, um die Änderung von Konfigurationseinstellungen zu signalisieren.
Client Capability:
- property path (optional):
workspace.didChangeConfiguration - property type:
DidChangeConfigurationClientCapabilities, wie folgt definiert
export interface DidChangeConfigurationClientCapabilities {
/**
* Did change configuration notification supports dynamic registration.
*/
dynamicRegistration?: boolean;
}
Benachrichtigung:
- method: ‘workspace/didChangeConfiguration’,
- params:
DidChangeConfigurationParams, wie folgt definiert
interface DidChangeConfigurationParams {
/**
* The actual changed settings
*/
settings: any;
}
Konfigurationsanfrage ()
Seit Version 3.6.0
Die workspace/configuration-Anfrage wird vom Server an den Client gesendet, um Konfigurationseinstellungen vom Client abzurufen. Die Anfrage kann mehrere Konfigurationseinstellungen in einem einzigen Roundtrip abrufen. Die Reihenfolge der zurückgegebenen Konfigurationseinstellungen entspricht der Reihenfolge der übergebenen ConfigurationItems (z. B. ist das erste Element in der Antwort das Ergebnis für das erste Konfigurationselement in den Parametern).
Ein ConfigurationItem besteht aus dem zu erfragenden Konfigurationsabschnitt und einer zusätzlichen Bereichs-URI. Der abgefragte Konfigurationsabschnitt wird vom Server definiert und muss nicht unbedingt dem vom Client verwendeten Konfigurationsspeicher entsprechen. So könnte ein Server nach einer Konfiguration cpp.formatterOptions fragen, der Client speichert die Konfiguration jedoch anders in einem XML-Speicherlayout. Es liegt am Client, die notwendige Konvertierung durchzuführen. Wenn eine Bereichs-URI angegeben ist, sollte der Client die Einstellung für die angegebene Ressource zurückgeben. Wenn der Client beispielsweise EditorConfig zur Verwaltung seiner Einstellungen verwendet, sollte die Konfiguration für die angegebene Ressourcen-URI zurückgegeben werden. Wenn der Client keine Konfigurationseinstellung für einen bestimmten Bereich bereitstellen kann, muss null im zurückgegebenen Array vorhanden sein.
Client Capability:
- property path (optional):
workspace.configuration - property type:
boolean
Anfrage:
- method: ‘workspace/configuration’
- params:
ConfigurationParams, wie folgt definiert
export interface ConfigurationParams {
items: ConfigurationItem[];
}
export interface ConfigurationItem {
/**
* The scope to get the configuration section for.
*/
scopeUri?: DocumentUri;
/**
* The configuration section asked for.
*/
section?: string;
}
Antwort:
- result: any[]
- error: code und message werden gesetzt, wenn während der
workspace/configuration-Anfrage ein Fehler auftritt
DidChangeWatchedFiles-Benachrichtigung ()
Die Benachrichtigung über überwachte Dateien wird vom Client an den Server gesendet, wenn der Client Änderungen an von den Sprachclients überwachten Dateien erkennt. Es wird empfohlen, dass Server sich mit Hilfe des Registrierungsmechanismus für diese Dateizähler registrieren. In früheren Implementierungen wurden Dateizähler vom Client gesendet, ohne dass der Server aktiv danach fragte.
Server dürfen ihren eigenen Mechanismus zur Dateiüberwachung ausführen und sich nicht auf Clients verlassen, um Dateiereignisse bereitzustellen. Dies wird jedoch aus folgenden Gründen nicht empfohlen
- nach unserer Erfahrung ist es schwierig, die Dateiüberwachung auf der Festplatte korrekt zu implementieren, insbesondere wenn sie auf mehreren Betriebssystemen unterstützt werden muss.
- Die Dateiüberwachung ist nicht kostenlos, insbesondere wenn die Implementierung eine Art von Abfrage verwendet und einen Dateibaum im Speicher hält, um Zeitstempel zu vergleichen (wie zum Beispiel einige Node-Module tun)
- Ein Client startet normalerweise mehr als einen Server. Wenn jeder Server seine eigene Dateiüberwachung ausführt, kann dies zu einem CPU- oder Speicherproblem werden.
- Im Allgemeinen gibt es mehr Server- als Clientimplementierungen. Dieses Problem ist daher auf der Clientseite besser gelöst.
Client Capability:
- property path (optional):
workspace.didChangeWatchedFiles - property type:
DidChangeWatchedFilesClientCapabilities, wie folgt definiert
export interface DidChangeWatchedFilesClientCapabilities {
/**
* 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;
}
Registrierungsoptionen: DidChangeWatchedFilesRegistrationOptions, wie folgt definiert
/**
* Describe options to be used when registering for file system change events.
*/
export interface DidChangeWatchedFilesRegistrationOptions {
/**
* The watchers to register.
*/
watchers: FileSystemWatcher[];
}
export interface FileSystemWatcher {
/**
* The glob pattern to watch.
*
* 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`)
*/
globPattern: string;
/**
* The kind of events of interest. If omitted it defaults
* to WatchKind.Create | WatchKind.Change | WatchKind.Delete
* which is 7.
*/
kind?: number;
}
export namespace WatchKind {
/**
* Interested in create events.
*/
export const Create = 1;
/**
* Interested in change events
*/
export const Change = 2;
/**
* Interested in delete events
*/
export const Delete = 4;
}
Benachrichtigung:
- method: ‘workspace/didChangeWatchedFiles’
- params:
DidChangeWatchedFilesParams, wie folgt definiert
interface DidChangeWatchedFilesParams {
/**
* The actual file events.
*/
changes: FileEvent[];
}
Dabei sind FileEvents wie folgt beschrieben
/**
* An event describing a file change.
*/
interface FileEvent {
/**
* The file's URI.
*/
uri: DocumentUri;
/**
* The change type.
*/
type: number;
}
/**
* The file event type.
*/
export namespace FileChangeType {
/**
* The file got created.
*/
export const Created = 1;
/**
* The file got changed.
*/
export const Changed = 2;
/**
* The file got deleted.
*/
export const Deleted = 3;
}
Workspace-Symbole-Anfrage ()
Die Anfrage nach Arbeitsbereichssymbolen wird vom Client an den Server gesendet, um projektspezifische Symbole abzurufen, die mit der Abfragezeichenkette übereinstimmen.
Client Capability:
- property path (optional):
workspace.symbol - property type:
WorkspaceSymbolClientCapabilities, wie folgt definiert
interface WorkspaceSymbolClientCapabilities {
/**
* 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[];
}
}
Server-Fähigkeit:
- property path (optional):
workspaceSymbolProvider - property type:
boolean | WorkspaceSymbolOptions, wobeiWorkspaceSymbolOptionswie folgt definiert ist
export interface WorkspaceSymbolOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: WorkspaceSymbolRegistrationOptions wie folgt definiert
export interface WorkspaceSymbolRegistrationOptions
extends WorkspaceSymbolOptions {
}
Anfrage:
- methode: „workspace/symbol“
- parameter:
WorkspaceSymbolParamswie folgt definiert
/**
* The parameters of a Workspace Symbol Request.
*/
interface WorkspaceSymbolParams
extends WorkDoneProgressParams, PartialResultParams {
/**
* A query string to filter symbols by. Clients may send an empty
* string here to request all symbols.
*/
query: string;
}
Antwort:
- result:
SymbolInformation[]|nullwie oben definiert. - partial result:
SymbolInformation[]wie oben definiert. - Fehler: Code und Nachricht werden gesetzt, wenn während der Workspace-Symbolanfrage eine Ausnahme auftritt.
Führe einen Befehl aus ()
Die Anfrage workspace/executeCommand wird vom Client an den Server gesendet, um die Befehlsausführung auf dem Server auszulösen. In den meisten Fällen erstellt der Server eine WorkspaceEdit-Struktur und wendet die Änderungen auf den Workspace mithilfe der Anfrage workspace/applyEdit an, die vom Server an den Client gesendet wird.
Client Capability:
- Eigenschaftspfad (optional):
workspace.executeCommand - Eigenschaftstyp:
ExecuteCommandClientCapabilitieswie folgt definiert
export interface ExecuteCommandClientCapabilities {
/**
* Execute command supports dynamic registration.
*/
dynamicRegistration?: boolean;
}
Server-Fähigkeit:
- Eigenschaftspfad (optional):
executeCommandProvider - Eigenschaftstyp:
ExecuteCommandOptionswie folgt definiert
export interface ExecuteCommandOptions extends WorkDoneProgressOptions {
/**
* The commands to be executed on the server
*/
commands: string[]
}
Registrierungsoptionen: ExecuteCommandRegistrationOptions wie folgt definiert
/**
* Execute command registration options.
*/
export interface ExecuteCommandRegistrationOptions
extends ExecuteCommandOptions {
}
Anfrage
- methode: „workspace/executeCommand“
- parameter:
ExecuteCommandParamswie folgt definiert
export interface ExecuteCommandParams extends WorkDoneProgressParams {
/**
* The identifier of the actual command handler.
*/
command: string;
/**
* Arguments that the command should be invoked with.
*/
arguments?: any[];
}
Die Argumente werden typischerweise angegeben, wenn ein Befehl vom Server an den Client zurückgegeben wird. Beispielanfragen, die einen Befehl zurückgeben, sind textDocument/codeAction oder textDocument/codeLens.
Antwort:
- result:
any|null - error: code und message werden gesetzt, wenn während der Anfrage ein Fehler auftritt.
Wendet einen WorkspaceEdit an ()
Die Anfrage workspace/applyEdit wird vom Server an den Client gesendet, um Ressourcen auf der Clientseite zu ändern.
Client Capability:
- Eigenschaftspfad (optional):
workspace.applyEdit - property type:
boolean
Siehe auch die WorkspaceEditClientCapabilities für die unterstützten Fähigkeiten eines Workspace-Edits.
Anfrage:
- methode: „workspace/applyEdit“
- parameter:
ApplyWorkspaceEditParamswie folgt definiert
export interface ApplyWorkspaceEditParams {
/**
* An optional label of the workspace edit. This label is
* presented in the user interface for example on an undo
* stack to undo the workspace edit.
*/
label?: string;
/**
* The edits to apply.
*/
edit: WorkspaceEdit;
}
Antwort:
- result:
ApplyWorkspaceEditResponsewie folgt definiert
export interface ApplyWorkspaceEditResponse {
/**
* Indicates whether the edit was applied or not.
*/
applied: boolean;
/**
* An optional textual description for why the edit was not applied.
* This may be used may be used by the server for diagnostic
* logging or to provide a suitable error for a request that
* triggered the edit.
*/
failureReason?: string;
}
- error: code und message werden gesetzt, wenn während der Anfrage ein Fehler auftritt.
Textdokument-Synchronisierung
Die Client-Unterstützung für die Benachrichtigungen textDocument/didOpen, textDocument/didChange und textDocument/didClose ist im Protokoll zwingend erforderlich und Clients können sich nicht von der Unterstützung abmelden. Dies umfasst sowohl die vollständige als auch die inkrementelle Synchronisation in der Benachrichtigung textDocument/didChange. Zusätzlich muss ein Server entweder alle drei oder keine implementieren. Ihre Fähigkeiten werden daher über eine kombinierte Client- und Server-Fähigkeit gesteuert.
- Eigenschaftspfad (optional):
textDocument.synchronization.dynamicRegistration - property type:
boolean
Steuert, ob die Textdokument-Synchronisierung dynamische Registrierung unterstützt.
- Eigenschaftspfad (optional):
textDocumentSync - Eigenschaftstyp:
TextDocumentSyncKind | TextDocumentSyncOptions. Die folgende Definition vonTextDocumentSyncOptionsdeckt nur die Eigenschaften ab, die spezifisch für die Benachrichtigungen open, change und close sind. Eine vollständige Definition, die alle Eigenschaften abdeckt, finden Sie hier.
/**
* Defines how the host (editor) should sync document changes
* to the language server.
*/
export namespace TextDocumentSyncKind {
/**
* Documents should not be synced at all.
*/
export const None = 0;
/**
* Documents are synced by always sending the full content
* of the document.
*/
export const Full = 1;
/**
* Documents are synced by sending the full content on open.
* After that only incremental updates to the document are
* send.
*/
export const Incremental = 2;
}
export interface TextDocumentSyncOptions {
/**
* Open and close notifications are sent to the server.
* If omitted open close notification should not be sent.
*/
openClose?: boolean;
/**
* Change notifications are sent to the server.
* See TextDocumentSyncKind.None, TextDocumentSyncKind.Full,
* and TextDocumentSyncKind.Incremental.
* If omitted, it defaults to TextDocumentSyncKind.None.
*/
change?: TextDocumentSyncKind;
}
DidOpenTextDocument Notification ()
Die Benachrichtigung „Dokument geöffnet“ wird vom Client an den Server gesendet, um neu geöffnete Textdokumente zu signalisieren. Der Inhalt des Dokuments wird nun vom Client verwaltet und der Server darf nicht versuchen, den Inhalt des Dokuments mithilfe der URI des Dokuments zu lesen. Öffnen in diesem Sinne bedeutet, dass es vom Client verwaltet wird. Es bedeutet nicht unbedingt, dass sein Inhalt in einem Editor angezeigt wird. Eine Öffnungsbenachrichtigung darf nicht mehr als einmal gesendet werden, ohne dass zuvor eine entsprechende Schließungsbenachrichtigung gesendet wurde. Das bedeutet, dass die Öffnungs- und Schließungsbenachrichtigungen ausgeglichen sein müssen und die maximale Anzahl offener Dokumente für ein bestimmtes Textdokument eins beträgt. Beachten Sie, dass die Fähigkeit eines Servers, Anfragen zu erfüllen, unabhängig davon ist, ob ein Textdokument geöffnet oder geschlossen ist.
Die DidOpenTextDocumentParams enthalten die Sprach-ID, der das Dokument zugeordnet ist. Wenn sich die Sprach-ID eines Dokuments ändert, muss der Client eine textDocument/didClose an den Server senden, gefolgt von einer textDocument/didOpen mit der neuen Sprach-ID, wenn der Server die neue Sprach-ID ebenfalls behandelt.
Client-Fähigkeit: Siehe allgemeine Synchronisierungs- Client-Fähigkeiten.
Server-Fähigkeit: Siehe allgemeine Synchronisierungs- Server-Fähigkeiten.
Registrierungsoptionen: TextDocumentRegistrationOptions
Benachrichtigung:
- methode: „textDocument/didOpen“
- parameter:
DidOpenTextDocumentParamswie folgt definiert
interface DidOpenTextDocumentParams {
/**
* The document that was opened.
*/
textDocument: TextDocumentItem;
}
DidChangeTextDocument Notification ()
Die Dokumentänderungsbenachrichtigung wird vom Client an den Server gesendet, um Änderungen an einem Textdokument zu signalisieren. Bevor ein Client ein Textdokument ändern kann, muss er die Eigentümerschaft seines Inhalts über die textDocument/didOpen-Benachrichtigung beanspruchen. In 2.0 hat sich die Form der Parameter geändert, um korrekte Versionsnummern und Sprach-IDs einzuschließen.
Client-Fähigkeit: Siehe allgemeine Synchronisierungs- Client-Fähigkeiten.
Server-Fähigkeit: Siehe allgemeine Synchronisierungs- Server-Fähigkeiten.
Registrierungsoptionen: TextDocumentChangeRegistrationOptions wie folgt definiert
/**
* Describe options to be used when registering for text document change events.
*/
export interface TextDocumentChangeRegistrationOptions
extends TextDocumentRegistrationOptions {
/**
* How documents are synced to the server. See TextDocumentSyncKind.Full
* and TextDocumentSyncKind.Incremental.
*/
syncKind: TextDocumentSyncKind;
}
Benachrichtigung:
- method: ‘textDocument/didChange’
- parameter:
DidChangeTextDocumentParamswie folgt definiert
interface DidChangeTextDocumentParams {
/**
* The document that did change. The version number points
* to the version after all provided content changes have
* been applied.
*/
textDocument: VersionedTextDocumentIdentifier;
/**
* The actual content changes.
* The content changes describe single state changes to the document.
* If there are two content changes c1 (at array index 0) and
* c2 (at array index 1) for a document in state S, then c1 moves the
* document from S to S' and c2 from S' to S''.
* So c1 is computed on the state S and c2 is computed on the state S'.
*
* To mirror the content of a document using change events,
* use the following approach:
* - start with the same initial content
* - apply the 'textDocument/didChange' notifications
* in the order you receive them.
* - apply the `TextDocumentContentChangeEvent`s
* in a single notification in the order you receive them.
*/
contentChanges: TextDocumentContentChangeEvent[];
}
/**
* An event describing a change to a text document.
* If range and rangeLength are omitted, the new text is considered to be
* the full content of the document.
*/
export type TextDocumentContentChangeEvent = {
/**
* The range of the document that changed.
*/
range: Range;
/**
* The optional length of the range that got replaced.
*
* @deprecated use range instead.
*/
rangeLength?: number;
/**
* The new text for the provided range.
*/
text: string;
} | {
/**
* The new text of the whole document.
*/
text: string;
}
WillSaveTextDocument Notification ()
Die Benachrichtigung 'document will save' wird vom Client an den Server gesendet, bevor das Dokument tatsächlich gespeichert wird.
Client Capability:
- Eigenschaftsname (optional):
textDocument.synchronization.willSave - property type:
boolean
Die Fähigkeit zeigt an, dass der Client textDocument/willSave-Benachrichtigungen unterstützt.
Server-Fähigkeit:
- Eigenschaftsname (optional):
textDocumentSync.willSave - property type:
boolean
Die Fähigkeit zeigt an, dass der Server an textDocument/willSave-Benachrichtigungen interessiert ist.
Registrierungsoptionen: TextDocumentRegistrationOptions
Benachrichtigung:
- methode: „textDocument/willSave“
- parameter:
WillSaveTextDocumentParamswie folgt definiert
/**
* The parameters send in a will save text document notification.
*/
export interface WillSaveTextDocumentParams {
/**
* The document that will be saved.
*/
textDocument: TextDocumentIdentifier;
/**
* The 'TextDocumentSaveReason'.
*/
reason: number;
}
/**
* Represents reasons why a text document is saved.
*/
export namespace TextDocumentSaveReason {
/**
* Manually triggered, for example, by the user pressing save,
* by starting debugging, or by an API call.
*/
export const Manual = 1;
/**
* Automatic after a delay.
*/
export const AfterDelay = 2;
/**
* When the editor lost focus.
*/
export const FocusOut = 3;
}
WillSaveWaitUntilTextDocument Request ()
Die Anfrage 'document will save' wird vom Client an den Server gesendet, bevor das Dokument tatsächlich gespeichert wird. Die Anfrage kann ein Array von TextEdits zurückgeben, die vor dem Speichern des Textdokuments angewendet werden. Bitte beachten Sie, dass Clients Ergebnisse fallen lassen können, wenn die Berechnung der TextEdits zu lange dauerte oder wenn ein Server bei dieser Anfrage ständig fehlschlägt. Dies geschieht, um das Speichern schnell und zuverlässig zu halten.
Client Capability:
- Eigenschaftsname (optional):
textDocument.synchronization.willSaveWaitUntil - property type:
boolean
Die Fähigkeit zeigt an, dass der Client textDocument/willSaveWaitUntil-Anfragen unterstützt.
Server-Fähigkeit:
- Eigenschaftsname (optional):
textDocumentSync.willSaveWaitUntil - property type:
boolean
Die Fähigkeit zeigt an, dass der Server an textDocument/willSaveWaitUntil-Anfragen interessiert ist.
Registrierungsoptionen: TextDocumentRegistrationOptions
Anfrage:
- method: ‘textDocument/willSaveWaitUntil’
- parameter:
WillSaveTextDocumentParams
Antwort:
- result:
TextEdit[]|null - error: code und message, gesetzt im Falle einer Ausnahme während der
willSaveWaitUntil-Anfrage.
DidSaveTextDocument Notification ()
Die Benachrichtigung „Dokument gespeichert“ wird vom Client an den Server gesendet, wenn das Dokument im Client gespeichert wurde.
Client Capability:
- Eigenschaftsname (optional):
textDocument.synchronization.didSave - property type:
boolean
Die Fähigkeit zeigt an, dass der Client textDocument/didSave-Benachrichtigungen unterstützt.
Server-Fähigkeit:
- Eigenschaftsname (optional):
textDocumentSync.save - Eigenschaftstyp:
boolean | SaveOptions, wobeiSaveOptionswie folgt definiert ist
export interface SaveOptions {
/**
* The client is supposed to include the content on save.
*/
includeText?: boolean;
}
Die Fähigkeit zeigt an, dass der Server an textDocument/didSave-Benachrichtigungen interessiert ist.
Registrierungsoptionen: TextDocumentSaveRegistrationOptions wie folgt definiert
export interface TextDocumentSaveRegistrationOptions
extends TextDocumentRegistrationOptions {
/**
* The client is supposed to include the content on save.
*/
includeText?: boolean;
}
Benachrichtigung:
- method: ‘textDocument/didSave’
- parameter:
DidSaveTextDocumentParamswie folgt definiert
interface DidSaveTextDocumentParams {
/**
* The document that was saved.
*/
textDocument: TextDocumentIdentifier;
/**
* Optional the content when saved. Depends on the includeText value
* when the save notification was requested.
*/
text?: string;
}
DidCloseTextDocument Notification ()
Die Benachrichtigung „Dokument geschlossen“ wird vom Client an den Server gesendet, wenn das Dokument im Client geschlossen wurde. Der Master des Dokuments existiert nun dort, wo die URI des Dokuments hinzeigt (z.B. wenn die URI des Dokuments eine Datei-URI ist, existiert der Master nun auf der Festplatte). Wie bei der Öffnungsbenachrichtigung geht es bei der Schließungsbenachrichtigung um die Verwaltung des Dokumenteninhalts. Der Empfang einer Schließungsbenachrichtigung bedeutet nicht, dass das Dokument zuvor in einem Editor geöffnet war. Eine Schließungsbenachrichtigung erfordert die vorherige Zusendung einer Öffnungsbenachrichtigung. Beachten Sie, dass die Fähigkeit eines Servers, Anfragen zu erfüllen, unabhängig davon ist, ob ein Textdokument geöffnet oder geschlossen ist.
Client-Fähigkeit: Siehe allgemeine Synchronisierungs- Client-Fähigkeiten.
Server-Fähigkeit: Siehe allgemeine Synchronisierungs- Server-Fähigkeiten.
Registrierungsoptionen: TextDocumentRegistrationOptions
Benachrichtigung:
- method: ‘textDocument/didClose’
- parameter:
DidCloseTextDocumentParamswie folgt definiert
interface DidCloseTextDocumentParams {
/**
* The document that was closed.
*/
textDocument: TextDocumentIdentifier;
}
Die endgültige Struktur der TextDocumentSyncClientCapabilities und der TextDocumentSyncOptions Serveroptionen sieht wie folgt aus
export interface TextDocumentSyncClientCapabilities {
/**
* 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;
}
/**
* Defines how the host (editor) should sync document changes
* to the language server.
*/
export namespace TextDocumentSyncKind {
/**
* Documents should not be synced at all.
*/
export const None = 0;
/**
* Documents are synced by always sending the full content
* of the document.
*/
export const Full = 1;
/**
* Documents are synced by sending the full content on open.
* After that only incremental updates to the document are
* send.
*/
export const Incremental = 2;
}
export interface TextDocumentSyncOptions {
/**
* Open and close notifications are sent to the server.
* If omitted, open close notification should not be sent.
*/
openClose?: boolean;
/**
* Change notifications are sent to the server.
* See TextDocumentSyncKind.None, TextDocumentSyncKind.Full,
* and TextDocumentSyncKind.Incremental.
* If omitted, it defaults to TextDocumentSyncKind.None.
*/
change?: number;
/**
* If present will save notifications are sent to the server.
* If omitted, the notification should not be sent.
*/
willSave?: boolean;
/**
* If present will save wait until requests are sent to the server.
* If omitted, the request should not be sent.
*/
willSaveWaitUntil?: boolean;
/**
* If present save notifications are sent to the server.
* If omitted, the notification should not be sent.
*/
save?: boolean | SaveOptions;
}
PublishDiagnostics Notification ()
Diagnosebenachrichtigungen werden vom Server an den Client gesendet, um Ergebnisse von Validierungsläufen zu signalisieren.
Diagnosen werden vom Server „besessen“, sodass es die Verantwortung des Servers ist, sie bei Bedarf zu löschen. Die folgende Regel wird für VS Code-Server verwendet, die Diagnosen generieren:
- Wenn eine Sprache nur eine einzelne Datei hat (z. B. HTML), werden die Diagnostiken vom Server gelöscht, wenn die Datei geschlossen wird.
- Wenn eine Sprache ein Projektsystem hat (z. B. C#), werden die Diagnosen beim Schließen einer Datei nicht gelöscht. Wenn ein Projekt geöffnet wird, werden alle Diagnosen für alle Dateien neu berechnet (oder aus einem Cache gelesen).
Wenn sich eine Datei ändert, liegt es in der Verantwortung des Servers, Diagnosen neu zu berechnen und an den Client zu senden. Wenn die berechnete Menge leer ist, muss er ein leeres Array senden, um frühere Diagnosen zu löschen. Neu gesendete Diagnosen ersetzen immer zuvor gesendete Diagnosen. Es findet kein Zusammenführen auf der Clientseite statt.
Siehe auch den Abschnitt Diagnostic.
Client Capability:
- Eigenschaftsname (optional):
textDocument.publishDiagnostics - property type
PublishDiagnosticsClientCapabilitieswie folgt definiert
export interface PublishDiagnosticsClientCapabilities {
/**
* 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 the client.
*/
valueSet: DiagnosticTag[];
};
/**
* Whether the client interprets the version property of the
* `textDocument/publishDiagnostics` notification's parameter.
*
* @since 3.15.0
*/
versionSupport?: boolean;
}
Benachrichtigung:
- method: ‘textDocument/publishDiagnostics’
- parameter:
PublishDiagnosticsParamswie folgt definiert
interface PublishDiagnosticsParams {
/**
* The URI for which diagnostic information is reported.
*/
uri: DocumentUri;
/**
* The version number of the document the diagnostics are published for.
* Optional.
* @since 3.15.0
*/
version?: number;
/**
* An array of diagnostic information items.
*/
diagnostics: Diagnostic[];
}
Completion Request ()
Die Completion-Anfrage wird vom Client an den Server gesendet, um Completion-Elemente an einer gegebenen Cursorposition zu berechnen. Completion-Elemente werden in der IntelliSense dargestellt. Wenn die Berechnung vollständiger Completion-Elemente teuer ist, können Server zusätzlich einen Handler für die Completion-Item-Resolve-Anfrage ('completionItem/resolve') bereitstellen. Diese Anfrage wird gesendet, wenn ein Completion-Element in der Benutzeroberfläche ausgewählt wird. Ein typischer Anwendungsfall ist beispielsweise: Die Anfrage 'textDocument/completion' füllt die documentation-Eigenschaft für zurückgegebene Completion-Elemente nicht aus, da ihre Berechnung teuer ist. Wenn das Element in der Benutzeroberfläche ausgewählt wird, wird eine 'completionItem/resolve'-Anfrage mit dem ausgewählten Completion-Element als Parameter gesendet. Das zurückgegebene Completion-Element sollte die Dokumentationseigenschaft ausgefüllt haben. Die Anfrage kann nur die Berechnung der Eigenschaften detail und documentation verzögern. Andere Eigenschaften wie sortText, filterText, insertText, textEdit und additionalTextEdits müssen in der Antwort textDocument/completion bereitgestellt werden und dürfen während des Resolves nicht geändert werden.
Client Capability:
- Eigenschaftsname (optional):
textDocument.completion - Eigenschaftstyp:
CompletionClientCapabilitieswie folgt definiert
export interface CompletionClientCapabilities {
/**
* Whether completion supports dynamic registration.
*/
dynamicRegistration?: boolean;
/**
* The client supports the following `CompletionItem` specific
* capabilities.
*/
completionItem?: {
/**
* 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, so that typing in
* one will update others as well.
*/
snippetSupport?: boolean;
/**
* Client supports commit characters on a completion item.
*/
commitCharactersSupport?: boolean
/**
* Client supports the follow content formats for the documentation
* property. The order describes the preferred format of the client.
*/
documentationFormat?: MarkupKind[];
/**
* Client supports the deprecated property on a completion item.
*/
deprecatedSupport?: boolean;
/**
* Client supports the preselect property on a completion item.
*/
preselectSupport?: boolean;
/**
* Client supports the tag property on a completion item.
* Clients supporting tags have to handle unknown tags gracefully.
* Clients especially need to preserve unknown tags when sending
* a completion item back to the server in a resolve call.
*
* @since 3.15.0
*/
tagSupport?: {
/**
* The tags supported by the client.
*/
valueSet: CompletionItemTag[]
}
};
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;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
completionProvider - Eigenschaftstyp:
CompletionOptionswie folgt definiert
/**
* Completion options.
*/
export interface CompletionOptions extends WorkDoneProgressOptions {
/**
* Most tools trigger completion request automatically without explicitly
* requesting it using a keyboard shortcut (for example 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 display `console` along with others as a
* completion item.
* Characters that make up identifiers don't need to be listed here.
*
* If code complete should automatically be triggered on characters
* not being valid inside an identifier (for example `.` in JavaScript),
* list them in `triggerCharacters`.
*/
triggerCharacters?: string[];
/**
* The list of all possible characters that commit a completion.
* This field can be used if clients don't support individual commit
* characters per completion item. See `ClientCapabilities.`
* `textDocument.completion.completionItem.commitCharactersSupport`.
*
* If a server provides both `allCommitCharacters` and commit characters
* on an individual completion item, the ones on the completion item win.
*
* @since 3.2.0
*/
allCommitCharacters?: string[];
/**
* The server provides support to resolve additional
* information for a completion item.
*/
resolveProvider?: boolean;
}
Registrierungsoptionen: CompletionRegistrationOptions Optionen wie folgt definiert
export interface CompletionRegistrationOptions
extends TextDocumentRegistrationOptions, CompletionOptions {
}
Anfrage:
- method: ‘textDocument/completion’
- parameter:
CompletionParamswie folgt definiert
export interface CompletionParams
extends TextDocumentPositionParams, WorkDoneProgressParams,
PartialResultParams {
/**
* The completion context.
* This is only available if the client specifies to send this using
* `ClientCapabilities.textDocument.completion.contextSupport === true`
*/
context?: CompletionContext;
}
/**
* How a completion was triggered
*/
export namespace CompletionTriggerKind {
/**
* Completion was triggered by typing an identifier (24x7 code
* complete), manual invocation (e.g Ctrl+Space) or via API.
*/
export const Invoked: 1 = 1;
/**
* Completion was triggered by a trigger character specified by
* the `triggerCharacters` properties of `CompletionRegistrationOptions`.
*/
export const TriggerCharacter: 2 = 2;
/**
* Completion was re-triggered as the current completion list is incomplete.
*/
export const TriggerForIncompleteCompletions: 3 = 3;
}
export type CompletionTriggerKind = 1 | 2 | 3;
/**
* Contains additional information about the context in which a completion
* request is triggered.
*/
export interface CompletionContext {
/**
* How the completion was triggered.
*/
triggerKind: CompletionTriggerKind;
/**
* The trigger character (single character) that has trigger code complete.
* Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
*/
triggerCharacter?: string;
}
Antwort:
- ergebnis:
CompletionItem[]|CompletionList|null. Wenn einCompletionItem[]bereitgestellt wird, wird es als vollständig interpretiert. Es ist also dasselbe wie{ isIncomplete: false, items }
/**
* Represents a collection of [completion items](#CompletionItem) to be
* presented in the editor.
*/
export interface CompletionList {
/**
* This list is not complete. Further typing should result in recomputing
* this list.
*
* Recomputed lists have all their items replaced (not appended) in the
* incomplete completion sessions.
*/
isIncomplete: boolean;
/**
* The completion items.
*/
items: CompletionItem[];
}
/**
* Defines whether the insert text in a completion item should be interpreted as
* plain text or a snippet.
*/
export namespace InsertTextFormat {
/**
* The primary text to be inserted is treated as a plain string.
*/
export const 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.
*/
export const Snippet = 2;
}
export type InsertTextFormat = 1 | 2;
/**
* Completion item tags are extra annotations that tweak the rendering of
* a completion item.
*
* @since 3.15.0
*/
export namespace CompletionItemTag {
/**
* Render a completion as obsolete, usually using a strike-out.
*/
export const Deprecated = 1;
}
export type CompletionItemTag = 1;
export interface CompletionItem {
/**
* The label of this completion item. By default
* also the text that is inserted when selecting
* this completion.
*/
label: string;
/**
* The kind of this completion item. Based of the kind
* an icon is chosen by the editor. The standardized set
* of available values is defined in `CompletionItemKind`.
*/
kind?: number;
/**
* Tags for this completion item.
*
* @since 3.15.0
*/
tags?: CompletionItemTag[];
/**
* A human-readable string with additional information
* about this item, like type or symbol information.
*/
detail?: string;
/**
* A human-readable string that represents a doc-comment.
*/
documentation?: string | MarkupContent;
/**
* Indicates if this item is deprecated.
*
* @deprecated Use `tags` instead if supported.
*/
deprecated?: boolean;
/**
* Select this item when showing.
*
* *Note* that only one completion item can be selected and that the
* tool / client decides which item that is. The rule is that the *first*
* item of those that match best is selected.
*/
preselect?: boolean;
/**
* A string that should be used when comparing this item
* with other items. When `falsy` the label is used.
*/
sortText?: string;
/**
* A string that should be used when filtering a set of
* completion items. When `falsy` the label is used.
*/
filterText?: string;
/**
* A string that should be inserted into a document when selecting
* this completion. When `falsy` the label is used.
*
* The `insertText` is subject to interpretation by the client side.
* Some tools might not take the string literally.
* For example, VS Code when code complete is requested in this example
* `con<cursor position>` and a completion item with an `insertText` of
* `console` is provided, it will only insert `sole`.
* Therefore, it is recommended to use `textEdit` instead since it avoids
* additional client side interpretation.
*/
insertText?: string;
/**
* The format of the insert text.
* The format applies to both the `insertText` property and the `newText`
* property of a provided `textEdit`.
* If omitted, defaults to `InsertTextFormat.PlainText`.
*/
insertTextFormat?: InsertTextFormat;
/**
* An edit that is applied to a document when selecting this completion.
* When an edit is provided, the value of `insertText` is ignored.
*
* *Note:* The range of the edit must be a single line range and it must
* contain the position at which completion has been requested.
*/
textEdit?: TextEdit;
/**
* An optional array of additional text edits that are applied when
* selecting this completion.
* Edits must not overlap (including the same insert position) with the
* main edit nor with themselves.
*
* Additional text edits should be used to change text unrelated to the
* current cursor position (for example adding an import statement at the
* top of the file if the completion item will insert an unqualified type).
*/
additionalTextEdits?: TextEdit[];
/**
* An optional set of characters that when pressed, while this completion
* is active, will accept it first and then type that character.
* *Note* that all commit characters should have `length=1` and that
* superfluous characters will be ignored.
*/
commitCharacters?: string[];
/**
* An optional command that is executed *after* inserting this completion.
* *Note* that additional modifications to the current document should be
* described with the additionalTextEdits-property.
*/
command?: Command;
/**
* A data entry field that is preserved on a completion item between
* a completion and a completion resolve request.
*/
data?: any
}
/**
* The kind of a completion entry.
*/
export namespace CompletionItemKind {
export const Text = 1;
export const Method = 2;
export const Function = 3;
export const Constructor = 4;
export const Field = 5;
export const Variable = 6;
export const Class = 7;
export const Interface = 8;
export const Module = 9;
export const Property = 10;
export const Unit = 11;
export const Value = 12;
export const Enum = 13;
export const Keyword = 14;
export const Snippet = 15;
export const Color = 16;
export const File = 17;
export const Reference = 18;
export const Folder = 19;
export const EnumMember = 20;
export const Constant = 21;
export const Struct = 22;
export const Event = 23;
export const Operator = 24;
export const TypeParameter = 25;
}
- Teilergebnis:
CompletionItem[]oderCompletionListgefolgt vonCompletionItem[]. Wenn das erste bereitgestellte Ergebnis einCompletionList-Typ ist, werden nachfolgende Teilergebnisse vonCompletionItem[]zuritems-Eigenschaft derCompletionListhinzugefügt. - Fehler: Code und Nachricht werden gesetzt, wenn während der Vervollständigungsanfrage eine Ausnahme auftritt.
Vervollständigungselemente unterstützen Snippets (siehe InsertTextFormat.Snippet). Das Snippet-Format ist wie folgt:
Snippet-Syntax
Der body eines Snippets kann spezielle Konstrukte verwenden, um Cursors und den eingefügten Text zu steuern. Die folgenden Funktionen und ihre Syntax werden unterstützt:
Tab-Stopps
Mit Tab-Stopps können Sie den Editor-Cursor innerhalb eines Snippets bewegen. Verwenden Sie $1, $2, um Cursorpositionen anzugeben. Die Zahl ist die Reihenfolge, in der die Tab-Stopps besucht werden, während $0 die endgültige Cursorposition bezeichnet. Mehrere Tab-Stopps sind verknüpft und werden synchron aktualisiert.
Platzhalter
Platzhalter sind Tab-Stopps mit Werten, wie ${1:foo}. Der Platzhaltertext wird eingefügt und ausgewählt, sodass er leicht geändert werden kann. Platzhalter können verschachtelt sein, wie ${1:another ${2:placeholder}}.
Auswahl
Platzhalter können Auswahlmöglichkeiten als Werte haben. Die Syntax ist eine kommagetrennte Aufzählung von Werten, eingeschlossen in das Pipe-Zeichen, z.B. ${1|one,two,three|}. Wenn das Snippet eingefügt und der Platzhalter ausgewählt wird, werden dem Benutzer Auswahlmöglichkeiten angezeigt, um einen der Werte auszuwählen.
Variablen
Mit $name oder ${name:default} können Sie den Wert einer Variablen einfügen. Wenn eine Variable nicht gesetzt ist, wird ihr Standardwert oder eine leere Zeichenkette eingefügt. Wenn eine Variable unbekannt ist (d. h. ihr Name ist nicht definiert), wird der Name der Variablen eingefügt und sie wird in einen Platzhalter umgewandelt.
Die folgenden Variablen können verwendet werden:
-
TM_SELECTED_TEXTDer aktuell ausgewählte Text oder die leere Zeichenkette -
TM_CURRENT_LINEDer Inhalt der aktuellen Zeile -
TM_CURRENT_WORDDer Inhalt des Wortes unter dem Cursor oder die leere Zeichenkette -
TM_LINE_INDEXDie nullbasierte Zeilennummer -
TM_LINE_NUMBERDie einbasierte Zeilennummer -
TM_FILENAMEDer Dateiname des aktuellen Dokuments -
TM_FILENAME_BASEDer Dateiname des aktuellen Dokuments ohne seine Erweiterungen -
TM_DIRECTORYDas Verzeichnis des aktuellen Dokuments -
TM_FILEPATHDer vollständige Dateipfad des aktuellen Dokuments
Variablentransformationen
Transformationen ermöglichen es Ihnen, den Wert einer Variablen zu ändern, bevor sie eingefügt wird. Die Definition einer Transformation besteht aus drei Teilen:
- Ein regulärer Ausdruck, der auf den Wert einer Variablen oder die leere Zeichenkette angewendet wird, wenn die Variable nicht aufgelöst werden kann.
- Eine „Formatzeichenkette“, die das Referenzieren von Übereinstimmungsgruppen aus dem regulären Ausdruck ermöglicht. Die Formatzeichenkette ermöglicht bedingte Einfügungen und einfache Modifikationen.
- Optionen, die an den regulären Ausdruck übergeben werden.
Das folgende Beispiel fügt den Namen der aktuellen Datei ohne Endung ein, also aus foo.txt wird foo.
${TM_FILENAME/(.*)\..+$/$1/}
| | | |
| | | |-> no options
| | |
| | |-> references the contents of the first
| | capture group
| |
| |-> regex to capture everything before
| the final `.suffix`
|
|-> resolves to the filename
Grammatik
Unten ist die EBNF (erweiterte Backus-Naur-Form) für Snippets. Mit \ (Backslash) können Sie $, } und \ maskieren. Innerhalb von Auswahl-Elementen maskiert der Backslash auch Komma- und Pipe-Zeichen.
any ::= tabstop | placeholder | choice | variable | text
tabstop ::= '$' int | '${' int '}'
placeholder ::= '${' int ':' any '}'
choice ::= '${' int '|' text (',' text)* '|}'
variable ::= '$' var | '${' var }'
| '${' var ':' any '}'
| '${' var '/' regex '/' (format | text)+ '/' options '}'
format ::= '$' int | '${' int '}'
| '${' int ':' '/upcase' | '/downcase' | '/capitalize' '}'
| '${' int ':+' if '}'
| '${' int ':?' if ':' else '}'
| '${' int ':-' else '}' | '${' int ':' else '}'
regex ::= JavaScript Regular Expression value (ctor-string)
options ::= JavaScript Regular Expression option (ctor-options)
var ::= [_a-zA-Z] [_a-zA-Z0-9]*
int ::= [0-9]+
text ::= .*
Completion Item Resolve Request ()
Die Anfrage wird vom Client an den Server gesendet, um zusätzliche Informationen für ein gegebenes Vervollständigungselement aufzulösen.
Anfrage:
- method: ‘completionItem/resolve’
- parameter:
CompletionItem
Antwort:
- ergebnis:
CompletionItem - Fehler: Code und Nachricht werden gesetzt, wenn während der Vervollständigungsauflösungsanfrage eine Ausnahme auftritt.
Hover Request ()
Die Hover-Anfrage wird vom Client an den Server gesendet, um Hover-Informationen an einer gegebenen Textdokumentposition anzufordern.
Client Capability:
- Eigenschaftsname (optional):
textDocument.hover - Eigenschaftstyp:
HoverClientCapabilitieswie folgt definiert
export interface HoverClientCapabilities {
/**
* Whether hover supports dynamic registration.
*/
dynamicRegistration?: boolean;
/**
* Client supports the follow content formats for the content
* property. The order describes the preferred format of the client.
*/
contentFormat?: MarkupKind[];
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
hoverProvider - Eigenschaftstyp:
boolean | HoverOptions, wobeiHoverOptionswie folgt definiert ist
export interface HoverOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: HoverRegistrationOptions wie folgt definiert
export interface HoverRegistrationOptions
extends TextDocumentRegistrationOptions, HoverOptions {
}
Anfrage:
- method: ‘textDocument/hover’
- parameter:
HoverParamswie folgt definiert
export interface HoverParams
extends TextDocumentPositionParams, WorkDoneProgressParams {
}
Antwort:
- ergebnis:
Hover|nullwie folgt definiert
/**
* The result of a hover request.
*/
export interface Hover {
/**
* The hover's content
*/
contents: MarkedString | MarkedString[] | MarkupContent;
/**
* An optional range is a range inside a text document
* that is used to visualize a hover, e.g. by changing the background color.
*/
range?: Range;
}
Wobei MarkedString wie folgt definiert ist
/**
* MarkedString can be used to render human readable text.
* It is either a Markdown string or a code-block that provides a language
* and a code snippet. The language identifier is semantically equal to the
* optional language identifier in fenced code blocks in GitHub issues.
*
* The pair of a language and a value is an equivalent to Markdown:
* ```${language}
* ${value}
* ```
*
* Note that Markdown strings will be sanitized, meaning HTML will be escaped.
* @deprecated use MarkupContent instead.
*/
type MarkedString = string | { language: string; value: string };
- Fehler: Code und Nachricht werden gesetzt, wenn während der Hover-Anfrage eine Ausnahme auftritt.
Signature Help Request ()
Die Signaturhilfe-Anfrage wird vom Client an den Server gesendet, um Signaturinformationen an einer gegebenen Cursorposition anzufordern.
Client Capability:
- Eigenschaftsname (optional):
textDocument.signatureHelp - Eigenschaftstyp:
SignatureHelpClientCapabilitieswie folgt definiert
export interface SignatureHelpClientCapabilities {
/**
* Whether signature help supports dynamic registration.
*/
dynamicRegistration?: boolean;
/**
* The client supports the following `SignatureInformation`
* specific properties.
*/
signatureInformation?: {
/**
* 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;
};
};
/**
* The client supports to send additional context information for a
* `textDocument/signatureHelp` request. A client that opts into
* contextSupport will also support the `retriggerCharacters` on
* `SignatureHelpOptions`.
*
* @since 3.15.0
*/
contextSupport?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
signatureHelpProvider - Eigenschaftstyp:
SignatureHelpOptionswie folgt definiert
export interface SignatureHelpOptions extends WorkDoneProgressOptions {
/**
* The characters that trigger signature help
* automatically.
*/
triggerCharacters?: string[];
/**
* List of characters that re-trigger signature help.
*
* These trigger characters are only active when signature help is already
* showing.
* All trigger characters are also counted as re-trigger characters.
*
* @since 3.15.0
*/
retriggerCharacters?: string[];
}
Registrierungsoptionen: SignatureHelpRegistrationOptions wie folgt definiert
export interface SignatureHelpRegistrationOptions
extends TextDocumentRegistrationOptions, SignatureHelpOptions {
}
Anfrage:
- method: ‘textDocument/signatureHelp’
- parameter:
SignatureHelpParamswie folgt definiert
export interface SignatureHelpParams extends TextDocumentPositionParams,
WorkDoneProgressParams {
/**
* The signature help context.
* This is only available if the client specifies to send this using the
* client capability `textDocument.signatureHelp.contextSupport === true`.
*
* @since 3.15.0
*/
context?: SignatureHelpContext;
}
/**
* How a signature help was triggered.
*
* @since 3.15.0
*/
export namespace SignatureHelpTriggerKind {
/**
* Signature help was invoked manually by the user or by a command.
*/
export const Invoked: 1 = 1;
/**
* Signature help was triggered by a trigger character.
*/
export const TriggerCharacter: 2 = 2;
/**
* Signature help was triggered by the cursor moving or
* by the document content changing.
*/
export const ContentChange: 3 = 3;
}
export type SignatureHelpTriggerKind = 1 | 2 | 3;
/**
* Additional information about the context in which a
* signature help request was triggered.
*
* @since 3.15.0
*/
export interface SignatureHelpContext {
/**
* Action that caused signature help to be triggered.
*/
triggerKind: SignatureHelpTriggerKind;
/**
* Character that caused signature help to be triggered.
*
* This is undefined when
* `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter`.
*/
triggerCharacter?: string;
/**
* `true` if signature help was already showing when it was triggered.
*
* Retriggers occur when the signature help is already active and can be
* caused by actions such as typing a trigger character, a cursor move,
* or document content changes.
*/
isRetrigger: boolean;
/**
* The currently active `SignatureHelp`.
*
* The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field
* updated based on the user navigating through available signatures.
*/
activeSignatureHelp?: SignatureHelp;
}
Antwort:
- ergebnis:
SignatureHelp|nullwie folgt definiert
/**
* Signature help represents the signature of something
* callable. There can be multiple signature but only one
* active and only one active parameter.
*/
export interface SignatureHelp {
/**
* One or more signatures. If no signatures are available the signature help
* request should return `null`.
*/
signatures: SignatureInformation[];
/**
* The active signature. If omitted or the value lies outside the
* range of `signatures` the value defaults to zero or is ignore if
* the `SignatureHelp` as no signatures.
*
* Whenever possible implementors should make an active decision about
* the active signature and shouldn't rely on a default value.
*
* In future version of the protocol this property might become
* mandatory to better express this.
*/
activeSignature?: number;
/**
* The active parameter of the active signature. If omitted or the value
* lies outside the range of `signatures[activeSignature].parameters`
* defaults to 0 if the active signature has parameters. If
* the active signature has no parameters it is ignored.
* In future version of the protocol this property might become
* mandatory to better express the active parameter if the
* active signature does have any.
*/
activeParameter?: number;
}
/**
* Represents the signature of something callable. A signature
* can have a label, like a function-name, a doc-comment, and
* a set of parameters.
*/
export interface SignatureInformation {
/**
* The label of this signature. Will be shown in
* the UI.
*/
label: string;
/**
* The human-readable doc-comment of this signature. Will be shown
* in the UI but can be omitted.
*/
documentation?: string | MarkupContent;
/**
* The parameters of this signature.
*/
parameters?: ParameterInformation[];
}
/**
* Represents a parameter of a callable-signature. A parameter can
* have a label and a doc-comment.
*/
export interface ParameterInformation {
/**
* The label of this parameter information.
*
* Either a string or an inclusive start and exclusive end offsets within
* its containing signature label. (see SignatureInformation.label).
* The offsets are based on a UTF-16 string representation
* as `Position` and `Range` does.
*
* *Note*: a label of type string should be a substring of its containing
* signature label. Its intended use case is to highlight the
* parameter label part in the `SignatureInformation.label`.
*/
label: string | [number, number];
/**
* The human-readable doc-comment of this parameter. Will be shown
* in the UI but can be omitted.
*/
documentation?: string | MarkupContent;
}
- Fehler: Code und Nachricht werden gesetzt, wenn während der Signaturhilfe-Anfrage eine Ausnahme auftritt.
Goto Declaration Request ()
Seit Version 3.14.0
Die Anfrage „Zu Deklaration springen“ wird vom Client an den Server gesendet, um die Deklarationsposition eines Symbols an einer gegebenen Textdokumentposition aufzulösen.
Der Ergebnistyp LocationLink[] wurde mit Version 3.14.0 eingeführt und hängt von der entsprechenden Client-Fähigkeit textDocument.declaration.linkSupport ab.
Client Capability:
- Eigenschaftsname (optional):
textDocument.declaration - Eigenschaftstyp:
DeclarationClientCapabilitieswie folgt definiert
export interface DeclarationClientCapabilities {
/**
* Whether declaration supports dynamic registration.
* If this is set to `true`, the client supports the new
* `DeclarationRegistrationOptions` return value for the
* corresponding server capability as well.
*/
dynamicRegistration?: boolean;
/**
* The client supports additional metadata in the form of declaration links.
*/
linkSupport?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
declarationProvider - Eigenschaftstyp:
boolean | DeclarationOptions | DeclarationRegistrationOptions, wobeiDeclarationOptionswie folgt definiert ist
export interface DeclarationOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: DeclarationRegistrationOptions wie folgt definiert
export interface DeclarationRegistrationOptions extends DeclarationOptions,
TextDocumentRegistrationOptions, StaticRegistrationOptions {
}
Anfrage:
- method: ‘textDocument/declaration’
- parameter:
DeclarationParamswie folgt definiert
export interface DeclarationParams extends TextDocumentPositionParams,
WorkDoneProgressParams, PartialResultParams {
}
Antwort:
- Ergebnis:
Location|Location[] |LocationLink[] |null - Teilergebnis:
Location[] |LocationLink[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Deklarationsanfrage auftritt.
Gehe zu Definition Anfrage ()
Die Anfrage "Gehe zu Definition" wird vom Client an den Server gesendet, um die Definitionsstelle eines Symbols an einer gegebenen Textdokumentposition aufzulösen.
Der Ergebnistyp LocationLink[] wurde mit Version 3.14.0 eingeführt und hängt von der entsprechenden Client-Fähigkeit textDocument.definition.linkSupport ab.
Client Capability:
- Eigenschaftsname (optional):
textDocument.definition - Eigenschaftstyp:
DefinitionClientCapabilities, wie folgt definiert:
export interface DefinitionClientCapabilities {
/**
* Whether definition supports dynamic registration.
*/
dynamicRegistration?: boolean;
/**
* The client supports additional metadata in the form of definition links.
*
* @since 3.14.0
*/
linkSupport?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
definitionProvider - Eigenschaftstyp:
boolean | DefinitionOptions, wobeiDefinitionOptionswie folgt definiert ist:
export interface DefinitionOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: DefinitionRegistrationOptions, wie folgt definiert:
export interface DefinitionRegistrationOptions
extends TextDocumentRegistrationOptions, DefinitionOptions {
}
Anfrage:
- method: ‘textDocument/definition’
- Parameter:
DefinitionParams, wie folgt definiert:
export interface DefinitionParams
extends TextDocumentPositionParams, WorkDoneProgressParams,
PartialResultParams {
}
Antwort:
- Ergebnis:
Location|Location[] |LocationLink[] |null - Teilergebnis:
Location[] |LocationLink[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Definitionsanfrage auftritt.
Gehe zu Typdefinition Anfrage ()
Seit Version 3.6.0
Die Anfrage "Gehe zu Typdefinition" wird vom Client an den Server gesendet, um die Typdefinitionsstelle eines Symbols an einer gegebenen Textdokumentposition aufzulösen.
Der Ergebnistyp LocationLink[] wurde mit Version 3.14.0 eingeführt und hängt von der entsprechenden Client-Fähigkeit textDocument.typeDefinition.linkSupport ab.
Client Capability:
- Eigenschaftsname (optional):
textDocument.typeDefinition - Eigenschaftstyp:
TypeDefinitionClientCapabilities, wie folgt definiert:
export interface TypeDefinitionClientCapabilities {
/**
* Whether implementation supports dynamic registration.
* If this is set to `true`, the client supports the new `
* TypeDefinitionRegistrationOptions` 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;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
typeDefinitionProvider - Eigenschaftstyp:
boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions, wobeiTypeDefinitionOptionswie folgt definiert ist:
export interface TypeDefinitionOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: TypeDefinitionRegistrationOptions, wie folgt definiert:
export interface TypeDefinitionRegistrationOptions
extends TextDocumentRegistrationOptions, TypeDefinitionOptions,
StaticRegistrationOptions {
}
Anfrage:
- method: ‘textDocument/typeDefinition’
- Parameter:
TypeDefinitionParams, wie folgt definiert:
export interface TypeDefinitionParams
extends TextDocumentPositionParams, WorkDoneProgressParams,
PartialResultParams {
}
Antwort:
- Ergebnis:
Location|Location[] |LocationLink[] |null - Teilergebnis:
Location[] |LocationLink[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Definitionsanfrage auftritt.
Suche Implementierungsanfrage ()
Seit Version 3.6.0
Die Anfrage "Suche Implementierung" wird vom Client an den Server gesendet, um die Implementierungsstelle eines Symbols an einer gegebenen Textdokumentposition aufzulösen.
Der Ergebnistyp LocationLink[] wurde mit Version 3.14.0 eingeführt und hängt von der entsprechenden Client-Fähigkeit textDocument.implementation.linkSupport ab.
Client Capability:
- Eigenschaftsname (optional):
textDocument.implementation - Eigenschaftstyp:
ImplementationClientCapabilities, wie folgt definiert:
export interface ImplementationClientCapabilities {
/**
* Whether implementation supports dynamic registration.
* If this is set to `true`, the client supports the new
* `ImplementationRegistrationOptions` 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;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
implementationProvider - Eigenschaftstyp:
boolean | ImplementationOptions | ImplementationRegistrationOptions, wobeiImplementationOptionswie folgt definiert ist:
export interface ImplementationOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: ImplementationRegistrationOptions, wie folgt definiert:
export interface ImplementationRegistrationOptions
extends TextDocumentRegistrationOptions, ImplementationOptions,
StaticRegistrationOptions {
}
Anfrage:
- method: ‘textDocument/implementation’
- Parameter:
ImplementationParams, wie folgt definiert:
export interface ImplementationParams extends TextDocumentPositionParams,
WorkDoneProgressParams, PartialResultParams {
}
Antwort:
- Ergebnis:
Location|Location[] |LocationLink[] |null - Teilergebnis:
Location[] |LocationLink[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Definitionsanfrage auftritt.
Suche Referenzanfrage ()
Die Referenzanfrage wird vom Client an den Server gesendet, um projektweite Referenzen für das durch die gegebene Textdokumentposition bezeichnete Symbol aufzulösen.
Client Capability:
- Eigenschaftsname (optional):
textDocument.references - Eigenschaftstyp:
ReferenceClientCapabilities, wie folgt definiert:
export interface ReferenceClientCapabilities {
/**
* Whether references supports dynamic registration.
*/
dynamicRegistration?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
referencesProvider - Eigenschaftstyp:
boolean | ReferenceOptions, wobeiReferenceOptionswie folgt definiert ist:
export interface ReferenceOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: ReferenceRegistrationOptions, wie folgt definiert:
export interface ReferenceRegistrationOptions
extends TextDocumentRegistrationOptions, ReferenceOptions {
}
Anfrage:
- method: ‘textDocument/references’
- Parameter:
ReferenceParams, wie folgt definiert:
export interface ReferenceParams extends TextDocumentPositionParams,
WorkDoneProgressParams, PartialResultParams {
context: ReferenceContext
}
export interface ReferenceContext {
/**
* Include the declaration of the current symbol.
*/
includeDeclaration: boolean;
}
Antwort:
- Ergebnis:
Location[] |null - Teilergebnis:
Location[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Referenzanfrage auftritt.
Dokument-Highlights-Anfrage ()
Die Dokument-Highlighting-Anfrage wird vom Client an den Server gesendet, um Dokument-Highlights für eine gegebene Textdokumentposition aufzulösen. Für Programmiersprachen werden hier normalerweise alle Verweise auf das Symbol, das auf diese Datei beschränkt ist, hervorgehoben. Wir haben jedoch 'textDocument/documentHighlight' und 'textDocument/references' als separate Anfragen beibehalten, da ersteres auch unscharfe Übereinstimmungen zulässt. Symbol-Übereinstimmungen haben normalerweise einen DocumentHighlightKind von Read oder Write, während unscharfe oder textliche Übereinstimmungen Text als Art verwenden.
Client Capability:
- Eigenschaftsname (optional):
textDocument.documentHighlight - Eigenschaftstyp:
DocumentHighlightClientCapabilities, wie folgt definiert:
export interface DocumentHighlightClientCapabilities {
/**
* Whether document highlight supports dynamic registration.
*/
dynamicRegistration?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
documentHighlightProvider - Eigenschaftstyp:
boolean | DocumentHighlightOptions, wobeiDocumentHighlightOptionswie folgt definiert ist:
export interface DocumentHighlightOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: DocumentHighlightRegistrationOptions, wie folgt definiert:
export interface DocumentHighlightRegistrationOptions
extends TextDocumentRegistrationOptions, DocumentHighlightOptions {
}
Anfrage:
- method: ‘textDocument/documentHighlight’
- Parameter:
DocumentHighlightParams, wie folgt definiert:
export interface DocumentHighlightParams extends TextDocumentPositionParams,
WorkDoneProgressParams, PartialResultParams {
}
Antwort:
- Ergebnis:
DocumentHighlight[]|null, wie folgt definiert:
/**
* A document highlight is a range inside a text document which deserves
* special attention. Usually a document highlight is visualized by changing
* the background color of its range.
*
*/
export interface DocumentHighlight {
/**
* The range this highlight applies to.
*/
range: Range;
/**
* The highlight kind, default is DocumentHighlightKind.Text.
*/
kind?: number;
}
/**
* A document highlight kind.
*/
export namespace DocumentHighlightKind {
/**
* A textual occurrence.
*/
export const Text = 1;
/**
* Read-access of a symbol, like reading a variable.
*/
export const Read = 2;
/**
* Write-access of a symbol, like writing to a variable.
*/
export const Write = 3;
}
- Teilergebnis:
DocumentHighlight[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Dokument-Highlight-Anfrage auftritt.
Dokument-Symbole-Anfrage ()
Die Dokument-Symbole-Anfrage wird vom Client an den Server gesendet. Das zurückgegebene Ergebnis ist entweder
-
SymbolInformation[], eine flache Liste aller in einem gegebenen Textdokument gefundenen Symbole. Dann sollten weder der Standortbereich noch der Containername des Symbols verwendet werden, um eine Hierarchie abzuleiten. -
DocumentSymbol[], eine Hierarchie von Symbolen, die in einem gegebenen Textdokument gefunden wurden.
Client Capability:
- Eigenschaftsname (optional):
textDocument.documentSymbol - Eigenschaftstyp:
DocumentSymbolClientCapabilities, wie folgt definiert:
export interface DocumentSymbolClientCapabilities {
/**
* Whether document symbol supports dynamic registration.
*/
dynamicRegistration?: boolean;
/**
* Specific capabilities for the `SymbolKind` in the
* `textDocument/documentSymbol` 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[];
}
/**
* The client supports hierarchical document symbols.
*/
hierarchicalDocumentSymbolSupport?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
documentSymbolProvider - Eigenschaftstyp:
boolean | DocumentSymbolOptions, wobeiDocumentSymbolOptionswie folgt definiert ist:
export interface DocumentSymbolOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: DocumentSymbolRegistrationOptions, wie folgt definiert:
export interface DocumentSymbolRegistrationOptions
extends TextDocumentRegistrationOptions, DocumentSymbolOptions {
}
Anfrage:
- method: ‘textDocument/documentSymbol’
- Parameter:
DocumentSymbolParams, wie folgt definiert:
export interface DocumentSymbolParams
extends WorkDoneProgressParams, PartialResultParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
}
Antwort:
- Ergebnis:
DocumentSymbol[]|SymbolInformation[]|null, wie folgt definiert:
/**
* A symbol kind.
*/
export namespace SymbolKind {
export const File = 1;
export const Module = 2;
export const Namespace = 3;
export const Package = 4;
export const Class = 5;
export const Method = 6;
export const Property = 7;
export const Field = 8;
export const Constructor = 9;
export const Enum = 10;
export const Interface = 11;
export const Function = 12;
export const Variable = 13;
export const Constant = 14;
export const String = 15;
export const Number = 16;
export const Boolean = 17;
export const Array = 18;
export const Object = 19;
export const Key = 20;
export const Null = 21;
export const EnumMember = 22;
export const Struct = 23;
export const Event = 24;
export const Operator = 25;
export const TypeParameter = 26;
}
/**
* Represents programming constructs like variables, classes, interfaces etc.
* that appear in a document. Document symbols can be hierarchical and they
* have two ranges: one that encloses its definition and one that points to
* its most interesting range, for example, the range of an identifier.
*/
export interface DocumentSymbol {
/**
* The name of this symbol.
* Will be displayed in the user interface and therefore must not be
* an empty string or a string only consisting of white spaces.
*/
name: string;
/**
* More detail for this symbol, e.g the signature of a function.
*/
detail?: string;
/**
* The kind of this symbol.
*/
kind: SymbolKind;
/**
* Indicates if this symbol is deprecated.
*/
deprecated?: boolean;
/**
* The range enclosing this symbol not including leading/trailing
* whitespace but everything else like comments.
* This information is typically used to determine if the client's cursor
* is inside the symbol to reveal it in the UI.
*/
range: Range;
/**
* The range that should be selected and revealed when this symbol
* is being picked, for example, the name of a function.
* Must be contained by the `range`.
*/
selectionRange: Range;
/**
* Children of this symbol, e.g. properties of a class.
*/
children?: DocumentSymbol[];
}
/**
* Represents information about programming constructs like variables, classes,
* interfaces etc.
*/
export interface SymbolInformation {
/**
* The name of this symbol.
*/
name: string;
/**
* The kind of this symbol.
*/
kind: SymbolKind;
/**
* Indicates if this symbol is deprecated.
*/
deprecated?: boolean;
/**
* The location of this symbol. The location's range is used by a tool
* to reveal the location in the editor. If the symbol is selected in the
* tool the range's start information is used to position the cursor. So
* the range usually spans more then the actual symbol's name and does
* normally include things like visibility modifiers.
*
* The range doesn't have to denote a node range in the sense of an abstract
* syntax tree. It can therefore not be used to re-construct a hierarchy of
* the symbols.
*/
location: Location;
/**
* The name of the symbol containing this symbol. This information is for
* user interface purposes (e.g. to render a qualifier in the user interface
* if necessary). It can't be used to re-infer a hierarchy for the document
* symbols.
*/
containerName?: string;
}
- Teilergebnis:
DocumentSymbol[]|SymbolInformation[].DocumentSymbol[]undSymbolInformation[]können nicht gemischt werden. Das bedeutet, dass der erste Block den Typ aller anderen Blöcke definiert. - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Dokument-Symbole-Anfrage auftritt.
Code-Aktion-Anfrage ()
Die Code-Aktions-Anfrage wird vom Client an den Server gesendet, um Befehle für ein gegebenes Textdokument und einen Bereich zu berechnen. Diese Befehle sind typischerweise Code-Fixes, um entweder Probleme zu beheben oder Code zu verschönern/refaktorisieren. Das Ergebnis einer textDocument/codeAction-Anfrage ist ein Array von Command-Literalen, die typischerweise in der Benutzeroberfläche präsentiert werden. Um sicherzustellen, dass ein Server in vielen Clients nützlich ist, sollten die in den Code-Aktionen angegebenen Befehle vom Server und nicht vom Client verarbeitet werden (siehe workspace/executeCommand und ServerCapabilities.executeCommandProvider). Wenn der Client die Bereitstellung von Bearbeitungen mit einer Code-Aktion unterstützt, sollte der Modus verwendet werden.
Wenn der Befehl ausgewählt wird, sollte der Server erneut kontaktiert werden (über die workspace/executeCommand)-Anfrage, um den Befehl auszuführen.
Seit Version 3.8.0: Unterstützung für CodeAction-Literale zur Ermöglichung der folgenden Szenarien:
- die Möglichkeit, eine Workspace-Änderung direkt von der Code-Aktions-Anfrage zurückzugeben. Dies vermeidet einen weiteren Server-Roundtrip zur Ausführung einer tatsächlichen Code-Aktion. Serveranbieter sollten sich jedoch bewusst sein, dass es immer noch vorteilhaft sein kann, wenn das Ergebnis einfach ein Befehl ist und die tatsächliche Änderung nur bei Bedarf berechnet wird, wenn die Code-Aktion teuer zu berechnen ist oder die Änderungen sehr groß sind.
- die Möglichkeit, Code-Aktionen mithilfe einer Art zu gruppieren. Clients dürfen diese Informationen ignorieren. Sie ermöglicht es ihnen jedoch, Code-Aktionen besser zu gruppieren, z. B. in entsprechende Menüs (z. B. alle Refactor-Code-Aktionen in ein Refactor-Menü).
Clients müssen ihre Unterstützung für Code-Aktions-Literale (z. B. Literale vom Typ CodeAction) und Code-Aktions-Arten über die entsprechende Client-Fähigkeit codeAction.codeActionLiteralSupport ankündigen.
Client Capability:
- Eigenschaftsname (optional):
textDocument.codeAction - Eigenschaftstyp:
CodeActionClientCapabilities, wie folgt definiert:
export interface CodeActionClientCapabilities {
/**
* Whether code action supports dynamic registration.
*/
dynamicRegistration?: boolean;
/**
* The client supports code action literals as a valid
* response of the `textDocument/codeAction` request.
*
* @since 3.8.0
*/
codeActionLiteralSupport?: {
/**
* The code action kind is supported 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[];
};
};
/**
* Whether code action supports the `isPreferred` property.
* @since 3.15.0
*/
isPreferredSupport?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
codeActionProvider - Eigenschaftstyp:
boolean | CodeActionOptions, wobeiCodeActionOptionswie folgt definiert ist:
export interface CodeActionOptions extends WorkDoneProgressOptions {
/**
* 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[];
}
Registrierungsoptionen: CodeActionRegistrationOptions, wie folgt definiert:
export interface CodeActionRegistrationOptions
extends TextDocumentRegistrationOptions, CodeActionOptions {
}
Anfrage:
- method: ‘textDocument/codeAction’
- Parameter:
CodeActionParams, wie folgt definiert:
/**
* Params for the CodeActionRequest
*/
export interface CodeActionParams
extends WorkDoneProgressParams, PartialResultParams {
/**
* The document in which the command was invoked.
*/
textDocument: TextDocumentIdentifier;
/**
* The range for which the command was invoked.
*/
range: Range;
/**
* Context carrying additional information.
*/
context: CodeActionContext;
}
/**
* The kind of a code action.
*
* Kinds are a hierarchical list of identifiers separated by `.`,
* e.g. `"refactor.extract.function"`.
*
* The set of kinds is open and the client needs to announce the kinds it
* supports to the server during initialization.
*/
export type CodeActionKind = string;
/**
* A set of predefined code action kinds.
*/
export namespace CodeActionKind {
/**
* Empty kind.
*/
export const Empty: CodeActionKind = '';
/**
* Base kind for quickfix actions: 'quickfix'.
*/
export const QuickFix: CodeActionKind = 'quickfix';
/**
* Base kind for refactoring actions: 'refactor'.
*/
export const Refactor: CodeActionKind = 'refactor';
/**
* Base kind for refactoring extraction actions: 'refactor.extract'.
*
* Example extract actions:
*
* - Extract method
* - Extract function
* - Extract variable
* - Extract interface from class
* - ...
*/
export const RefactorExtract: CodeActionKind = 'refactor.extract';
/**
* Base kind for refactoring inline actions: 'refactor.inline'.
*
* Example inline actions:
*
* - Inline function
* - Inline variable
* - Inline constant
* - ...
*/
export const RefactorInline: CodeActionKind = 'refactor.inline';
/**
* Base kind for refactoring rewrite actions: 'refactor.rewrite'.
*
* Example rewrite actions:
*
* - Convert JavaScript function to class
* - Add or remove parameter
* - Encapsulate field
* - Make method static
* - Move method to base class
* - ...
*/
export const RefactorRewrite: CodeActionKind = 'refactor.rewrite';
/**
* Base kind for source actions: `source`.
*
* Source code actions apply to the entire file.
*/
export const Source: CodeActionKind = 'source';
/**
* Base kind for an organize imports source action `source.organizeImports`.
*/
export const SourceOrganizeImports: CodeActionKind
= 'source.organizeImports';
}
/**
* Contains additional diagnostic information about the context in which
* a code action is run.
*/
export interface CodeActionContext {
/**
* 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.
*/
diagnostics: Diagnostic[];
/**
* 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.
*/
only?: CodeActionKind[];
}
Antwort:
- Ergebnis:
(Command | CodeAction)[]|null, wobeiCodeActionwie folgt definiert ist:
/**
* A code action represents a change that can be performed in code.
* For example, to fix a problem or to refactor code.
*
* A CodeAction must set either `edit` and/or a `command`.
* If both are supplied, the `edit` is applied first, then the `command`
* is executed.
*/
export interface CodeAction {
/**
* A short, human-readable, title for this code action.
*/
title: string;
/**
* The kind of the code action.
*
* Used to filter code actions.
*/
kind?: CodeActionKind;
/**
* The diagnostics that this code action resolves.
*/
diagnostics?: Diagnostic[];
/**
* 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.
*
* @since 3.15.0
*/
isPreferred?: boolean;
/**
* The workspace edit this code action performs.
*/
edit?: WorkspaceEdit;
/**
* 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.
*/
command?: Command;
}
- Teilergebnis:
(Command | CodeAction)[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Code-Aktion-Anfrage auftritt.
Code-Lens-Anfrage ()
Die CodeLens-Anfrage wird vom Client an den Server gesendet, um CodeLens für ein gegebenes Textdokument zu berechnen.
Client Capability:
- Eigenschaftsname (optional):
textDocument.codeLens - Eigenschaftstyp:
CodeLensClientCapabilities, wie folgt definiert:
export interface CodeLensClientCapabilities {
/**
* Whether CodeLens supports dynamic registration.
*/
dynamicRegistration?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
codeLensProvider - Eigenschaftstyp:
CodeLensOptions, wie folgt definiert:
export interface CodeLensOptions extends WorkDoneProgressOptions {
/**
* Code lens has a resolve provider as well.
*/
resolveProvider?: boolean;
}
Registrierungsoptionen: CodeLensRegistrationOptions, wie folgt definiert:
export interface CodeLensRegistrationOptions
extends TextDocumentRegistrationOptions, CodeLensOptions {
}
Anfrage:
- method: ‘textDocument/codeLens’
- Parameter:
CodeLensParams, wie folgt definiert:
interface CodeLensParams extends WorkDoneProgressParams, PartialResultParams {
/**
* The document to request CodeLens for.
*/
textDocument: TextDocumentIdentifier;
}
Antwort:
- Ergebnis:
CodeLens[]|null, wie folgt definiert:
/**
* A CodeLense represents a command that should be shown along with
* source text, like the number of references, a way to run tests, etc.
*
* A CodeLens is _unresolved_ when no command is associated to it.
* For performance reasons, the creation of a CodeLens and resolving should
* be done in two stages.
*/
interface CodeLens {
/**
* The range in which the CodeLens is valid. Should only span a single line.
*/
range: Range;
/**
* The command this CodeLens represents.
*/
command?: Command;
/**
* A data entry field that is preserved on a CodeLens item between
* a CodeLens and a CodeLens resolve request.
*/
data?: any
}
- Teilergebnis:
CodeLens[] - error: code und message, gesetzt im Falle einer Ausnahme während der CodeLens-Anfrage.
Code-Lens-Auflösungsanfrage ()
Die CodeLens-Resolve-Anfrage wird vom Client an den Server gesendet, um den Befehl für ein gegebenes CodeLens-Element aufzulösen.
Anfrage:
- method: ‘codeLens/resolve’
- Parameter:
CodeLens
Antwort:
- Ergebnis:
CodeLens - error: code und message, gesetzt im Falle einer Ausnahme während der CodeLens-Resolve-Anfrage.
Dokument-Link-Anfrage ()
Die Dokument-Link-Anfrage wird vom Client an den Server gesendet, um die Position von Links in einem Dokument anzufordern.
Client Capability:
- Eigenschaftsname (optional):
textDocument.documentLink - Eigenschaftstyp:
DocumentLinkClientCapabilities, wie folgt definiert:
export interface DocumentLinkClientCapabilities {
/**
* Whether document link supports dynamic registration.
*/
dynamicRegistration?: boolean;
/**
* Whether the client supports the `tooltip` property on `DocumentLink`.
*
* @since 3.15.0
*/
tooltipSupport?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
documentLinkProvider - Eigenschaftstyp:
DocumentLinkOptions, wie folgt definiert:
export interface DocumentLinkOptions extends WorkDoneProgressOptions {
/**
* Document links have a resolve provider as well.
*/
resolveProvider?: boolean;
}
Registrierungsoptionen: DocumentLinkRegistrationOptions, wie folgt definiert:
export interface DocumentLinkRegistrationOptions
extends TextDocumentRegistrationOptions, DocumentLinkOptions {
}
Anfrage:
- method: ‘textDocument/documentLink’
- Parameter:
DocumentLinkParams, wie folgt definiert:
interface DocumentLinkParams
extends WorkDoneProgressParams, PartialResultParams {
/**
* The document to provide document links for.
*/
textDocument: TextDocumentIdentifier;
}
Antwort:
- Ergebnis:
DocumentLink[]|null.
/**
* A document link is a range in a text document that links to an internal
* or external resource, like another text document or a web site.
*/
interface DocumentLink {
/**
* The range this link applies to.
*/
range: Range;
/**
* The uri this link points to. If missing a resolve request is sent later.
*/
target?: DocumentUri;
/**
* The tooltip text when you hover over this link.
*
* If a tooltip is provided, it will be displayed in a string that
* includes instructions on how to trigger the link,
* such as `{0} (ctrl + click)`.
* The specific instructions vary depending on OS, user settings,
* and localization.
*
* @since 3.15.0
*/
tooltip?: string;
/**
* A data entry field that is preserved on a document link between a
* DocumentLinkRequest and a DocumentLinkResolveRequest.
*/
data?: any;
}
- Teilergebnis:
DocumentLink[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Dokument-Link-Anfrage auftritt.
Dokument-Link-Auflösungsanfrage ()
Die Dokument-Link-Auflösungsanfrage wird vom Client an den Server gesendet, um das Ziel eines gegebenen Dokument-Links aufzulösen.
Anfrage:
- method: ‘documentLink/resolve’
- Parameter:
DocumentLink
Antwort:
- Ergebnis:
DocumentLink - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Dokument-Link-Auflösungsanfrage auftritt.
Dokument-Farbanfrage ()
Seit Version 3.6.0
Die Dokument-Farbanfrage wird vom Client an den Server gesendet, um alle Farbverweise in einem gegebenen Textdokument aufzulisten. Zusammen mit dem Bereich wird ein Farbwert in RGB zurückgegeben.
Clients können das Ergebnis verwenden, um Farbverweise in einem Editor zu dekorieren. Zum Beispiel:
- Farbkästen, die die tatsächliche Farbe neben dem Verweis anzeigen
- Farbwähler anzeigen, wenn ein Farbverweis bearbeitet wird
Client Capability:
- Eigenschaftsname (optional):
textDocument.colorProvider - Eigenschaftstyp:
DocumentColorClientCapabilities, wie folgt definiert:
export interface DocumentColorClientCapabilities {
/**
* Whether document color supports dynamic registration.
*/
dynamicRegistration?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
colorProvider - Eigenschaftstyp:
boolean | DocumentColorOptions | DocumentColorRegistrationOptions, wobeiDocumentColorOptionswie folgt definiert ist:
export interface DocumentColorOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: DocumentColorRegistrationOptions, wie folgt definiert:
export interface DocumentColorRegistrationOptions
extends TextDocumentRegistrationOptions, StaticRegistrationOptions,
DocumentColorOptions {
}
Anfrage:
- method: ‘textDocument/documentColor’
- Parameter:
DocumentColorParams, wie folgt definiert:
interface DocumentColorParams
extends WorkDoneProgressParams, PartialResultParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
}
Antwort:
- Ergebnis:
ColorInformation[], wie folgt definiert:
interface ColorInformation {
/**
* The range in the document where this color appears.
*/
range: Range;
/**
* The actual color value for this color range.
*/
color: Color;
}
/**
* Represents a color in RGBA space.
*/
interface Color {
/**
* The red component of this color in the range [0-1].
*/
readonly red: number;
/**
* The green component of this color in the range [0-1].
*/
readonly green: number;
/**
* The blue component of this color in the range [0-1].
*/
readonly blue: number;
/**
* The alpha component of this color in the range [0-1].
*/
readonly alpha: number;
}
- Teilergebnis:
ColorInformation[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der `textDocument/documentColor`-Anfrage auftritt.
Farbpräsentationsanfrage ()
Seit Version 3.6.0
Die Farbpräsentationsanfrage wird vom Client an den Server gesendet, um eine Liste von Präsentationen für einen Farbwert an einem gegebenen Ort zu erhalten. Clients können das Ergebnis verwenden, um
- einen Farbverweis zu ändern.
- in einem Farbwähler anzuzeigen und Benutzern die Auswahl einer der Präsentationen zu ermöglichen
Diese Anfrage hat keine speziellen Fähigkeiten und Registrierungsoptionen, da sie als Auflösungsanfrage für die `textDocument/documentColor`-Anfrage gesendet wird.
Anfrage:
- method: ‘textDocument/colorPresentation’
- Parameter:
ColorPresentationParams, wie folgt definiert:
interface ColorPresentationParams
extends WorkDoneProgressParams, PartialResultParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The color information to request presentations for.
*/
color: Color;
/**
* The range where the color would be inserted. Serves as a context.
*/
range: Range;
}
Antwort:
- Ergebnis:
ColorPresentation[], wie folgt definiert:
interface ColorPresentation {
/**
* The label of this color presentation. It will be shown on the color
* picker header.
* By default, this is also the text that is inserted when selecting
* this color presentation.
*/
label: string;
/**
* An [edit](#TextEdit) which is applied to a document when selecting
* this presentation for the color.
* When `falsy`, the [label](#ColorPresentation.label) is used.
*/
textEdit?: TextEdit;
/**
* An optional array of additional [text edits](#TextEdit) that are
* applied when selecting this color presentation.
* Edits must not overlap with the main [edit](#ColorPresentation.textEdit)
* nor with themselves.
*/
additionalTextEdits?: TextEdit[];
}
- Teilergebnis:
ColorPresentation[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der `textDocument/colorPresentation`-Anfrage auftritt.
Dokumentformatierungsanfrage ()
Die Dokumentformatierungsanfrage wird vom Client an den Server gesendet, um ein ganzes Dokument zu formatieren.
Client Capability:
- Eigenschaftsname (optional):
textDocument.formatting - Eigenschaftstyp:
DocumentFormattingClientCapabilities, wie folgt definiert:
export interface DocumentFormattingClientCapabilities {
/**
* Whether formatting supports dynamic registration.
*/
dynamicRegistration?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
documentFormattingProvider - Eigenschaftstyp:
boolean | DocumentFormattingOptions, wobeiDocumentFormattingOptionswie folgt definiert ist:
export interface DocumentFormattingOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: DocumentFormattingRegistrationOptions, wie folgt definiert:
export interface DocumentFormattingRegistrationOptions
extends TextDocumentRegistrationOptions, DocumentFormattingOptions {
}
Anfrage:
- method: ‘textDocument/formatting’
- Parameter:
DocumentFormattingParams, wie folgt definiert:
interface DocumentFormattingParams extends WorkDoneProgressParams {
/**
* The document to format.
*/
textDocument: TextDocumentIdentifier;
/**
* The format options.
*/
options: FormattingOptions;
}
/**
* Value-object describing what options formatting should use.
*/
interface FormattingOptions {
/**
* Size of a tab in spaces.
*/
tabSize: number;
/**
* Prefer spaces over tabs.
*/
insertSpaces: boolean;
/**
* Trim trailing whitespace on a line.
*
* @since 3.15.0
*/
trimTrailingWhitespace?: boolean;
/**
* Insert a newline character at the end of the file if one does not exist.
*
* @since 3.15.0
*/
insertFinalNewline?: boolean;
/**
* Trim all newlines after the final newline at the end of the file.
*
* @since 3.15.0
*/
trimFinalNewlines?: boolean;
/**
* Signature for further properties.
*/
[key: string]: boolean | number | string;
}
Antwort:
- Ergebnis:
TextEdit[]|null, beschreibt die Änderung am zu formatierenden Dokument. - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Formatierungsanfrage auftritt.
Dokument-Bereichsformatierungsanfrage ()
Die Dokument-Bereichsformatierungsanfrage wird vom Client an den Server gesendet, um einen gegebenen Bereich in einem Dokument zu formatieren.
Client Capability:
- Eigenschaftsname (optional):
textDocument.rangeFormatting - Eigenschaftstyp:
DocumentRangeFormattingClientCapabilities, wie folgt definiert:
export interface DocumentRangeFormattingClientCapabilities {
/**
* Whether formatting supports dynamic registration.
*/
dynamicRegistration?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
documentRangeFormattingProvider - Eigenschaftstyp:
boolean | DocumentRangeFormattingOptions, wobeiDocumentRangeFormattingOptionswie folgt definiert ist:
export interface DocumentRangeFormattingOptions
extends WorkDoneProgressOptions {
}
Registrierungsoptionen: DocumentFormattingRegistrationOptions, wie folgt definiert:
export interface DocumentRangeFormattingRegistrationOptions
extends TextDocumentRegistrationOptions, DocumentRangeFormattingOptions {
}
Anfrage:
- method: ‘textDocument/rangeFormatting’,
- Parameter:
DocumentRangeFormattingParams, wie folgt definiert:
interface DocumentRangeFormattingParams extends WorkDoneProgressParams {
/**
* The document to format.
*/
textDocument: TextDocumentIdentifier;
/**
* The range to format
*/
range: Range;
/**
* The format options
*/
options: FormattingOptions;
}
Antwort:
- Ergebnis:
TextEdit[]|null, beschreibt die Änderung am zu formatierenden Dokument. - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Bereichsformatierungsanfrage auftritt.
Dokument-Formatierungsanfrage bei Tippen ()
Die Dokument-Formatierungsanfrage bei Tippen wird vom Client an den Server gesendet, um Teile des Dokuments während des Tippens zu formatieren.
Client Capability:
- Eigenschaftsname (optional):
textDocument.onTypeFormatting - Eigenschaftstyp:
DocumentOnTypeFormattingClientCapabilities, wie folgt definiert:
export interface DocumentOnTypeFormattingClientCapabilities {
/**
* Whether on type formatting supports dynamic registration.
*/
dynamicRegistration?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
documentOnTypeFormattingProvider - Eigenschaftstyp:
DocumentOnTypeFormattingOptions, wie folgt definiert:
export interface DocumentOnTypeFormattingOptions {
/**
* A character on which formatting should be triggered, like `}`.
*/
firstTriggerCharacter: string;
/**
* More trigger characters.
*/
moreTriggerCharacter?: string[];
}
Registrierungsoptionen: DocumentOnTypeFormattingRegistrationOptions, wie folgt definiert:
export interface DocumentOnTypeFormattingRegistrationOptions
extends TextDocumentRegistrationOptions, DocumentOnTypeFormattingOptions {
}
Anfrage:
- method: ‘textDocument/onTypeFormatting’
- Parameter:
DocumentOnTypeFormattingParams, wie folgt definiert:
interface DocumentOnTypeFormattingParams extends TextDocumentPositionParams {
/**
* The character that has been typed.
*/
ch: string;
/**
* The format options.
*/
options: FormattingOptions;
}
Antwort:
- Ergebnis:
TextEdit[]|null, beschreibt die Änderung am Dokument. - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der Bereichsformatierungsanfrage auftritt.
Umbenennungsanfrage ()
Die Umbenennungsanfrage wird vom Client an den Server gesendet, um den Server aufzufordern, eine Workspace-Änderung zu berechnen, damit der Client eine projektweite Umbenennung eines Symbols durchführen kann.
Client Capability:
- Eigenschaftsname (optional):
textDocument.rename - Eigenschaftstyp:
RenameClientCapabilities, wie folgt definiert:
export interface RenameClientCapabilities {
/**
* Whether rename supports dynamic registration.
*/
dynamicRegistration?: boolean;
/**
* Client supports testing for validity of rename operations
* before execution.
*
* @since version 3.12.0
*/
prepareSupport?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
renameProvider - Eigenschaftstyp:
boolean | RenameOptions, wobeiRenameOptionswie folgt definiert ist:
RenameOptions kann nur angegeben werden, wenn der Client im Rahmen seiner ersten `initialize`-Anfrage prepareSupport angibt.
export interface RenameOptions extends WorkDoneProgressOptions {
/**
* Renames should be checked and tested before being executed.
*/
prepareProvider?: boolean;
}
Registrierungsoptionen: RenameRegistrationOptions, wie folgt definiert:
export interface RenameRegistrationOptions
extends TextDocumentRegistrationOptions, RenameOptions {
}
Anfrage:
- method: ‘textDocument/rename’
- Parameter:
RenameParams, wie folgt definiert:
interface RenameParams
extends TextDocumentPositionParams, WorkDoneProgressParams {
/**
* The new name of the symbol. If the given name is not valid the
* request must return a [ResponseError](#ResponseError) with an
* appropriate message set.
*/
newName: string;
}
Antwort:
- result:
WorkspaceEdit|null, die die Änderung des Arbeitsbereichs beschreibt. - error: code und message, gesetzt im Falle einer Ausnahme während der Umbenennungsanfrage.
Umbenennung vorbereiten Anfrage ()
Seit Version 3.12.0
Die Umbenennung vorbereiten Anfrage wird vom Client an den Server gesendet, um eine Umbenennungsoperation an einer gegebenen Position vorzubereiten und deren Gültigkeit zu prüfen.
Anfrage:
- method: ‘textDocument/prepareRename’
- Parameter:
PrepareRenameParams, wie folgt definiert:export interface PrepareRenameParams extends TextDocumentPositionParams { }
Antwort:
- result:
Range|{ range: Range, placeholder: string }|null, die den Bereich der umzubenennenden Zeichenkette und optional einen Platzhaltertext für den Inhalt der umzubenennenden Zeichenkette beschreibt. Wennnullzurückgegeben wird, wird angenommen, dass eine 'textDocument/rename'-Anfrage an der gegebenen Position nicht gültig ist. - Fehler: Code und Nachricht werden gesetzt, falls das Element nicht umbenannt werden kann. Clients sollten die Informationen in ihrer Benutzeroberfläche anzeigen.
Faltungsbereichsanfrage ()
Seit Version 3.10.0
Die Faltungsbereichsanfrage wird vom Client an den Server gesendet, um alle Faltungsbereiche in einem gegebenen Textdokument zurückzugeben.
Client Capability:
- Eigenschaftsname (optional):
textDocument.foldingRange - Eigenschaftstyp:
FoldingRangeClientCapabilities, wie folgt definiert:
export interface FoldingRangeClientCapabilities {
/**
* Whether the implementation supports dynamic registration for
* folding range providers.
* If this is set to `true`, the client supports the new
* `FoldingRangeRegistrationOptions` 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, the client will ignore specified `startCharacter` and
* `endCharacter` properties in a FoldingRange.
*/
lineFoldingOnly?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
foldingRangeProvider - Eigenschaftstyp:
boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions, wobeiFoldingRangeOptionswie folgt definiert ist:
export interface FoldingRangeOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: FoldingRangeRegistrationOptions, wie folgt definiert:
export interface FoldingRangeRegistrationOptions
extends TextDocumentRegistrationOptions, FoldingRangeOptions,
StaticRegistrationOptions {
}
Anfrage:
- method: ‘textDocument/foldingRange’
- Parameter:
FoldingRangeParams, wie folgt definiert:
export interface FoldingRangeParams
extends WorkDoneProgressParams, PartialResultParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
}
Antwort:
- Ergebnis:
FoldingRange[] | null, wie folgt definiert:
/**
* Enum of known range kinds
*/
export enum FoldingRangeKind {
/**
* Folding range for a comment
*/
Comment = 'comment',
/**
* Folding range for imports or includes
*/
Imports = 'imports',
/**
* Folding range for a region (e.g. `#region`)
*/
Region = 'region'
}
/**
* Represents a folding range.
*/
export interface FoldingRange {
/**
* The zero-based line number from where the folded range starts.
*/
startLine: number;
/**
* The zero-based character offset from where the folded range starts.
* If not defined, defaults to the length of the start line.
*/
startCharacter?: number;
/**
* The zero-based line number where the folded range ends.
*/
endLine: number;
/**
* The zero-based character offset before the folded range ends.
* If not defined, defaults to the length of the end line.
*/
endCharacter?: number;
/**
* Describes the kind of the folding range such as `comment` or `region`.
* The kind is used to categorize folding ranges and used by commands
* like 'Fold all comments'.
* See [FoldingRangeKind](#FoldingRangeKind) for an enumeration of
* standardized kinds.
*/
kind?: string;
}
- Teilergebnis:
FoldingRange[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der `textDocument/foldingRange`-Anfrage auftritt.
Auswahlbereichsanfrage ()
Seit Version 3.15.0
Die Auswahlbereichsanfrage wird vom Client an den Server gesendet, um vorgeschlagene Auswahlbereiche an einer oder mehreren gegebenen Positionen zurückzugeben. Ein Auswahlbereich ist ein Bereich um die Cursorposition, an dem der Benutzer möglicherweise interessiert ist, ihn auszuwählen.
Ein Auswahlbereich im zurückgegebenen Array entspricht der Position in den übergebenen Parametern am selben Index. Daher muss positions[i] in result[i].range enthalten sein.
Typischerweise, aber nicht notwendigerweise, entsprechen Auswahlbereiche den Knoten des Syntaxbaums.
Client Capability:
- Eigenschaftsname (optional):
textDocument.selectionRange - Eigenschaftstyp:
SelectionRangeClientCapabilities, wie folgt definiert:
export interface SelectionRangeClientCapabilities {
/**
* Whether implementation supports dynamic registration for selection
* range providers.
* If set to `true`, the client supports the new
* `SelectionRangeRegistrationOptions` return value for the corresponding
* server capability as well.
*/
dynamicRegistration?: boolean;
}
Server-Fähigkeit:
- Eigenschaftsname (optional):
selectionRangeProvider - Eigenschaftstyp:
boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions, wobeiSelectionRangeOptionswie folgt definiert ist:
export interface SelectionRangeOptions extends WorkDoneProgressOptions {
}
Registrierungsoptionen: SelectionRangeRegistrationOptions, wie folgt definiert:
export interface SelectionRangeRegistrationOptions
extends SelectionRangeOptions, TextDocumentRegistrationOptions,
StaticRegistrationOptions {
}
Anfrage:
- method: ‘textDocument/selectionRange’
- Parameter:
SelectionRangeParams, wie folgt definiert:
export interface SelectionRangeParams
extends WorkDoneProgressParams, PartialResultParams {
/**
* The text document.
*/
textDocument: TextDocumentIdentifier;
/**
* The positions inside the text document.
*/
positions: Position[];
}
Antwort:
- Ergebnis:
SelectionRange[] | null, wie folgt definiert:
export interface SelectionRange {
/**
* The [range](#Range) of this selection range.
*/
range: Range;
/**
* The parent selection range containing this range.
* Therefore `parent.range` must
* contain `this.range`.
*/
parent?: SelectionRange;
}
- Teilergebnis:
SelectionRange[] - Fehler: Code und Nachricht werden gesetzt, falls eine Ausnahme während der `textDocument/selectionRange`-Anfrage auftritt.
Implementierungsüberlegungen
Sprachserver laufen normalerweise in einem separaten Prozess und Clients kommunizieren asynchron mit ihnen. Darüber hinaus erlauben Clients Benutzern normalerweise, mit dem Quellcode zu interagieren, auch wenn Anforderungsergebnisse ausstehen. Wir empfehlen das folgende Implementierungsmuster, um zu vermeiden, dass Clients veraltete Antwortresultate anwenden
- Wenn ein Client eine Anfrage an den Server sendet und sich der Client-Zustand so ändert, dass das Ergebnis ungültig wird, sollte er die Serveranfrage abbrechen und das Ergebnis ignorieren. Bei Bedarf kann er die Anfrage erneut senden, um ein aktuelles Ergebnis zu erhalten.
- Wenn ein Server eine Zustandsänderung erkennt, die das Ergebnis einer laufenden Anfrage ungültig macht, kann er diese Anfragen mit
ContentModifiedablehnen. Wenn Clients einenContentModified-Fehler erhalten, sollten sie ihn im Allgemeinen nicht für den Endbenutzer in der Benutzeroberfläche anzeigen. Clients können die Anfrage bei Bedarf erneut senden. - Wenn Server in einen inkonsistenten Zustand geraten, sollten sie dies dem Client über die Anfrage
window/logMessagemelden. Wenn sie sich davon nicht erholen können, ist das Beste, was sie derzeit tun können, sich selbst zu beenden. Wir erwägen eine Erweiterung des Protokolls, die es Servern ermöglicht, einen Neustart auf Clientseite anzufordern. - Wenn ein Client feststellt, dass ein Server unerwartet beendet wird, sollte er versuchen, den Server neu zu starten. Clients sollten jedoch vorsichtig sein, einen abstürzenden Server nicht endlos neu zu starten. VS Code startet beispielsweise keinen Server neu, der 5 Mal in den letzten 180 Sekunden abgestürzt ist.
Änderungsprotokoll
3.15.0 (01/14/2020)
- Unterstützung für generisches Fortschrittsreporting hinzufügen.
- Unterstützung für spezifisches Work-Done-Fortschrittsreporting für Anfragen hinzufügen, wo zutreffend.
- Unterstützung für spezifisches Partials-Result-Fortschrittsreporting für Anfragen hinzufügen, wo zutreffend.
- Unterstützung für
textDocument/selectionRangehinzufügen. - Unterstützung für Server- und Client-Informationen hinzufügen.
- Hinzufügen des Signature Help Contexts.
- Erlangen und Elixir zur Liste der unterstützten Programmiersprachen hinzufügen
- Hinzufügen von
versionzuPublishDiagnosticsParams - Unterstützung für
CodeAction#isPreferredhinzufügen. - Unterstützung für
CompletionItem#taghinzufügen. - Unterstützung für
Diagnostic#taghinzufügen. - Unterstützung für
DocumentLink#tooltiphinzufügen. - Hinzufügen von
trimTrailingWhitespace,insertFinalNewlineundtrimFinalNewlineszuFormattingOptions. - Klärung des Parameters
WorkspaceSymbolParams#query.
3.14.0 (12/13/2018)
- Unterstützung für Signature-Label-Offsets hinzufügen.
- Unterstützung für Location Links hinzufügen.
- Unterstützung für die
textDocument/declaration-Anfrage hinzufügen.
3.13.0 (9/11/2018)
- Unterstützung für Datei- und Ordneroperationen (Erstellen, Umbenennen, Verschieben) zu Workspace-Edits hinzufügen.
3.12.0 (8/23/2018)
- Unterstützung für die
textDocument/prepareRename-Anfrage hinzufügen.
3.11.0 (8/21/2018)
- Unterstützung für
CodeActionOptionshinzufügen, damit ein Server eine Liste der unterstützten Code-Aktionen bereitstellen kann.
3.10.0 (7/23/2018)
- Unterstützung für hierarchische Dokumentensymbole als gültige Antwort auf eine
textDocument/documentSymbol-Anfrage hinzufügen. - Unterstützung für Faltenbereiche als gültige Antwort auf eine
textDocument/foldingRange-Anfrage hinzufügen.
3.9.0 (7/10/2018)
- Unterstützung für die
preselect-Eigenschaft inCompletionItemhinzufügen
3.8.0 (6/11/2018)
- Unterstützung für CodeAction-Literale für die
textDocument/codeAction-Anfrage hinzugefügt. - ColorServerCapabilities.colorProvider kann auch ein Boolean sein
- ColorPresentationParams.colorInfo korrigiert zu color (wie in der
d.tsund in Implementierungen)
3.7.0 (4/5/2018)
- Verwandte Informationen zu Diagnostics hinzugefügt.
3.6.0 (2/22/2018)
Zusammenführung des vorgeschlagenen Protokolls für Workspace-Ordner, Konfiguration, Go-to-Type-Definition, Go-to-Implementierung und Document-Color-Provider in den Hauptzweig der Spezifikation. Details siehe
- Workspace-Ordner abrufen
- DidChangeWorkspaceFolders Benachrichtigung
- Konfiguration abrufen
- Go to Type Definition
- Go to Implementation
- Document Color
- Color Presentation
Zusätzlich haben wir CompletionTriggerKind um einen neuen Wert TriggerForIncompleteCompletions: 3 = 3 erweitert, um zu signalisieren, dass eine Completion-Anfrage ausgelöst wurde, seit das letzte Ergebnis unvollständig war.
3.5.0
Entscheidung, diese Version zu überspringen, um die Protokollversionsnummer mit dem npm-Modul vscode-languageserver-protocol in Einklang zu bringen.
3.4.0 (11/27/2017)
3.3.0 (11/24/2017)
- Unterstützung für
CompletionContexthinzugefügt - Unterstützung für
MarkupContenthinzugefügt - Alte New- und Updated-Marker entfernt.
3.2.0 (09/26/2017)
- Optionales
commitCharacters-Property zurCompletionItemhinzugefügt
3.1.0 (02/28/2017)
- Die Änderungen an
WorkspaceEditrückwärtskompatibel gemacht. - Die Spezifikation aktualisiert, um die Breaking Changes von 2.x zu 3.x bezüglich
WorkspaceEditundTextDocumentEditkorrekt zu beschreiben.
3.0 Version
- Hinzufügen von Unterstützung für Client-Feature-Flags, damit Server sich an unterschiedliche Client-Capabilities anpassen können. Ein Beispiel ist die neue
textDocument/willSaveWaitUntil-Anfrage, die nicht alle Clients unterstützen können. Wenn das Feature in den Client-Capabilities, die bei der initialisieren-Anfrage gesendet werden, deaktiviert ist, kann sich der Server nicht darauf verlassen, die Anfrage zu erhalten. - Unterstützung für das Experimentieren mit neuen Features hinzufügen. Der neue Abschnitt
ClientCapabilities.experimentalzusammen mit Feature-Flags ermöglicht es Servern, experimentelle Features bereitzustellen, ohne dass ALLE Clients diese sofort annehmen müssen. - Server können dynamischer auf Client-Funktionen reagieren. Fähigkeiten können jetzt nach der initialisieren-Anfrage mit den neuen
client/registerCapabilityundclient/unregisterCapabilityregistriert und deregistriert werden. Dies ermöglicht es Servern beispielsweise, ohne Neustart auf Einstellungs- oder Konfigurationsänderungen zu reagieren. - Unterstützung für die Benachrichtigung
textDocument/willSaveund die AnfragetextDocument/willSaveWaitUntilhinzufügen. - Unterstützung für die Anfrage
textDocument/documentLinkhinzufügen. - Fügen Sie eine
rootUri-Eigenschaft zu den initializeParams hinzu, zugunsten derrootPath-Eigenschaft.