--- /dev/null
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnection = exports.combineFeatures = exports.combineLanguagesFeatures = exports.combineWorkspaceFeatures = exports.combineWindowFeatures = exports.combineClientFeatures = exports.combineTracerFeatures = exports.combineTelemetryFeatures = exports.combineConsoleFeatures = exports._LanguagesImpl = exports.BulkUnregistration = exports.BulkRegistration = exports.ErrorMessageTracker = exports.TextDocuments = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const Is = require("./utils/is");
+const UUID = require("./utils/uuid");
+const progress_1 = require("./progress");
+const configuration_1 = require("./configuration");
+const workspaceFolders_1 = require("./workspaceFolders");
+const callHierarchy_1 = require("./callHierarchy");
+const semanticTokens_1 = require("./semanticTokens");
+const showDocument_1 = require("./showDocument");
+const fileOperations_1 = require("./fileOperations");
+const linkedEditingRange_1 = require("./linkedEditingRange");
+const moniker_1 = require("./moniker");
+function null2Undefined(value) {
+ if (value === null) {
+ return undefined;
+ }
+ return value;
+}
+/**
+ * A manager for simple text documents
+ */
+class TextDocuments {
+ /**
+ * Create a new text document manager.
+ */
+ constructor(configuration) {
+ this._documents = Object.create(null);
+ this._configuration = configuration;
+ this._onDidChangeContent = new vscode_languageserver_protocol_1.Emitter();
+ this._onDidOpen = new vscode_languageserver_protocol_1.Emitter();
+ this._onDidClose = new vscode_languageserver_protocol_1.Emitter();
+ this._onDidSave = new vscode_languageserver_protocol_1.Emitter();
+ this._onWillSave = new vscode_languageserver_protocol_1.Emitter();
+ }
+ /**
+ * An event that fires when a text document managed by this manager
+ * has been opened or the content changes.
+ */
+ get onDidChangeContent() {
+ return this._onDidChangeContent.event;
+ }
+ /**
+ * An event that fires when a text document managed by this manager
+ * has been opened.
+ */
+ get onDidOpen() {
+ return this._onDidOpen.event;
+ }
+ /**
+ * An event that fires when a text document managed by this manager
+ * will be saved.
+ */
+ get onWillSave() {
+ return this._onWillSave.event;
+ }
+ /**
+ * Sets a handler that will be called if a participant wants to provide
+ * edits during a text document save.
+ */
+ onWillSaveWaitUntil(handler) {
+ this._willSaveWaitUntil = handler;
+ }
+ /**
+ * An event that fires when a text document managed by this manager
+ * has been saved.
+ */
+ get onDidSave() {
+ return this._onDidSave.event;
+ }
+ /**
+ * An event that fires when a text document managed by this manager
+ * has been closed.
+ */
+ get onDidClose() {
+ return this._onDidClose.event;
+ }
+ /**
+ * Returns the document for the given URI. Returns undefined if
+ * the document is not managed by this instance.
+ *
+ * @param uri The text document's URI to retrieve.
+ * @return the text document or `undefined`.
+ */
+ get(uri) {
+ return this._documents[uri];
+ }
+ /**
+ * Returns all text documents managed by this instance.
+ *
+ * @return all text documents.
+ */
+ all() {
+ return Object.keys(this._documents).map(key => this._documents[key]);
+ }
+ /**
+ * Returns the URIs of all text documents managed by this instance.
+ *
+ * @return the URI's of all text documents.
+ */
+ keys() {
+ return Object.keys(this._documents);
+ }
+ /**
+ * Listens for `low level` notification on the given connection to
+ * update the text documents managed by this instance.
+ *
+ * Please note that the connection only provides handlers not an event model. Therefore
+ * listening on a connection will overwrite the following handlers on a connection:
+ * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
+ * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
+ *
+ * Use the corresponding events on the TextDocuments instance instead.
+ *
+ * @param connection The connection to listen on.
+ */
+ listen(connection) {
+ connection.__textDocumentSync = vscode_languageserver_protocol_1.TextDocumentSyncKind.Full;
+ connection.onDidOpenTextDocument((event) => {
+ let td = event.textDocument;
+ let document = this._configuration.create(td.uri, td.languageId, td.version, td.text);
+ this._documents[td.uri] = document;
+ let toFire = Object.freeze({ document });
+ this._onDidOpen.fire(toFire);
+ this._onDidChangeContent.fire(toFire);
+ });
+ connection.onDidChangeTextDocument((event) => {
+ let td = event.textDocument;
+ let changes = event.contentChanges;
+ if (changes.length === 0) {
+ return;
+ }
+ let document = this._documents[td.uri];
+ const { version } = td;
+ if (version === null || version === undefined) {
+ throw new Error(`Received document change event for ${td.uri} without valid version identifier`);
+ }
+ document = this._configuration.update(document, changes, version);
+ this._documents[td.uri] = document;
+ this._onDidChangeContent.fire(Object.freeze({ document }));
+ });
+ connection.onDidCloseTextDocument((event) => {
+ let document = this._documents[event.textDocument.uri];
+ if (document) {
+ delete this._documents[event.textDocument.uri];
+ this._onDidClose.fire(Object.freeze({ document }));
+ }
+ });
+ connection.onWillSaveTextDocument((event) => {
+ let document = this._documents[event.textDocument.uri];
+ if (document) {
+ this._onWillSave.fire(Object.freeze({ document, reason: event.reason }));
+ }
+ });
+ connection.onWillSaveTextDocumentWaitUntil((event, token) => {
+ let document = this._documents[event.textDocument.uri];
+ if (document && this._willSaveWaitUntil) {
+ return this._willSaveWaitUntil(Object.freeze({ document, reason: event.reason }), token);
+ }
+ else {
+ return [];
+ }
+ });
+ connection.onDidSaveTextDocument((event) => {
+ let document = this._documents[event.textDocument.uri];
+ if (document) {
+ this._onDidSave.fire(Object.freeze({ document }));
+ }
+ });
+ }
+}
+exports.TextDocuments = TextDocuments;
+/**
+ * Helps tracking error message. Equal occurrences of the same
+ * message are only stored once. This class is for example
+ * useful if text documents are validated in a loop and equal
+ * error message should be folded into one.
+ */
+class ErrorMessageTracker {
+ constructor() {
+ this._messages = Object.create(null);
+ }
+ /**
+ * Add a message to the tracker.
+ *
+ * @param message The message to add.
+ */
+ add(message) {
+ let count = this._messages[message];
+ if (!count) {
+ count = 0;
+ }
+ count++;
+ this._messages[message] = count;
+ }
+ /**
+ * Send all tracked messages to the connection's window.
+ *
+ * @param connection The connection established between client and server.
+ */
+ sendErrors(connection) {
+ Object.keys(this._messages).forEach(message => {
+ connection.window.showErrorMessage(message);
+ });
+ }
+}
+exports.ErrorMessageTracker = ErrorMessageTracker;
+class RemoteConsoleImpl {
+ constructor() {
+ }
+ rawAttach(connection) {
+ this._rawConnection = connection;
+ }
+ attach(connection) {
+ this._connection = connection;
+ }
+ get connection() {
+ if (!this._connection) {
+ throw new Error('Remote is not attached to a connection yet.');
+ }
+ return this._connection;
+ }
+ fillServerCapabilities(_capabilities) {
+ }
+ initialize(_capabilities) {
+ }
+ error(message) {
+ this.send(vscode_languageserver_protocol_1.MessageType.Error, message);
+ }
+ warn(message) {
+ this.send(vscode_languageserver_protocol_1.MessageType.Warning, message);
+ }
+ info(message) {
+ this.send(vscode_languageserver_protocol_1.MessageType.Info, message);
+ }
+ log(message) {
+ this.send(vscode_languageserver_protocol_1.MessageType.Log, message);
+ }
+ send(type, message) {
+ if (this._rawConnection) {
+ this._rawConnection.sendNotification(vscode_languageserver_protocol_1.LogMessageNotification.type, { type, message });
+ }
+ }
+}
+class _RemoteWindowImpl {
+ constructor() {
+ }
+ attach(connection) {
+ this._connection = connection;
+ }
+ get connection() {
+ if (!this._connection) {
+ throw new Error('Remote is not attached to a connection yet.');
+ }
+ return this._connection;
+ }
+ initialize(_capabilities) {
+ }
+ fillServerCapabilities(_capabilities) {
+ }
+ showErrorMessage(message, ...actions) {
+ let params = { type: vscode_languageserver_protocol_1.MessageType.Error, message, actions };
+ return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
+ }
+ showWarningMessage(message, ...actions) {
+ let params = { type: vscode_languageserver_protocol_1.MessageType.Warning, message, actions };
+ return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
+ }
+ showInformationMessage(message, ...actions) {
+ let params = { type: vscode_languageserver_protocol_1.MessageType.Info, message, actions };
+ return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
+ }
+}
+const RemoteWindowImpl = showDocument_1.ShowDocumentFeature(progress_1.ProgressFeature(_RemoteWindowImpl));
+var BulkRegistration;
+(function (BulkRegistration) {
+ /**
+ * Creates a new bulk registration.
+ * @return an empty bulk registration.
+ */
+ function create() {
+ return new BulkRegistrationImpl();
+ }
+ BulkRegistration.create = create;
+})(BulkRegistration = exports.BulkRegistration || (exports.BulkRegistration = {}));
+class BulkRegistrationImpl {
+ constructor() {
+ this._registrations = [];
+ this._registered = new Set();
+ }
+ add(type, registerOptions) {
+ const method = Is.string(type) ? type : type.method;
+ if (this._registered.has(method)) {
+ throw new Error(`${method} is already added to this registration`);
+ }
+ const id = UUID.generateUuid();
+ this._registrations.push({
+ id: id,
+ method: method,
+ registerOptions: registerOptions || {}
+ });
+ this._registered.add(method);
+ }
+ asRegistrationParams() {
+ return {
+ registrations: this._registrations
+ };
+ }
+}
+var BulkUnregistration;
+(function (BulkUnregistration) {
+ function create() {
+ return new BulkUnregistrationImpl(undefined, []);
+ }
+ BulkUnregistration.create = create;
+})(BulkUnregistration = exports.BulkUnregistration || (exports.BulkUnregistration = {}));
+class BulkUnregistrationImpl {
+ constructor(_connection, unregistrations) {
+ this._connection = _connection;
+ this._unregistrations = new Map();
+ unregistrations.forEach(unregistration => {
+ this._unregistrations.set(unregistration.method, unregistration);
+ });
+ }
+ get isAttached() {
+ return !!this._connection;
+ }
+ attach(connection) {
+ this._connection = connection;
+ }
+ add(unregistration) {
+ this._unregistrations.set(unregistration.method, unregistration);
+ }
+ dispose() {
+ let unregistrations = [];
+ for (let unregistration of this._unregistrations.values()) {
+ unregistrations.push(unregistration);
+ }
+ let params = {
+ unregisterations: unregistrations
+ };
+ this._connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).then(undefined, (_error) => {
+ this._connection.console.info(`Bulk unregistration failed.`);
+ });
+ }
+ disposeSingle(arg) {
+ const method = Is.string(arg) ? arg : arg.method;
+ const unregistration = this._unregistrations.get(method);
+ if (!unregistration) {
+ return false;
+ }
+ let params = {
+ unregisterations: [unregistration]
+ };
+ this._connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).then(() => {
+ this._unregistrations.delete(method);
+ }, (_error) => {
+ this._connection.console.info(`Un-registering request handler for ${unregistration.id} failed.`);
+ });
+ return true;
+ }
+}
+class RemoteClientImpl {
+ attach(connection) {
+ this._connection = connection;
+ }
+ get connection() {
+ if (!this._connection) {
+ throw new Error('Remote is not attached to a connection yet.');
+ }
+ return this._connection;
+ }
+ initialize(_capabilities) {
+ }
+ fillServerCapabilities(_capabilities) {
+ }
+ register(typeOrRegistrations, registerOptionsOrType, registerOptions) {
+ if (typeOrRegistrations instanceof BulkRegistrationImpl) {
+ return this.registerMany(typeOrRegistrations);
+ }
+ else if (typeOrRegistrations instanceof BulkUnregistrationImpl) {
+ return this.registerSingle1(typeOrRegistrations, registerOptionsOrType, registerOptions);
+ }
+ else {
+ return this.registerSingle2(typeOrRegistrations, registerOptionsOrType);
+ }
+ }
+ registerSingle1(unregistration, type, registerOptions) {
+ const method = Is.string(type) ? type : type.method;
+ const id = UUID.generateUuid();
+ let params = {
+ registrations: [{ id, method, registerOptions: registerOptions || {} }]
+ };
+ if (!unregistration.isAttached) {
+ unregistration.attach(this.connection);
+ }
+ return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then((_result) => {
+ unregistration.add({ id: id, method: method });
+ return unregistration;
+ }, (_error) => {
+ this.connection.console.info(`Registering request handler for ${method} failed.`);
+ return Promise.reject(_error);
+ });
+ }
+ registerSingle2(type, registerOptions) {
+ const method = Is.string(type) ? type : type.method;
+ const id = UUID.generateUuid();
+ let params = {
+ registrations: [{ id, method, registerOptions: registerOptions || {} }]
+ };
+ return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then((_result) => {
+ return vscode_languageserver_protocol_1.Disposable.create(() => {
+ this.unregisterSingle(id, method);
+ });
+ }, (_error) => {
+ this.connection.console.info(`Registering request handler for ${method} failed.`);
+ return Promise.reject(_error);
+ });
+ }
+ unregisterSingle(id, method) {
+ let params = {
+ unregisterations: [{ id, method }]
+ };
+ return this.connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).then(undefined, (_error) => {
+ this.connection.console.info(`Un-registering request handler for ${id} failed.`);
+ });
+ }
+ registerMany(registrations) {
+ let params = registrations.asRegistrationParams();
+ return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then(() => {
+ return new BulkUnregistrationImpl(this._connection, params.registrations.map(registration => { return { id: registration.id, method: registration.method }; }));
+ }, (_error) => {
+ this.connection.console.info(`Bulk registration failed.`);
+ return Promise.reject(_error);
+ });
+ }
+}
+class _RemoteWorkspaceImpl {
+ constructor() {
+ }
+ attach(connection) {
+ this._connection = connection;
+ }
+ get connection() {
+ if (!this._connection) {
+ throw new Error('Remote is not attached to a connection yet.');
+ }
+ return this._connection;
+ }
+ initialize(_capabilities) {
+ }
+ fillServerCapabilities(_capabilities) {
+ }
+ applyEdit(paramOrEdit) {
+ function isApplyWorkspaceEditParams(value) {
+ return value && !!value.edit;
+ }
+ let params = isApplyWorkspaceEditParams(paramOrEdit) ? paramOrEdit : { edit: paramOrEdit };
+ return this.connection.sendRequest(vscode_languageserver_protocol_1.ApplyWorkspaceEditRequest.type, params);
+ }
+}
+const RemoteWorkspaceImpl = fileOperations_1.FileOperationsFeature(workspaceFolders_1.WorkspaceFoldersFeature(configuration_1.ConfigurationFeature(_RemoteWorkspaceImpl)));
+class TracerImpl {
+ constructor() {
+ this._trace = vscode_languageserver_protocol_1.Trace.Off;
+ }
+ attach(connection) {
+ this._connection = connection;
+ }
+ get connection() {
+ if (!this._connection) {
+ throw new Error('Remote is not attached to a connection yet.');
+ }
+ return this._connection;
+ }
+ initialize(_capabilities) {
+ }
+ fillServerCapabilities(_capabilities) {
+ }
+ set trace(value) {
+ this._trace = value;
+ }
+ log(message, verbose) {
+ if (this._trace === vscode_languageserver_protocol_1.Trace.Off) {
+ return;
+ }
+ this.connection.sendNotification(vscode_languageserver_protocol_1.LogTraceNotification.type, {
+ message: message,
+ verbose: this._trace === vscode_languageserver_protocol_1.Trace.Verbose ? verbose : undefined
+ });
+ }
+}
+class TelemetryImpl {
+ constructor() {
+ }
+ attach(connection) {
+ this._connection = connection;
+ }
+ get connection() {
+ if (!this._connection) {
+ throw new Error('Remote is not attached to a connection yet.');
+ }
+ return this._connection;
+ }
+ initialize(_capabilities) {
+ }
+ fillServerCapabilities(_capabilities) {
+ }
+ logEvent(data) {
+ this.connection.sendNotification(vscode_languageserver_protocol_1.TelemetryEventNotification.type, data);
+ }
+}
+class _LanguagesImpl {
+ constructor() {
+ }
+ attach(connection) {
+ this._connection = connection;
+ }
+ get connection() {
+ if (!this._connection) {
+ throw new Error('Remote is not attached to a connection yet.');
+ }
+ return this._connection;
+ }
+ initialize(_capabilities) {
+ }
+ fillServerCapabilities(_capabilities) {
+ }
+ attachWorkDoneProgress(params) {
+ return progress_1.attachWorkDone(this.connection, params);
+ }
+ attachPartialResultProgress(_type, params) {
+ return progress_1.attachPartialResult(this.connection, params);
+ }
+}
+exports._LanguagesImpl = _LanguagesImpl;
+const LanguagesImpl = moniker_1.MonikerFeature(linkedEditingRange_1.LinkedEditingRangeFeature(semanticTokens_1.SemanticTokensFeature(callHierarchy_1.CallHierarchyFeature(_LanguagesImpl))));
+function combineConsoleFeatures(one, two) {
+ return function (Base) {
+ return two(one(Base));
+ };
+}
+exports.combineConsoleFeatures = combineConsoleFeatures;
+function combineTelemetryFeatures(one, two) {
+ return function (Base) {
+ return two(one(Base));
+ };
+}
+exports.combineTelemetryFeatures = combineTelemetryFeatures;
+function combineTracerFeatures(one, two) {
+ return function (Base) {
+ return two(one(Base));
+ };
+}
+exports.combineTracerFeatures = combineTracerFeatures;
+function combineClientFeatures(one, two) {
+ return function (Base) {
+ return two(one(Base));
+ };
+}
+exports.combineClientFeatures = combineClientFeatures;
+function combineWindowFeatures(one, two) {
+ return function (Base) {
+ return two(one(Base));
+ };
+}
+exports.combineWindowFeatures = combineWindowFeatures;
+function combineWorkspaceFeatures(one, two) {
+ return function (Base) {
+ return two(one(Base));
+ };
+}
+exports.combineWorkspaceFeatures = combineWorkspaceFeatures;
+function combineLanguagesFeatures(one, two) {
+ return function (Base) {
+ return two(one(Base));
+ };
+}
+exports.combineLanguagesFeatures = combineLanguagesFeatures;
+function combineFeatures(one, two) {
+ function combine(one, two, func) {
+ if (one && two) {
+ return func(one, two);
+ }
+ else if (one) {
+ return one;
+ }
+ else {
+ return two;
+ }
+ }
+ let result = {
+ __brand: 'features',
+ console: combine(one.console, two.console, combineConsoleFeatures),
+ tracer: combine(one.tracer, two.tracer, combineTracerFeatures),
+ telemetry: combine(one.telemetry, two.telemetry, combineTelemetryFeatures),
+ client: combine(one.client, two.client, combineClientFeatures),
+ window: combine(one.window, two.window, combineWindowFeatures),
+ workspace: combine(one.workspace, two.workspace, combineWorkspaceFeatures)
+ };
+ return result;
+}
+exports.combineFeatures = combineFeatures;
+function createConnection(connectionFactory, watchDog, factories) {
+ const logger = (factories && factories.console ? new (factories.console(RemoteConsoleImpl))() : new RemoteConsoleImpl());
+ const connection = connectionFactory(logger);
+ logger.rawAttach(connection);
+ const tracer = (factories && factories.tracer ? new (factories.tracer(TracerImpl))() : new TracerImpl());
+ const telemetry = (factories && factories.telemetry ? new (factories.telemetry(TelemetryImpl))() : new TelemetryImpl());
+ const client = (factories && factories.client ? new (factories.client(RemoteClientImpl))() : new RemoteClientImpl());
+ const remoteWindow = (factories && factories.window ? new (factories.window(RemoteWindowImpl))() : new RemoteWindowImpl());
+ const workspace = (factories && factories.workspace ? new (factories.workspace(RemoteWorkspaceImpl))() : new RemoteWorkspaceImpl());
+ const languages = (factories && factories.languages ? new (factories.languages(LanguagesImpl))() : new LanguagesImpl());
+ const allRemotes = [logger, tracer, telemetry, client, remoteWindow, workspace, languages];
+ function asPromise(value) {
+ if (value instanceof Promise) {
+ return value;
+ }
+ else if (Is.thenable(value)) {
+ return new Promise((resolve, reject) => {
+ value.then((resolved) => resolve(resolved), (error) => reject(error));
+ });
+ }
+ else {
+ return Promise.resolve(value);
+ }
+ }
+ let shutdownHandler = undefined;
+ let initializeHandler = undefined;
+ let exitHandler = undefined;
+ let protocolConnection = {
+ listen: () => connection.listen(),
+ sendRequest: (type, ...params) => connection.sendRequest(Is.string(type) ? type : type.method, ...params),
+ onRequest: (type, handler) => connection.onRequest(type, handler),
+ sendNotification: (type, param) => {
+ const method = Is.string(type) ? type : type.method;
+ if (arguments.length === 1) {
+ connection.sendNotification(method);
+ }
+ else {
+ connection.sendNotification(method, param);
+ }
+ },
+ onNotification: (type, handler) => connection.onNotification(type, handler),
+ onProgress: connection.onProgress,
+ sendProgress: connection.sendProgress,
+ onInitialize: (handler) => initializeHandler = handler,
+ onInitialized: (handler) => connection.onNotification(vscode_languageserver_protocol_1.InitializedNotification.type, handler),
+ onShutdown: (handler) => shutdownHandler = handler,
+ onExit: (handler) => exitHandler = handler,
+ get console() { return logger; },
+ get telemetry() { return telemetry; },
+ get tracer() { return tracer; },
+ get client() { return client; },
+ get window() { return remoteWindow; },
+ get workspace() { return workspace; },
+ get languages() { return languages; },
+ onDidChangeConfiguration: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, handler),
+ onDidChangeWatchedFiles: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type, handler),
+ __textDocumentSync: undefined,
+ onDidOpenTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, handler),
+ onDidChangeTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, handler),
+ onDidCloseTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type, handler),
+ onWillSaveTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type, handler),
+ onWillSaveTextDocumentWaitUntil: (handler) => connection.onRequest(vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type, handler),
+ onDidSaveTextDocument: (handler) => connection.onNotification(vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, handler),
+ sendDiagnostics: (params) => connection.sendNotification(vscode_languageserver_protocol_1.PublishDiagnosticsNotification.type, params),
+ onHover: (handler) => connection.onRequest(vscode_languageserver_protocol_1.HoverRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), undefined);
+ }),
+ onCompletion: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CompletionRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onCompletionResolve: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, handler),
+ onSignatureHelp: (handler) => connection.onRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), undefined);
+ }),
+ onDeclaration: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onDefinition: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onTypeDefinition: (handler) => connection.onRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onImplementation: (handler) => connection.onRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onReferences: (handler) => connection.onRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onDocumentHighlight: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onDocumentSymbol: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onWorkspaceSymbol: (handler) => connection.onRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onCodeAction: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CodeActionRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onCodeActionResolve: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CodeActionResolveRequest.type, (params, cancel) => {
+ return handler(params, cancel);
+ }),
+ onCodeLens: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onCodeLensResolve: (handler) => connection.onRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, (params, cancel) => {
+ return handler(params, cancel);
+ }),
+ onDocumentFormatting: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), undefined);
+ }),
+ onDocumentRangeFormatting: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), undefined);
+ }),
+ onDocumentOnTypeFormatting: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, (params, cancel) => {
+ return handler(params, cancel);
+ }),
+ onRenameRequest: (handler) => connection.onRequest(vscode_languageserver_protocol_1.RenameRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), undefined);
+ }),
+ onPrepareRename: (handler) => connection.onRequest(vscode_languageserver_protocol_1.PrepareRenameRequest.type, (params, cancel) => {
+ return handler(params, cancel);
+ }),
+ onDocumentLinks: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onDocumentLinkResolve: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, (params, cancel) => {
+ return handler(params, cancel);
+ }),
+ onDocumentColor: (handler) => connection.onRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onColorPresentation: (handler) => connection.onRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onFoldingRanges: (handler) => connection.onRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onSelectionRanges: (handler) => connection.onRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
+ }),
+ onExecuteCommand: (handler) => connection.onRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, (params, cancel) => {
+ return handler(params, cancel, progress_1.attachWorkDone(connection, params), undefined);
+ }),
+ dispose: () => connection.dispose()
+ };
+ for (let remote of allRemotes) {
+ remote.attach(protocolConnection);
+ }
+ connection.onRequest(vscode_languageserver_protocol_1.InitializeRequest.type, (params) => {
+ watchDog.initialize(params);
+ if (Is.string(params.trace)) {
+ tracer.trace = vscode_languageserver_protocol_1.Trace.fromString(params.trace);
+ }
+ for (let remote of allRemotes) {
+ remote.initialize(params.capabilities);
+ }
+ if (initializeHandler) {
+ let result = initializeHandler(params, new vscode_languageserver_protocol_1.CancellationTokenSource().token, progress_1.attachWorkDone(connection, params), undefined);
+ return asPromise(result).then((value) => {
+ if (value instanceof vscode_languageserver_protocol_1.ResponseError) {
+ return value;
+ }
+ let result = value;
+ if (!result) {
+ result = { capabilities: {} };
+ }
+ let capabilities = result.capabilities;
+ if (!capabilities) {
+ capabilities = {};
+ result.capabilities = capabilities;
+ }
+ if (capabilities.textDocumentSync === undefined || capabilities.textDocumentSync === null) {
+ capabilities.textDocumentSync = Is.number(protocolConnection.__textDocumentSync) ? protocolConnection.__textDocumentSync : vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
+ }
+ else if (!Is.number(capabilities.textDocumentSync) && !Is.number(capabilities.textDocumentSync.change)) {
+ capabilities.textDocumentSync.change = Is.number(protocolConnection.__textDocumentSync) ? protocolConnection.__textDocumentSync : vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
+ }
+ for (let remote of allRemotes) {
+ remote.fillServerCapabilities(capabilities);
+ }
+ return result;
+ });
+ }
+ else {
+ let result = { capabilities: { textDocumentSync: vscode_languageserver_protocol_1.TextDocumentSyncKind.None } };
+ for (let remote of allRemotes) {
+ remote.fillServerCapabilities(result.capabilities);
+ }
+ return result;
+ }
+ });
+ connection.onRequest(vscode_languageserver_protocol_1.ShutdownRequest.type, () => {
+ watchDog.shutdownReceived = true;
+ if (shutdownHandler) {
+ return shutdownHandler(new vscode_languageserver_protocol_1.CancellationTokenSource().token);
+ }
+ else {
+ return undefined;
+ }
+ });
+ connection.onNotification(vscode_languageserver_protocol_1.ExitNotification.type, () => {
+ try {
+ if (exitHandler) {
+ exitHandler();
+ }
+ }
+ finally {
+ if (watchDog.shutdownReceived) {
+ watchDog.exit(0);
+ }
+ else {
+ watchDog.exit(1);
+ }
+ }
+ });
+ connection.onNotification(vscode_languageserver_protocol_1.SetTraceNotification.type, (params) => {
+ tracer.trace = vscode_languageserver_protocol_1.Trace.fromString(params.value);
+ });
+ return protocolConnection;
+}
+exports.createConnection = createConnection;
+//# sourceMappingURL=server.js.map
\ No newline at end of file
projects / dotfiles / .git / blobdiff