@mrclrchtr/supi-lsp 1.11.1 → 1.11.3

package/node_modules/vscode-jsonrpc/lib/common/connection.js

@@ -3,10 +3,48 @@
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License. See License.txt in the project root for license information.
  * ------------------------------------------------------------------------------------------ */
+/// <reference path="../../typings/thenable.d.ts" preserve="true"/>
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMessageConnection = exports.ConnectionOptions = exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0;
-const ral_1 = require("./ral");
-const Is = require("./is");
+exports.ConnectionOptions = exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.TraceValue = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0;
+exports.createMessageConnection = createMessageConnection;
+const ral_1 = __importDefault(require("./ral"));
+const Is = __importStar(require("./is"));
 const messages_1 = require("./messages");
 const linkedMap_1 = require("./linkedMap");
 const events_1 = require("./events");
@@ -27,6 +65,12 @@ var ProgressNotification;
     ProgressNotification.type = new messages_1.NotificationType('$/progress');
 })(ProgressNotification || (ProgressNotification = {}));
 class ProgressType {
+    /**
+     * Clients must not use these properties. They are here to ensure correct typing.
+     * in TypeScript
+     */
+    __;
+    _pr;
     constructor() {
     }
 }
@@ -51,25 +95,29 @@ var Trace;
     Trace[Trace["Compact"] = 2] = "Compact";
     Trace[Trace["Verbose"] = 3] = "Verbose";
 })(Trace || (exports.Trace = Trace = {}));
-var TraceValues;
-(function (TraceValues) {
+var TraceValue;
+(function (TraceValue) {
     /**
      * Turn tracing off.
      */
-    TraceValues.Off = 'off';
+    TraceValue.Off = 'off';
     /**
      * Trace messages only.
      */
-    TraceValues.Messages = 'messages';
+    TraceValue.Messages = 'messages';
     /**
      * Compact message tracing.
      */
-    TraceValues.Compact = 'compact';
+    TraceValue.Compact = 'compact';
     /**
      * Verbose message tracing.
      */
-    TraceValues.Verbose = 'verbose';
-})(TraceValues || (exports.TraceValues = TraceValues = {}));
+    TraceValue.Verbose = 'verbose';
+})(TraceValue || (exports.TraceValue = TraceValue = {}));
+/**
+ * @deprecated Use TraceValue instead
+ */
+exports.TraceValues = TraceValue;
 (function (Trace) {
     function fromString(value) {
         if (!Is.string(value)) {
@@ -150,6 +198,7 @@ var ConnectionErrors;
     ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";
 })(ConnectionErrors || (exports.ConnectionErrors = ConnectionErrors = {}));
 class ConnectionError extends Error {
+    code;
     constructor(code, message) {
         super(message);
         this.code = code;
@@ -231,7 +280,8 @@ var ConnectionOptions;
 (function (ConnectionOptions) {
     function is(value) {
         const candidate = value;
-        return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy));
+        return candidate
+            && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy) || Is.number(candidate.maxParallelism));
     }
     ConnectionOptions.is = is;
 })(ConnectionOptions || (exports.ConnectionOptions = ConnectionOptions = {}));
@@ -248,6 +298,8 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
     let notificationSequenceNumber = 0;
     let unknownResponseSequenceNumber = 0;
     const version = '2.0';
+    const maxParallelism = options?.maxParallelism ?? -1;
+    let inFlight = 0;
     let starRequestHandler = undefined;
     const requestHandlers = new Map();
     let starNotificationHandler = undefined;
@@ -268,34 +320,6 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
     const unhandledProgressEmitter = new events_1.Emitter();
     const disposeEmitter = new events_1.Emitter();
     const cancellationStrategy = (options && options.cancellationStrategy) ? options.cancellationStrategy : CancellationStrategy.Message;
-    function createRequestQueueKey(id) {
-        if (id === null) {
-            throw new Error(`Can't send requests with id null since the response can't be correlated.`);
-        }
-        return 'req-' + id.toString();
-    }
-    function createResponseQueueKey(id) {
-        if (id === null) {
-            return 'res-unknown-' + (++unknownResponseSequenceNumber).toString();
-        }
-        else {
-            return 'res-' + id.toString();
-        }
-    }
-    function createNotificationQueueKey() {
-        return 'not-' + (++notificationSequenceNumber).toString();
-    }
-    function addMessageToQueue(queue, message) {
-        if (messages_1.Message.isRequest(message)) {
-            queue.set(createRequestQueueKey(message.id), message);
-        }
-        else if (messages_1.Message.isResponse(message)) {
-            queue.set(createResponseQueueKey(message.id), message);
-        }
-        else {
-            queue.set(createNotificationQueueKey(), message);
-        }
-    }
     function cancelUndispatched(_message) {
         return undefined;
     }
@@ -325,45 +349,101 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
     messageReader.onError(readErrorHandler);
     messageWriter.onClose(closeHandler);
     messageWriter.onError(writeErrorHandler);
-    function triggerMessageQueue() {
-        if (timer || messageQueue.size === 0) {
-            return;
+    function createRequestQueueKey(id) {
+        if (id === null) {
+            throw new Error(`Can't send requests with id null since the response can't be correlated.`);
         }
-        timer = (0, ral_1.default)().timer.setImmediate(() => {
-            timer = undefined;
-            processMessageQueue();
-        });
+        return 'req-' + id.toString();
     }
-    function handleMessage(message) {
-        if (messages_1.Message.isRequest(message)) {
-            handleRequest(message);
+    function createResponseQueueKey(id) {
+        if (id === null) {
+            return 'res-unknown-' + (++unknownResponseSequenceNumber).toString();
         }
-        else if (messages_1.Message.isNotification(message)) {
-            handleNotification(message);
+        else {
+            return 'res-' + id.toString();
+        }
+    }
+    function createNotificationQueueKey() {
+        return 'not-' + (++notificationSequenceNumber).toString();
+    }
+    function addMessageToQueue(queue, message) {
+        if (messages_1.Message.isRequest(message)) {
+            queue.set(createRequestQueueKey(message.id), message);
         }
         else if (messages_1.Message.isResponse(message)) {
-            handleResponse(message);
+            // If we have unlimited parallelism we queue the response to keep
+            // the previous semantics.
+            if (maxParallelism === -1) {
+                queue.set(createResponseQueueKey(message.id), message);
+            }
+            else {
+                // If we have limited parallelism we resolve responses to avoid
+                // dead locks.
+                handleResponse(message);
+            }
         }
         else {
-            handleInvalidMessage(message);
+            queue.set(createNotificationQueueKey(), message);
         }
     }
-    function processMessageQueue() {
-        if (messageQueue.size === 0) {
+    function triggerMessageQueue() {
+        if (timer || messageQueue.size === 0) {
             return;
         }
-        const message = messageQueue.shift();
-        try {
-            const messageStrategy = options?.messageStrategy;
-            if (MessageStrategy.is(messageStrategy)) {
-                messageStrategy.handleMessage(message, handleMessage);
+        if (maxParallelism !== -1 && inFlight >= maxParallelism) {
+            return;
+        }
+        timer = (0, ral_1.default)().timer.setImmediate(async () => {
+            timer = undefined;
+            if (messageQueue.size === 0) {
+                return;
             }
-            else {
-                handleMessage(message);
+            if (maxParallelism !== -1 && inFlight >= maxParallelism) {
+                return;
+            }
+            const message = messageQueue.shift();
+            let result;
+            try {
+                inFlight++;
+                const messageStrategy = options?.messageStrategy;
+                if (MessageStrategy.is(messageStrategy)) {
+                    result = messageStrategy.handleMessage(message, handleMessage);
+                }
+                else {
+                    result = handleMessage(message);
+                }
+            }
+            catch (error) {
+                logger.error(`Processing message queue failed: ${error.toString()}`);
+            }
+            finally {
+                if (result instanceof Promise) {
+                    result.then(() => {
+                        inFlight--;
+                        triggerMessageQueue();
+                    }).catch((error) => {
+                        logger.error(`Processing message queue failed: ${error.toString()}`);
+                    });
+                }
+                else {
+                    inFlight--;
+                }
+                triggerMessageQueue();
             }
+        });
+    }
+    async function handleMessage(message) {
+        if (messages_1.Message.isRequest(message)) {
+            return handleRequest(message);
         }
-        finally {
-            triggerMessageQueue();
+        else if (messages_1.Message.isNotification(message)) {
+            return handleNotification(message);
+        }
+        else if (messages_1.Message.isResponse(message)) {
+            return handleResponse(message);
+        }
+        else {
+            return handleInvalidMessage(message);
         }
     }
     const callback = (message) => {
@@ -405,11 +485,11 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             triggerMessageQueue();
         }
     };
-    function handleRequest(requestMessage) {
+    async function handleRequest(requestMessage) {
         if (isDisposed()) {
             // we return here silently since we fired an event when the
             // connection got disposed.
-            return;
+            return Promise.resolve();
         }
         function reply(resultOrError, method, startTime) {
             const message = {
@@ -423,7 +503,7 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                 message.result = resultOrError === undefined ? null : resultOrError;
             }
             traceSendingResponse(message, method, startTime);
-            messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
+            return messageWriter.write(message);
         }
         function replyError(error, method, startTime) {
             const message = {
@@ -432,21 +512,7 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                 error: error.toJson()
             };
             traceSendingResponse(message, method, startTime);
-            messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
-        }
-        function replySuccess(result, method, startTime) {
-            // The JSON RPC defines that a response must either have a result or an error
-            // So we can't treat undefined as a valid response result.
-            if (result === undefined) {
-                result = null;
-            }
-            const message = {
-                jsonrpc: version,
-                id: requestMessage.id,
-                result: result
-            };
-            traceSendingResponse(message, method, startTime);
-            messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
+            return messageWriter.write(message);
         }
         traceReceivedRequest(requestMessage);
         const element = requestHandlers.get(requestMessage.method);
@@ -473,22 +539,19 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                 if (requestHandler) {
                     if (requestMessage.params === undefined) {
                         if (type !== undefined && type.numberOfParams !== 0) {
-                            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
-                            return;
+                            return replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
                         }
                         handlerResult = requestHandler(cancellationSource.token);
                     }
                     else if (Array.isArray(requestMessage.params)) {
                         if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byName) {
-                            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
-                            return;
+                            return replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
                         }
                         handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
                     }
                     else {
                         if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
-                            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
-                            return;
+                            return replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
                         }
                         handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
                     }
@@ -496,48 +559,26 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                 else if (starRequestHandler) {
                     handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
                 }
-                const promise = handlerResult;
-                if (!handlerResult) {
-                    requestTokens.delete(tokenKey);
-                    replySuccess(handlerResult, requestMessage.method, startTime);
-                }
-                else if (promise.then) {
-                    promise.then((resultOrError) => {
-                        requestTokens.delete(tokenKey);
-                        reply(resultOrError, requestMessage.method, startTime);
-                    }, error => {
-                        requestTokens.delete(tokenKey);
-                        if (error instanceof messages_1.ResponseError) {
-                            replyError(error, requestMessage.method, startTime);
-                        }
-                        else if (error && Is.string(error.message)) {
-                            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
-                        }
-                        else {
-                            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
-                        }
-                    });
-                }
-                else {
-                    requestTokens.delete(tokenKey);
-                    reply(handlerResult, requestMessage.method, startTime);
-                }
+                const resultOrError = await handlerResult;
+                await reply(resultOrError, requestMessage.method, startTime);
             }
             catch (error) {
-                requestTokens.delete(tokenKey);
                 if (error instanceof messages_1.ResponseError) {
-                    reply(error, requestMessage.method, startTime);
+                    await reply(error, requestMessage.method, startTime);
                 }
                 else if (error && Is.string(error.message)) {
-                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
+                    await replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
                 }
                 else {
-                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
+                    await replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
                 }
             }
+            finally {
+                requestTokens.delete(tokenKey);
+            }
         }
         else {
-            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
+            await replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
         }
     }
     function handleResponse(responseMessage) {
@@ -582,7 +623,7 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             }
         }
     }
-    function handleNotification(message) {
+    async function handleNotification(message) {
         if (isDisposed()) {
             // See handle request.
             return;
@@ -612,14 +653,14 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                                 logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received none.`);
                             }
                         }
-                        notificationHandler();
+                        await notificationHandler();
                     }
                     else if (Array.isArray(message.params)) {
                         // There are JSON-RPC libraries that send progress message as positional params although
                         // specified as named. So convert them if this is the case.
                         const params = message.params;
                         if (message.method === ProgressNotification.type.method && params.length === 2 && ProgressToken.is(params[0])) {
-                            notificationHandler({ token: params[0], value: params[1] });
+                            await notificationHandler({ token: params[0], value: params[1] });
                         }
                         else {
                             if (type !== undefined) {
@@ -630,18 +671,18 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                                     logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments`);
                                 }
                             }
-                            notificationHandler(...params);
+                            await notificationHandler(...params);
                         }
                     }
                     else {
                         if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
                             logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
                         }
-                        notificationHandler(message.params);
+                        await notificationHandler(message.params);
                     }
                 }
                 else if (starNotificationHandler) {
-                    starNotificationHandler(message.method, message.params);
+                    await starNotificationHandler(message.method, message.params);
                 }
             }
             catch (error) {
@@ -693,7 +734,7 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
         if (traceFormat === TraceFormat.Text) {
             let data = undefined;
             if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
-                data = `Params: ${stringifyTrace(message.params)}\n\n`;
+                data = `Params: ${stringifyTrace(message.params)}`;
             }
             tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
         }
@@ -709,10 +750,10 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             let data = undefined;
             if (trace === Trace.Verbose || trace === Trace.Compact) {
                 if (message.params) {
-                    data = `Params: ${stringifyTrace(message.params)}\n\n`;
+                    data = `Params: ${stringifyTrace(message.params)}`;
                 }
                 else {
-                    data = 'No parameters provided.\n\n';
+                    data = 'No parameters provided.';
                 }
             }
             tracer.log(`Sending notification '${message.method}'.`, data);
@@ -729,14 +770,14 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             let data = undefined;
             if (trace === Trace.Verbose || trace === Trace.Compact) {
                 if (message.error && message.error.data) {
-                    data = `Error data: ${stringifyTrace(message.error.data)}\n\n`;
+                    data = `Error data: ${stringifyTrace(message.error.data)}`;
                 }
                 else {
                     if (message.result) {
-                        data = `Result: ${stringifyTrace(message.result)}\n\n`;
+                        data = `Result: ${stringifyTrace(message.result)}`;
                     }
                     else if (message.error === undefined) {
-                        data = 'No result returned.\n\n';
+                        data = 'No result returned.';
                     }
                 }
             }
@@ -753,7 +794,7 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
         if (traceFormat === TraceFormat.Text) {
             let data = undefined;
             if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
-                data = `Params: ${stringifyTrace(message.params)}\n\n`;
+                data = `Params: ${stringifyTrace(message.params)}`;
             }
             tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
         }
@@ -769,10 +810,10 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             let data = undefined;
             if (trace === Trace.Verbose || trace === Trace.Compact) {
                 if (message.params) {
-                    data = `Params: ${stringifyTrace(message.params)}\n\n`;
+                    data = `Params: ${stringifyTrace(message.params)}`;
                 }
                 else {
-                    data = 'No parameters provided.\n\n';
+                    data = 'No parameters provided.';
                 }
             }
             tracer.log(`Received notification '${message.method}'.`, data);
@@ -789,14 +830,14 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             let data = undefined;
             if (trace === Trace.Verbose || trace === Trace.Compact) {
                 if (message.error && message.error.data) {
-                    data = `Error data: ${stringifyTrace(message.error.data)}\n\n`;
+                    data = `Error data: ${stringifyTrace(message.error.data)}`;
                 }
                 else {
                     if (message.result) {
-                        data = `Result: ${stringifyTrace(message.result)}\n\n`;
+                        data = `Result: ${stringifyTrace(message.result)}`;
                     }
                     else if (message.error === undefined) {
-                        data = 'No result returned.\n\n';
+                        data = 'No result returned.';
                     }
                 }
             }
@@ -919,7 +960,7 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                     paramStart = 1;
                     parameterStructures = first;
                 }
-                let paramEnd = args.length;
+                const paramEnd = args.length;
                 const numberOfParams = paramEnd - paramStart;
                 switch (numberOfParams) {
                     case 0:
@@ -971,9 +1012,11 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             return {
                 dispose: () => {
                     if (method !== undefined) {
-                        notificationHandlers.delete(method);
+                        if (notificationHandlers.get(method)?.handler === handler) {
+                            notificationHandlers.delete(method);
+                        }
                     }
-                    else {
+                    else if (starNotificationHandler === type) {
                         starNotificationHandler = undefined;
                     }
                 }
@@ -986,7 +1029,9 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             progressHandlers.set(token, handler);
             return {
                 dispose: () => {
-                    progressHandlers.delete(token);
+                    if (progressHandlers.get(token) === handler) {
+                        progressHandlers.delete(token);
+                    }
                 }
             };
         },
@@ -999,6 +1044,17 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
         sendRequest: (type, ...args) => {
             throwIfClosedOrDisposed();
             throwIfNotListening();
+            function sendCancellation(connection, id) {
+                const p = cancellationStrategy.sender.sendCancellation(connection, id);
+                if (p === undefined) {
+                    logger.log(`Received no promise from cancellation strategy when cancelling id ${id}`);
+                }
+                else {
+                    p.catch(() => {
+                        logger.log(`Sending cancellation messages for id ${id} failed.`);
+                    });
+                }
+            }
             let method;
             let messageParams;
             let token = undefined;
@@ -1042,19 +1098,16 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             }
             const id = sequenceNumber++;
             let disposable;
-            if (token) {
-                disposable = token.onCancellationRequested(() => {
-                    const p = cancellationStrategy.sender.sendCancellation(connection, id);
-                    if (p === undefined) {
-                        logger.log(`Received no promise from cancellation strategy when cancelling id ${id}`);
-                        return Promise.resolve();
-                    }
-                    else {
-                        return p.catch(() => {
-                            logger.log(`Sending cancellation messages for id ${id} failed`);
-                        });
-                    }
-                });
+            let tokenWasCancelled = false;
+            if (token !== undefined) {
+                if (token.isCancellationRequested) {
+                    tokenWasCancelled = true;
+                }
+                else {
+                    disposable = token.onCancellationRequested(() => {
+                        sendCancellation(connection, id);
+                    });
+                }
             }
             const requestMessage = {
                 jsonrpc: version,
@@ -1066,6 +1119,7 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             if (typeof cancellationStrategy.sender.enableCancellation === 'function') {
                 cancellationStrategy.sender.enableCancellation(requestMessage);
             }
+            // eslint-disable-next-line no-async-promise-executor
             return new Promise(async (resolve, reject) => {
                 const resolveWithCleanup = (r) => {
                     resolve(r);
@@ -1081,6 +1135,9 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                 try {
                     responsePromises.set(id, responsePromise);
                     await messageWriter.write(requestMessage);
+                    if (tokenWasCancelled) {
+                        sendCancellation(connection, id);
+                    }
                 }
                 catch (error) {
                     // Writing the message failed. So we need to delete it from the response promises and
@@ -1118,9 +1175,11 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                         return;
                     }
                     if (method !== undefined) {
-                        requestHandlers.delete(method);
+                        if (requestHandlers.get(method)?.handler === handler) {
+                            requestHandlers.delete(method);
+                        }
                     }
-                    else {
+                    else if (starRequestHandler === type) {
                         starRequestHandler = undefined;
                     }
                 }
@@ -1189,7 +1248,6 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             messageReader.listen(callback);
         },
         inspect: () => {
-            // eslint-disable-next-line no-console
             (0, ral_1.default)().console.log('inspect');
         }
     };
@@ -1200,10 +1258,10 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
         const verbose = trace === Trace.Verbose || trace === Trace.Compact;
         tracer.log(params.message, verbose ? params.verbose : undefined);
     });
-    connection.onNotification(ProgressNotification.type, (params) => {
+    connection.onNotification(ProgressNotification.type, async (params) => {
         const handler = progressHandlers.get(params.token);
         if (handler) {
-            handler(params.value);
+            await handler(params.value);
         }
         else {
             unhandledProgressEmitter.fire(params);
@@ -1211,4 +1269,3 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
     });
     return connection;
 }
-exports.createMessageConnection = createMessageConnection;