vscode-languageserver-protocol 3.16.0-next.8 → 3.17.0-next.10

package/lib/browser/main.js

@@ -19,7 +19,7 @@ const browser_1 = require("vscode-jsonrpc/browser");
 __exportStar(require("vscode-jsonrpc/browser"), exports);
 __exportStar(require("../common/api"), exports);
 function createProtocolConnection(reader, writer, logger, options) {
-    return browser_1.createMessageConnection(reader, writer, logger, options);
+    return (0, browser_1.createMessageConnection)(reader, writer, logger, options);
 }
 exports.createProtocolConnection = createProtocolConnection;
 //# sourceMappingURL=main.js.map

package/lib/common/api.d.ts

@@ -1,4 +1,4 @@
-import * as mk from './protocol.moniker.proposed';
+import type { integer } from 'vscode-languageserver-types';
 export * from 'vscode-jsonrpc';
 export * from 'vscode-languageserver-types';
 export * from './messages';
@@ -11,28 +11,91 @@ export declare namespace LSPErrorCodes {
     *
     * @since 3.16.0
     */
-    const lspReservedErrorRangeStart: number;
-    const ContentModified: number;
-    const RequestCancelled: number;
+    const lspReservedErrorRangeStart: integer;
+    /**
+     * A request failed but it was syntactically correct, e.g the
+     * method name was known and the parameters were valid. The error
+     * message should contain human readable information about why
+     * the request failed.
+     *
+     * @since 3.17.0
+     */
+    const RequestFailed: integer;
+    /**
+     * The server cancelled the request. This error code should
+     * only be used for requests that explicitly support being
+     * server cancellable.
+     *
+     * @since 3.17.0
+     */
+    const ServerCancelled: integer;
+    /**
+     * The server detected that the content of a document got
+     * modified outside normal conditions. A server should
+     * NOT send this error code if it detects a content change
+     * in it unprocessed messages. The result even computed
+     * on an older state might still be useful for the client.
+     *
+     * If a client decides that a result is not of any use anymore
+     * the client should cancel the request.
+     */
+    const ContentModified: integer;
+    /**
+     * The client has canceled a request and a server as detected
+     * the cancel.
+     */
+    const RequestCancelled: integer;
     /**
     * This is the end range of LSP reserved error codes.
     * It doesn't denote a real error code.
     *
     * @since 3.16.0
     */
-    const lspReservedErrorRangeEnd: number;
+    const lspReservedErrorRangeEnd: integer;
 }
+import * as diag from './proposed.diagnostic';
+import * as typeh from './proposed.typeHierarchy';
+import * as iv from './proposed.inlineValue';
 export declare namespace Proposed {
-    const UniquenessLevel: typeof mk.UniquenessLevel;
-    const MonikerKind: typeof mk.MonikerKind;
-    type Moniker = mk.Moniker;
-    type MonikerClientCapabilities = mk.MonikerClientCapabilities;
-    type MonikerServerCapabilities = mk.MonikerServerCapabilities;
-    type MonikerOptions = mk.MonikerOptions;
-    type MonikerParams = mk.MonikerParams;
-    type MonikerRegistrationOptions = mk.MonikerRegistrationOptions;
-    namespace MonikerRequest {
-        const method: "textDocument/moniker";
-        const type: import("./messages").ProtocolRequestType<mk.MonikerParams, mk.Moniker[] | null, mk.Moniker[], void, mk.MonikerRegistrationOptions>;
-    }
+    type DiagnosticClientCapabilities = diag.DiagnosticClientCapabilities;
+    type $DiagnosticClientCapabilities = diag.$DiagnosticClientCapabilities;
+    type DiagnosticOptions = diag.DiagnosticOptions;
+    type DiagnosticRegistrationOptions = diag.DiagnosticRegistrationOptions;
+    type $DiagnosticServerCapabilities = diag.$DiagnosticServerCapabilities;
+    type DocumentDiagnosticParams = diag.DocumentDiagnosticParams;
+    type DiagnosticServerCancellationData = diag.DiagnosticServerCancellationData;
+    const DiagnosticServerCancellationData: typeof diag.DiagnosticServerCancellationData;
+    type DocumentDiagnosticReportKind = diag.DocumentDiagnosticReportKind;
+    const DocumentDiagnosticReportKind: typeof diag.DocumentDiagnosticReportKind;
+    type FullDocumentDiagnosticReport = diag.FullDocumentDiagnosticReport;
+    type RelatedFullDocumentDiagnosticReport = diag.RelatedFullDocumentDiagnosticReport;
+    type UnchangedDocumentDiagnosticReport = diag.UnchangedDocumentDiagnosticReport;
+    type RelatedUnchangedDocumentDiagnosticReport = diag.RelatedUnchangedDocumentDiagnosticReport;
+    type DocumentDiagnosticReport = diag.DocumentDiagnosticReport;
+    type DocumentDiagnosticReportPartialResult = diag.DocumentDiagnosticReportPartialResult;
+    const DocumentDiagnosticRequest: typeof diag.DocumentDiagnosticRequest;
+    type PreviousResultId = diag.PreviousResultId;
+    type WorkspaceDiagnosticParams = diag.WorkspaceDiagnosticParams;
+    type WorkspaceFullDocumentDiagnosticReport = diag.WorkspaceFullDocumentDiagnosticReport;
+    type WorkspaceUnchangedDocumentDiagnosticReport = diag.WorkspaceUnchangedDocumentDiagnosticReport;
+    type WorkspaceDocumentDiagnosticReport = diag.WorkspaceDocumentDiagnosticReport;
+    type WorkspaceDiagnosticReport = diag.WorkspaceDiagnosticReport;
+    type WorkspaceDiagnosticReportPartialResult = diag.WorkspaceDiagnosticReportPartialResult;
+    const WorkspaceDiagnosticRequest: typeof diag.WorkspaceDiagnosticRequest;
+    const DiagnosticRefreshRequest: typeof diag.DiagnosticRefreshRequest;
+    type TypeHierarchyClientCapabilities = typeh.TypeHierarchyClientCapabilities;
+    type TypeHierarchyOptions = typeh.TypeHierarchyOptions;
+    type TypeHierarchyRegistrationOptions = typeh.TypeHierarchyRegistrationOptions;
+    type TypeHierarchyPrepareParams = typeh.TypeHierarchyPrepareParams;
+    type TypeHierarchySupertypesParams = typeh.TypeHierarchySupertypesParams;
+    type TypeHierarchySubtypesParams = typeh.TypeHierarchySubtypesParams;
+    const TypeHierarchyPrepareRequest: typeof typeh.TypeHierarchyPrepareRequest;
+    const TypeHierarchySupertypesRequest: typeof typeh.TypeHierarchySupertypesRequest;
+    const TypeHierarchySubtypesRequest: typeof typeh.TypeHierarchySubtypesRequest;
+    type InlineValuesClientCapabilities = iv.InlineValuesClientCapabilities;
+    type InlineValuesOptions = iv.InlineValuesOptions;
+    type InlineValuesRegistrationOptions = iv.InlineValuesRegistrationOptions;
+    type InlineValuesParams = iv.InlineValuesParams;
+    const InlineValuesRequest: typeof iv.InlineValuesRequest;
+    const InlineValuesRefreshRequest: typeof iv.InlineValuesRefreshRequest;
 }

package/lib/common/api.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Proposed = exports.LSPErrorCodes = exports.createProtocolConnection = void 0;
-const mk = require("./protocol.moniker.proposed");
 __exportStar(require("vscode-jsonrpc"), exports);
 __exportStar(require("vscode-languageserver-types"), exports);
 __exportStar(require("./messages"), exports);
@@ -31,7 +30,38 @@ var LSPErrorCodes;
     * @since 3.16.0
     */
     LSPErrorCodes.lspReservedErrorRangeStart = -32899;
+    /**
+     * A request failed but it was syntactically correct, e.g the
+     * method name was known and the parameters were valid. The error
+     * message should contain human readable information about why
+     * the request failed.
+     *
+     * @since 3.17.0
+     */
+    LSPErrorCodes.RequestFailed = -32803;
+    /**
+     * The server cancelled the request. This error code should
+     * only be used for requests that explicitly support being
+     * server cancellable.
+     *
+     * @since 3.17.0
+     */
+    LSPErrorCodes.ServerCancelled = -32802;
+    /**
+     * The server detected that the content of a document got
+     * modified outside normal conditions. A server should
+     * NOT send this error code if it detects a content change
+     * in it unprocessed messages. The result even computed
+     * on an older state might still be useful for the client.
+     *
+     * If a client decides that a result is not of any use anymore
+     * the client should cancel the request.
+     */
     LSPErrorCodes.ContentModified = -32801;
+    /**
+     * The client has canceled a request and a server as detected
+     * the cancel.
+     */
     LSPErrorCodes.RequestCancelled = -32800;
     /**
     * This is the end range of LSP reserved error codes.
@@ -41,14 +71,20 @@ var LSPErrorCodes;
     */
     LSPErrorCodes.lspReservedErrorRangeEnd = -32800;
 })(LSPErrorCodes = exports.LSPErrorCodes || (exports.LSPErrorCodes = {}));
+const diag = require("./proposed.diagnostic");
+const typeh = require("./proposed.typeHierarchy");
+const iv = require("./proposed.inlineValue");
 var Proposed;
 (function (Proposed) {
-    Proposed.UniquenessLevel = mk.UniquenessLevel;
-    Proposed.MonikerKind = mk.MonikerKind;
-    let MonikerRequest;
-    (function (MonikerRequest) {
-        MonikerRequest.method = mk.MonikerRequest.method;
-        MonikerRequest.type = mk.MonikerRequest.type;
-    })(MonikerRequest = Proposed.MonikerRequest || (Proposed.MonikerRequest = {}));
+    Proposed.DiagnosticServerCancellationData = diag.DiagnosticServerCancellationData;
+    Proposed.DocumentDiagnosticReportKind = diag.DocumentDiagnosticReportKind;
+    Proposed.DocumentDiagnosticRequest = diag.DocumentDiagnosticRequest;
+    Proposed.WorkspaceDiagnosticRequest = diag.WorkspaceDiagnosticRequest;
+    Proposed.DiagnosticRefreshRequest = diag.DiagnosticRefreshRequest;
+    Proposed.TypeHierarchyPrepareRequest = typeh.TypeHierarchyPrepareRequest;
+    Proposed.TypeHierarchySupertypesRequest = typeh.TypeHierarchySupertypesRequest;
+    Proposed.TypeHierarchySubtypesRequest = typeh.TypeHierarchySubtypesRequest;
+    Proposed.InlineValuesRequest = iv.InlineValuesRequest;
+    Proposed.InlineValuesRefreshRequest = iv.InlineValuesRefreshRequest;
 })(Proposed = exports.Proposed || (exports.Proposed = {}));
 //# sourceMappingURL=api.js.map

package/lib/common/connection.d.ts

@@ -1,4 +1,5 @@
-import { Message, NotificationMessage, CancellationToken, RequestType0, RequestType, RequestHandler0, RequestHandler, GenericRequestHandler, NotificationType0, NotificationType, NotificationHandler0, NotificationHandler, GenericNotificationHandler, ProgressType, Trace, Tracer, TraceOptions, Disposable, Event, MessageReader, MessageWriter, Logger, ConnectionStrategy, ConnectionOptions } from 'vscode-jsonrpc';
+import { Message, NotificationMessage, CancellationToken, RequestHandler0, RequestHandler, GenericRequestHandler, NotificationHandler0, NotificationHandler, GenericNotificationHandler, ProgressType, Trace, Tracer, TraceOptions, Disposable, Event, MessageReader, MessageWriter, Logger, ConnectionStrategy, ConnectionOptions, RequestType0, RequestType, NotificationType0, NotificationType, MessageSignature } from 'vscode-jsonrpc';
+import { ProtocolRequestType, ProtocolRequestType0, ProtocolNotificationType, ProtocolNotificationType0 } from './messages';
 export interface ProtocolConnection {
     /**
      * Sends a request and returns a promise resolving to the result of the request.
@@ -7,7 +8,8 @@ export interface ProtocolConnection {
      * @param token An optional cancellation token.
      * @returns A promise resolving to the request's result.
      */
-    sendRequest<R, E, RO>(type: RequestType0<R, E, RO>, token?: CancellationToken): Promise<R>;
+    sendRequest<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, token?: CancellationToken): Promise<R>;
+    sendRequest<R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>;
     /**
      * Sends a request and returns a promise resolving to the result of the request.
      *
@@ -16,92 +18,99 @@ export interface ProtocolConnection {
      * @param token An optional cancellation token.
      * @returns A promise resolving to the request's result.
      */
-    sendRequest<P, R, E, RO>(type: RequestType<P, R, E, RO>, params: P, token?: CancellationToken): Promise<R>;
+    sendRequest<P, R, PR, E, RO>(type: ProtocolRequestType<P, R, PR, E, RO>, params: P, token?: CancellationToken): Promise<R>;
+    sendRequest<P, R, E>(type: RequestType<P, R, E>, params: P, token?: CancellationToken): Promise<R>;
     /**
      * Sends a request and returns a promise resolving to the result of the request.
      *
-     * @param method the request's method name.
+     * @param method the message signature or the method name.
      * @param token An optional cancellation token.
      * @returns A promise resolving to the request's result.
      */
-    sendRequest<R>(method: string, token?: CancellationToken): Promise<R>;
+    sendRequest<R>(method: MessageSignature | string, token?: CancellationToken): Promise<R>;
     /**
      * Sends a request and returns a promise resolving to the result of the request.
      *
-     * @param method the request's method name.
+     * @param method the message signature or the method name.
      * @param params The request's parameter.
      * @param token An optional cancellation token.
      * @returns A promise resolving to the request's result.
      */
-    sendRequest<R>(method: string, param: any, token?: CancellationToken): Promise<R>;
+    sendRequest<R>(method: MessageSignature | string, param: any, token?: CancellationToken): Promise<R>;
     /**
      * Installs a request handler.
      *
      * @param type The request type to install the handler for.
      * @param handler The actual handler.
      */
-    onRequest<R, E, RO>(type: RequestType0<R, E, RO>, handler: RequestHandler0<R, E>): void;
+    onRequest<R, PR, E, RO>(type: ProtocolRequestType0<R, PR, E, RO>, handler: RequestHandler0<R, E>): Disposable;
+    onRequest<R, E>(type: RequestType0<R, E>, handler: RequestHandler0<R, E>): Disposable;
     /**
      * Installs a request handler.
      *
      * @param type The request type to install the handler for.
      * @param handler The actual handler.
      */
-    onRequest<P, R, E, RO>(type: RequestType<P, R, E, RO>, handler: RequestHandler<P, R, E>): void;
+    onRequest<P, R, PR, E, RO>(type: ProtocolRequestType<P, R, PR, E, RO>, handler: RequestHandler<P, R, E>): Disposable;
+    onRequest<P, R, E>(type: RequestType<P, R, E>, handler: RequestHandler<P, R, E>): Disposable;
     /**
      * Installs a request handler.
      *
-     * @param methods The method name to install the handler for.
+     * @param methods the message signature or the method name to install a handler for.
      * @param handler The actual handler.
      */
-    onRequest<R, E>(method: string, handler: GenericRequestHandler<R, E>): void;
+    onRequest<R, E>(method: MessageSignature | string, handler: GenericRequestHandler<R, E>): Disposable;
     /**
      * Sends a notification.
      *
      * @param type the notification's type to send.
      */
-    sendNotification<RO>(type: NotificationType0<RO>): void;
+    sendNotification(type: NotificationType0): Promise<void>;
+    sendNotification<RO>(type: ProtocolNotificationType0<RO>): Promise<void>;
     /**
      * Sends a notification.
      *
      * @param type the notification's type to send.
      * @param params the notification's parameters.
      */
-    sendNotification<P, RO>(type: NotificationType<P, RO>, params?: P): void;
+    sendNotification<P, RO>(type: ProtocolNotificationType<P, RO>, params?: P): Promise<void>;
+    sendNotification<P>(type: NotificationType<P>, params?: P): Promise<void>;
     /**
      * Sends a notification.
      *
-     * @param method the notification's method name.
+     * @param method the notification's method signature or the method name.
      */
-    sendNotification(method: string): void;
+    sendNotification(method: MessageSignature | string): Promise<void>;
     /**
      * Sends a notification.
      *
-     * @param method the notification's method name.
+     * @param method the notification's method signature or the method name.
      * @param params the notification's parameters.
      */
-    sendNotification(method: string, params: any): void;
+    sendNotification(method: MessageSignature | string, params: any): Promise<void>;
     /**
      * Installs a notification handler.
      *
      * @param type The notification type to install the handler for.
      * @param handler The actual handler.
      */
-    onNotification<RO>(type: NotificationType0<RO>, handler: NotificationHandler0): void;
+    onNotification<RO>(type: ProtocolNotificationType0<RO>, handler: NotificationHandler0): Disposable;
+    onNotification(type: NotificationType0, handler: NotificationHandler0): Disposable;
     /**
      * Installs a notification handler.
      *
      * @param type The notification type to install the handler for.
      * @param handler The actual handler.
      */
-    onNotification<P, RO>(type: NotificationType<P, RO>, handler: NotificationHandler<P>): void;
+    onNotification<P, RO>(type: ProtocolNotificationType<P, RO>, handler: NotificationHandler<P>): Disposable;
+    onNotification<P>(type: NotificationType<P>, handler: NotificationHandler<P>): Disposable;
     /**
      * Installs a notification handler.
      *
-     * @param methods The method name to install the handler for.
+     * @param methods The message signature or the method name to install the handler for.
      * @param handler The actual handler.
      */
-    onNotification(method: string, handler: GenericNotificationHandler): void;
+    onNotification(method: MessageSignature | string, handler: GenericNotificationHandler): Disposable;
     /**
      * Installs a progress handler for a given token.
      * @param type the progress type
@@ -115,7 +124,7 @@ export interface ProtocolConnection {
      * @param token the token to use
      * @param value the progress value
      */
-    sendProgress<P>(type: ProgressType<P>, token: string | number, value: P): void;
+    sendProgress<P>(type: ProgressType<P>, token: string | number, value: P): Promise<void>;
     /**
      * Enables tracing mode for the connection.
      */
@@ -130,7 +139,7 @@ export interface ProtocolConnection {
      */
     onClose: Event<void>;
     /**
-     * An event emiiter firing when the connection receives a notification that is not
+     * An event emitter firing when the connection receives a notification that is not
      * handled.
      */
     onUnhandledNotification: Event<NotificationMessage>;
@@ -138,6 +147,10 @@ export interface ProtocolConnection {
      * An event emitter firing when the connection got disposed.
      */
     onDispose: Event<void>;
+    /**
+     * Ends the connection.
+     */
+    end(): void;
     /**
      * Actively disposes the connection.
      */

package/lib/common/connection.js

@@ -10,7 +10,7 @@ function createProtocolConnection(input, output, logger, options) {
     if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
         options = { connectionStrategy: options };
     }
-    return vscode_jsonrpc_1.createMessageConnection(input, output, logger, options);
+    return (0, vscode_jsonrpc_1.createMessageConnection)(input, output, logger, options);
 }
 exports.createProtocolConnection = createProtocolConnection;
 //# sourceMappingURL=connection.js.map

package/lib/common/messages.d.ts

@@ -1,15 +1,44 @@
 import { RequestType, RequestType0, NotificationType, NotificationType0, ProgressType, _EM } from 'vscode-jsonrpc';
-export declare class ProtocolRequestType0<R, PR, E, RO> extends RequestType0<R, E, RO> implements ProgressType<PR> {
-    readonly __?: [PR, _EM];
+export declare class RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ____: [RO, _EM] | undefined;
+    readonly method: string;
     constructor(method: string);
 }
-export declare class ProtocolRequestType<P, R, PR, E, RO> extends RequestType<P, R, E, RO> implements ProgressType<PR> {
-    readonly __?: [PR, _EM];
+export declare class ProtocolRequestType0<R, PR, E, RO> extends RequestType0<R, E> implements ProgressType<PR>, RegistrationType<RO> {
+    /**
+     * Clients must not use these properties. They are here to ensure correct typing.
+     * in TypeScript
+     */
+    readonly ___: [PR, RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    readonly _pr: PR | undefined;
     constructor(method: string);
 }
-export declare class ProtocolNotificationType<P, RO> extends NotificationType<P, RO> {
+export declare class ProtocolRequestType<P, R, PR, E, RO> extends RequestType<P, R, E> implements ProgressType<PR>, RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ___: [PR, RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    readonly _pr: PR | undefined;
     constructor(method: string);
 }
-export declare class ProtocolNotificationType0<RO> extends NotificationType0<RO> {
+export declare class ProtocolNotificationType0<RO> extends NotificationType0 implements RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ___: [RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
+    constructor(method: string);
+}
+export declare class ProtocolNotificationType<P, RO> extends NotificationType<P> implements RegistrationType<RO> {
+    /**
+     * Clients must not use this property. It is here to ensure correct typing.
+     */
+    readonly ___: [RO, _EM] | undefined;
+    readonly ____: [RO, _EM] | undefined;
     constructor(method: string);
 }

package/lib/common/messages.js

@@ -4,8 +4,14 @@
  * Licensed under the MIT License. See License.txt in the project root for license information.
  * ------------------------------------------------------------------------------------------ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtocolNotificationType0 = exports.ProtocolNotificationType = exports.ProtocolRequestType = exports.ProtocolRequestType0 = void 0;
+exports.ProtocolNotificationType = exports.ProtocolNotificationType0 = exports.ProtocolRequestType = exports.ProtocolRequestType0 = exports.RegistrationType = void 0;
 const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+class RegistrationType {
+    constructor(method) {
+        this.method = method;
+    }
+}
+exports.RegistrationType = RegistrationType;
 class ProtocolRequestType0 extends vscode_jsonrpc_1.RequestType0 {
     constructor(method) {
         super(method);
@@ -18,16 +24,16 @@ class ProtocolRequestType extends vscode_jsonrpc_1.RequestType {
     }
 }
 exports.ProtocolRequestType = ProtocolRequestType;
-class ProtocolNotificationType extends vscode_jsonrpc_1.NotificationType {
-    constructor(method) {
-        super(method, vscode_jsonrpc_1.ParameterStructures.byName);
-    }
-}
-exports.ProtocolNotificationType = ProtocolNotificationType;
 class ProtocolNotificationType0 extends vscode_jsonrpc_1.NotificationType0 {
     constructor(method) {
         super(method);
     }
 }
 exports.ProtocolNotificationType0 = ProtocolNotificationType0;
+class ProtocolNotificationType extends vscode_jsonrpc_1.NotificationType {
+    constructor(method) {
+        super(method, vscode_jsonrpc_1.ParameterStructures.byName);
+    }
+}
+exports.ProtocolNotificationType = ProtocolNotificationType;
 //# sourceMappingURL=messages.js.map