vscode-languageserver-protocol 3.15.0-next.8 → 3.15.2

package/lib/protocol.selectionRange.js

@@ -5,6 +5,7 @@
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const messages_1 = require("./messages");
 /**
  * A request to provide selection ranges in a document. The request's
  * parameter is of type [SelectionRangeParams](#SelectionRangeParams), the
@@ -13,6 +14,8 @@ const vscode_jsonrpc_1 = require("vscode-jsonrpc");
  */
 var SelectionRangeRequest;
 (function (SelectionRangeRequest) {
-    SelectionRangeRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/selectionRange');
+    SelectionRangeRequest.method = 'textDocument/selectionRange';
+    SelectionRangeRequest.type = new messages_1.ProtocolRequestType(SelectionRangeRequest.method);
+    /** @deprecated  Use SelectionRangeRequest.type */
     SelectionRangeRequest.resultType = new vscode_jsonrpc_1.ProgressType();
 })(SelectionRangeRequest = exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {}));

package/lib/protocol.sematicTokens.proposed.d.ts

@@ -0,0 +1,240 @@
+import { TextDocumentIdentifier, Range } from 'vscode-languageserver-types';
+import { PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions } from './protocol';
+import { ProtocolRequestType } from './messages';
+/**
+ * A set of predefined token types. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0 - Proposed state
+ */
+export declare enum SemanticTokenTypes {
+    comment = "comment",
+    keyword = "keyword",
+    string = "string",
+    number = "number",
+    regexp = "regexp",
+    operator = "operator",
+    namespace = "namespace",
+    type = "type",
+    struct = "struct",
+    class = "class",
+    interface = "interface",
+    enum = "enum",
+    typeParameter = "typeParameter",
+    function = "function",
+    member = "member",
+    property = "property",
+    marco = "marco",
+    variable = "variable",
+    parameter = "parameter",
+    label = "label"
+}
+/**
+ * A set of predefined token modifiers. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0 - Proposed state
+ */
+export declare enum SemanticTokenModifiers {
+    documentation = "documentation",
+    declaration = "declaration",
+    definition = "definition",
+    reference = "reference",
+    static = "static",
+    abstract = "abstract",
+    deprecated = "deprected",
+    async = "async",
+    volatile = "volatile",
+    final = "final"
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensLegend {
+    /**
+     * The token types a server uses.
+     */
+    tokenTypes: string[];
+    /**
+     * The token modifiers a server uses.
+     */
+    tokenModifiers: string[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokens {
+    /**
+     * An optional result id. If provided and clients support delta updating
+     * the client will include the result id in the next semantic token request.
+     * A server can then instead of computing all sematic tokens again simply
+     * send a delta.
+     */
+    resultId?: string;
+    /**
+     * The actual tokens. For a detailed description about how the data is
+     * structured pls see
+     * https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L71
+     */
+    data: number[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export declare namespace SemanticTokens {
+    function is(value: any): value is SemanticTokens;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensPartialResult {
+    data: number[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensEdit {
+    start: number;
+    deleteCount: number;
+    data?: number[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensEdits {
+    readonly resultId?: string;
+    /**
+     * For a detailed description how these edits are structured pls see
+     * https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L131
+     */
+    edits: SemanticTokensEdit[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensEditsPartialResult {
+    edits: SemanticTokensEdit[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensClientCapabilities {
+    /**
+     * The text document client capabilities
+     */
+    textDocument?: {
+        /**
+         * Capabilities specific to the `textDocument/semanticTokens`
+         *
+         * @since 3.16.0 - Proposed state
+         */
+        semanticTokens?: {
+            /**
+             * Whether implementation supports dynamic registration. If this is set to `true`
+             * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+             * return value for the corresponding server capability as well.
+             */
+            dynamicRegistration?: boolean;
+            /**
+             * The token types know by the client.
+             */
+            tokenTypes: string[];
+            /**
+             * The token modifiers know by the client.
+             */
+            tokenModifiers: string[];
+        };
+    };
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensOptions extends WorkDoneProgressOptions {
+    /**
+     * The legend used by the server
+     */
+    legend: SemanticTokensLegend;
+    /**
+     * Server supports providing semantic tokens for a sepcific range
+     * of a document.
+     */
+    rangeProvider?: boolean;
+    /**
+     * Server supports providing semantic tokens for a full document.
+     */
+    documentProvider?: boolean | {
+        /**
+         * The server supports deltas for full documents.
+         */
+        edits?: boolean;
+    };
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensRegistrationOptions extends TextDocumentRegistrationOptions, SemanticTokensOptions, StaticRegistrationOptions {
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensServerCapabilities {
+    semanticTokensProvider: SemanticTokensOptions | SemanticTokensRegistrationOptions;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export declare namespace SemanticTokensRequest {
+    const method: 'textDocument/semanticTokens';
+    const type: ProtocolRequestType<SemanticTokensParams, SemanticTokens | null, SemanticTokensPartialResult, void, SemanticTokensRegistrationOptions>;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensEditsParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The previous result id.
+     */
+    previousResultId: string;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export declare namespace SemanticTokensEditsRequest {
+    const method: 'textDocument/semanticTokens/edits';
+    const type: ProtocolRequestType<SemanticTokensEditsParams, SemanticTokens | SemanticTokensEdits | null, SemanticTokensPartialResult | SemanticTokensEditsPartialResult, void, SemanticTokensRegistrationOptions>;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensRangeParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The range the semantic tokens are requested for.
+     */
+    range: Range;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export declare namespace SemanticTokensRangeRequest {
+    const method: 'textDocument/semanticTokens/range';
+    const type: ProtocolRequestType<SemanticTokensRangeParams, SemanticTokens | null, SemanticTokensPartialResult, void, void>;
+}

package/lib/protocol.sematicTokens.proposed.js

@@ -0,0 +1,93 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const messages_1 = require("./messages");
+/**
+ * A set of predefined token types. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokenTypes;
+(function (SemanticTokenTypes) {
+    SemanticTokenTypes["comment"] = "comment";
+    SemanticTokenTypes["keyword"] = "keyword";
+    SemanticTokenTypes["string"] = "string";
+    SemanticTokenTypes["number"] = "number";
+    SemanticTokenTypes["regexp"] = "regexp";
+    SemanticTokenTypes["operator"] = "operator";
+    SemanticTokenTypes["namespace"] = "namespace";
+    SemanticTokenTypes["type"] = "type";
+    SemanticTokenTypes["struct"] = "struct";
+    SemanticTokenTypes["class"] = "class";
+    SemanticTokenTypes["interface"] = "interface";
+    SemanticTokenTypes["enum"] = "enum";
+    SemanticTokenTypes["typeParameter"] = "typeParameter";
+    SemanticTokenTypes["function"] = "function";
+    SemanticTokenTypes["member"] = "member";
+    SemanticTokenTypes["property"] = "property";
+    SemanticTokenTypes["marco"] = "marco";
+    SemanticTokenTypes["variable"] = "variable";
+    SemanticTokenTypes["parameter"] = "parameter";
+    SemanticTokenTypes["label"] = "label";
+})(SemanticTokenTypes = exports.SemanticTokenTypes || (exports.SemanticTokenTypes = {}));
+/**
+ * A set of predefined token modifiers. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokenModifiers;
+(function (SemanticTokenModifiers) {
+    SemanticTokenModifiers["documentation"] = "documentation";
+    SemanticTokenModifiers["declaration"] = "declaration";
+    SemanticTokenModifiers["definition"] = "definition";
+    SemanticTokenModifiers["reference"] = "reference";
+    SemanticTokenModifiers["static"] = "static";
+    SemanticTokenModifiers["abstract"] = "abstract";
+    SemanticTokenModifiers["deprecated"] = "deprected";
+    SemanticTokenModifiers["async"] = "async";
+    SemanticTokenModifiers["volatile"] = "volatile";
+    SemanticTokenModifiers["final"] = "final";
+})(SemanticTokenModifiers = exports.SemanticTokenModifiers || (exports.SemanticTokenModifiers = {}));
+/**
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokens;
+(function (SemanticTokens) {
+    function is(value) {
+        const candidate = value;
+        return candidate !== undefined && (candidate.resultId === undefined || typeof candidate.resultId === 'string') &&
+            Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === 'number');
+    }
+    SemanticTokens.is = is;
+})(SemanticTokens = exports.SemanticTokens || (exports.SemanticTokens = {}));
+/**
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokensRequest;
+(function (SemanticTokensRequest) {
+    SemanticTokensRequest.method = 'textDocument/semanticTokens';
+    SemanticTokensRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRequest.method);
+})(SemanticTokensRequest = exports.SemanticTokensRequest || (exports.SemanticTokensRequest = {}));
+/**
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokensEditsRequest;
+(function (SemanticTokensEditsRequest) {
+    SemanticTokensEditsRequest.method = 'textDocument/semanticTokens/edits';
+    SemanticTokensEditsRequest.type = new messages_1.ProtocolRequestType(SemanticTokensEditsRequest.method);
+})(SemanticTokensEditsRequest = exports.SemanticTokensEditsRequest || (exports.SemanticTokensEditsRequest = {}));
+/**
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokensRangeRequest;
+(function (SemanticTokensRangeRequest) {
+    SemanticTokensRangeRequest.method = 'textDocument/semanticTokens/range';
+    SemanticTokensRangeRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest.method);
+})(SemanticTokensRangeRequest = exports.SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = {}));

package/lib/protocol.typeDefinition.d.ts

@@ -1,37 +1,27 @@
-import { RequestType, RequestHandler, ProgressType } from 'vscode-jsonrpc';
+import { RequestHandler, ProgressType } from 'vscode-jsonrpc';
 import { Definition, DefinitionLink, LocationLink, Location } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
 import { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+/**
+ * Since 3.6.0
+ */
 export interface TypeDefinitionClientCapabilities {
     /**
-     * The text document client capabilities
+     * 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
      */
-    textDocument?: {
-        /**
-         * Capabilities specific to the `textDocument/typeDefinition`
-         */
-        typeDefinition?: {
-            /**
-             * Whether implementation supports dynamic registration. If this is set to `true`
-             * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
-             * return value for the corresponding server capability as well.
-             */
-            dynamicRegistration?: boolean;
-            /**
-             * The client supports additional metadata in the form of definition links.
-             */
-            linkSupport?: boolean;
-        };
-    };
+    linkSupport?: boolean;
 }
 export interface TypeDefinitionOptions extends WorkDoneProgressOptions {
 }
-export interface TypeDefinitionRegistrationOptions extends TextDocumentRegistrationOptions, TypeDefinitionOptions {
-}
-export interface TypeDefinitionServerCapabilities {
-    /**
-     * The server provides Goto Type Definition support.
-     */
-    typeDefinitionProvider?: boolean | TypeDefinitionOptions | (TypeDefinitionRegistrationOptions & StaticRegistrationOptions);
+export interface TypeDefinitionRegistrationOptions extends TextDocumentRegistrationOptions, TypeDefinitionOptions, StaticRegistrationOptions {
 }
 export interface TypeDefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
 }
@@ -42,7 +32,9 @@ export interface TypeDefinitionParams extends TextDocumentPositionParams, WorkDo
  * Thenable that resolves to such.
  */
 export declare namespace TypeDefinitionRequest {
-    const type: RequestType<TypeDefinitionParams, Location | Location[] | LocationLink[] | null, void, TypeDefinitionRegistrationOptions>;
-    const resultType: ProgressType<Location[] | LocationLink[]>;
+    const method: 'textDocument/typeDefinition';
+    const type: ProtocolRequestType<TypeDefinitionParams, Location | Location[] | LocationLink[] | null, LocationLink[] | Location[], void, TypeDefinitionRegistrationOptions>;
+    /** @deprecated Use TypeDefinitionRequest.type */
+    const resultType: ProgressType<LocationLink[] | Location[]>;
     type HandlerSignature = RequestHandler<TypeDefinitionParams, Definition | DefinitionLink[] | null, void>;
 }

package/lib/protocol.typeDefinition.js

@@ -5,6 +5,7 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const messages_1 = require("./messages");
 // @ts-ignore: to avoid inlining LocatioLink as dynamic import
 let __noDynamicImport;
 /**
@@ -15,6 +16,8 @@ let __noDynamicImport;
  */
 var TypeDefinitionRequest;
 (function (TypeDefinitionRequest) {
-    TypeDefinitionRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/typeDefinition');
+    TypeDefinitionRequest.method = 'textDocument/typeDefinition';
+    TypeDefinitionRequest.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest.method);
+    /** @deprecated Use TypeDefinitionRequest.type */
     TypeDefinitionRequest.resultType = new vscode_jsonrpc_1.ProgressType();
 })(TypeDefinitionRequest = exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {}));

package/lib/protocol.workspaceFolders.d.ts

@@ -1,4 +1,5 @@
-import { RequestType0, RequestHandler0, NotificationType, NotificationHandler, HandlerResult, CancellationToken } from 'vscode-jsonrpc';
+import { RequestHandler0, NotificationHandler, HandlerResult, CancellationToken } from 'vscode-jsonrpc';
+import { ProtocolRequestType0, ProtocolNotificationType } from './messages';
 export interface WorkspaceFoldersInitializeParams {
     /**
      * The actual configured workspace folders.
@@ -46,7 +47,7 @@ export interface WorkspaceFolder {
     uri: string;
     /**
      * The name of the workspace folder. Used to refer to this
-     * workspace folder in thge user interface.
+     * workspace folder in the user interface.
      */
     name: string;
 }
@@ -54,7 +55,7 @@ export interface WorkspaceFolder {
  * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.
  */
 export declare namespace WorkspaceFoldersRequest {
-    const type: RequestType0<WorkspaceFolder[] | null, void, void>;
+    const type: ProtocolRequestType0<WorkspaceFolder[] | null, never, void, void>;
     type HandlerSignature = RequestHandler0<WorkspaceFolder[] | null, void>;
     type MiddlewareSignature = (token: CancellationToken, next: HandlerSignature) => HandlerResult<WorkspaceFolder[] | null, void>;
 }
@@ -63,7 +64,7 @@ export declare namespace WorkspaceFoldersRequest {
  * folder configuration changes.
  */
 export declare namespace DidChangeWorkspaceFoldersNotification {
-    const type: NotificationType<DidChangeWorkspaceFoldersParams, void>;
+    const type: ProtocolNotificationType<DidChangeWorkspaceFoldersParams, void>;
     type HandlerSignature = NotificationHandler<DidChangeWorkspaceFoldersParams>;
     type MiddlewareSignature = (params: DidChangeWorkspaceFoldersParams, next: HandlerSignature) => void;
 }

package/lib/protocol.workspaceFolders.js

@@ -4,13 +4,13 @@
  * ------------------------------------------------------------------------------------------ */
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const messages_1 = require("./messages");
 /**
  * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.
  */
 var WorkspaceFoldersRequest;
 (function (WorkspaceFoldersRequest) {
-    WorkspaceFoldersRequest.type = new vscode_jsonrpc_1.RequestType0('workspace/workspaceFolders');
+    WorkspaceFoldersRequest.type = new messages_1.ProtocolRequestType0('workspace/workspaceFolders');
 })(WorkspaceFoldersRequest = exports.WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = {}));
 /**
  * The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace
@@ -18,5 +18,5 @@ var WorkspaceFoldersRequest;
  */
 var DidChangeWorkspaceFoldersNotification;
 (function (DidChangeWorkspaceFoldersNotification) {
-    DidChangeWorkspaceFoldersNotification.type = new vscode_jsonrpc_1.NotificationType('workspace/didChangeWorkspaceFolders');
+    DidChangeWorkspaceFoldersNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeWorkspaceFolders');
 })(DidChangeWorkspaceFoldersNotification = exports.DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = {}));

package/lib/utils/is.d.ts

@@ -6,5 +6,4 @@ export declare function func(value: any): value is Function;
 export declare function array<T>(value: any): value is T[];
 export declare function stringArray(value: any): value is string[];
 export declare function typedArray<T>(value: any, check: (value: any) => boolean): value is T[];
-export declare function thenable<T>(value: any): value is Thenable<T>;
 export declare function objectLiteral(value: any): value is object;

package/lib/utils/is.js

@@ -36,10 +36,6 @@ function typedArray(value, check) {
     return Array.isArray(value) && value.every(check);
 }
 exports.typedArray = typedArray;
-function thenable(value) {
-    return value && func(value.then);
-}
-exports.thenable = thenable;
 function objectLiteral(value) {
     // Strictly speaking class instances pass this check as well. Since the LSP
     // doesn't use classes we ignore this for now. If we do we need to add something

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "vscode-languageserver-protocol",
 	"description": "VSCode Language Server Protocol implementation",
-	"version": "3.15.0-next.8",
+	"version": "3.15.2",
 	"author": "Microsoft Corporation",
 	"license": "MIT",
 	"repository": {
@@ -15,14 +15,14 @@
 	"main": "./lib/main.js",
 	"typings": "./lib/main",
 	"dependencies": {
-		"vscode-jsonrpc": "^4.1.0-next.3",
-		"vscode-languageserver-types": "^3.15.0-next.4"
+		"vscode-jsonrpc": "^5.0.1",
+		"vscode-languageserver-types": "3.15.1"
 	},
 	"scripts": {
 		"prepublishOnly": "npm run clean && npm run compile && npm test",
 		"postpublish": "node ../build/npm/post-publish.js",
-		"compile": "node ../build/bin/tsc -p ./tsconfig.json",
-		"watch": "node ../build/bin/tsc -w -p ./tsconfig.json",
+		"compile": "node ../build/bin/tsc -b ./tsconfig.json",
+		"watch": "node ../build/bin/tsc -b ./tsconfig.json -w",
 		"test": "node ../node_modules/mocha/bin/_mocha",
 		"clean": "node ../node_modules/rimraf/bin.js lib",
 		"preversion": "npm test"