Fix unhandled errors

Author: DonJayamanne

src/interactive-window/debugger/jupyter/kernelDebugAdapter.ts

@@ -15,6 +15,7 @@ import { getInteractiveCellMetadata } from '../../../interactive-window/helpers'
 import { KernelDebugAdapterBase } from '../../../notebooks/debugger/kernelDebugAdapterBase';
 import { InteractiveCellMetadata } from '../../editor-integration/types';
 import { IDebugService } from '../../../platform/common/application/types';
+import { noop } from '../../../platform/common/utils/misc';
 /**
  * KernelDebugAdapter listens to debug messages in order to translate file requests into real files
  * (Interactive Window generally executes against a real file)
@@ -75,7 +76,11 @@ export class KernelDebugAdapter extends KernelDebugAdapterBase {
         if (message.type === 'response' && this.debugLocationTracker?.onDidSendMessage) {
             this.debugLocationTracker.onDidSendMessage(message);
         }
-        return super.handleMessage(message);
+        const promise = super.handleMessage(message);
+        // The VS Code debugger class does not support an async `handleMessage`, its supposed to be sync.
+        // As a result, any errors here will not be handled and they'll be treated as unhandled errors.
+        promise.catch(noop);
+        return promise;
     }
 
     // Dump content of given cell into a tmp file and return path to file.

src/kernels/common/delayedFutureExecute.ts

@@ -7,6 +7,7 @@ import type { Kernel, KernelMessage } from '@jupyterlab/services';
 import { traceInfoIfCI } from '../../platform/logging';
 import { createDeferred } from '../../platform/common/utils/async';
 import { CancellationError } from 'vscode';
+import { noop } from '../../platform/common/utils/misc';
 
 // Wraps a future so that a requestExecute on a session will wait for the previous future to finish before actually executing
 export class DelayedFutureExecute
@@ -40,6 +41,8 @@ export class DelayedFutureExecute
         private disposeOnDone?: boolean,
         private metadata?: JSONObject
     ) {
+        // Ensure we don't have any unhandled promises.
+        this.doneDeferred.promise.catch(noop);
         // Setup our request based on the previous link finishing
         previousLink.done.then(() => this.requestExecute()).catch((e) => this.doneDeferred.reject(e));
 

src/kernels/execution/cellExecution.ts

@@ -82,6 +82,7 @@ export class CellExecution implements IDisposable {
     private _completed?: boolean;
     private startTime?: number;
     private endTime?: number;
+    private disposed?: boolean;
     private execution?: NotebookCellExecution;
     private cancelHandled = false;
     private request: Kernel.IShellFuture<KernelMessage.IExecuteRequestMsg, KernelMessage.IExecuteReplyMsg> | undefined;
@@ -217,6 +218,10 @@ export class CellExecution implements IDisposable {
      * Or when execution has been cancelled.
      */
     public dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
         traceCellMessage(this.cell, 'Execution disposed');
         disposeAllDisposables(this.disposables);
         this.cellExecutionHandler?.dispose();

src/kernels/execution/cellExecutionMessageHandler.ts

@@ -114,6 +114,7 @@ export class CellExecutionMessageHandler implements IDisposable {
     private temporaryExecution?: NotebookCellExecution;
     private previousResultsToRestore?: NotebookCellExecutionSummary;
     private cellHasErrorsInOutput?: boolean;
+    private disposed?: boolean;
 
     public get hasErrorOutput() {
         return this.cellHasErrorsInOutput === true;
@@ -235,7 +236,11 @@ export class CellExecutionMessageHandler implements IDisposable {
      * Or when execution has been cancelled.
      */
     public dispose() {
-        traceCellMessage(this.cell, 'Execution disposed');
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        traceCellMessage(this.cell, 'Execution Message Handler disposed');
         disposeAllDisposables(this.disposables);
         this.prompts.forEach((item) => item.dispose());
         this.prompts.clear();

src/kernels/execution/kernelExecution.ts

@@ -36,6 +36,7 @@ import { noop } from '../../platform/common/utils/misc';
  */
 export class BaseKernelExecution<TKernel extends IBaseKernel = IBaseKernel> implements IDisposable {
     protected readonly disposables: IDisposable[] = [];
+    private disposed?: boolean;
     private _interruptPromise?: Promise<InterruptResult>;
     private _restartPromise?: Promise<void>;
     protected get restarting() {
@@ -100,6 +101,10 @@ export class BaseKernelExecution<TKernel extends IBaseKernel = IBaseKernel> impl
         await this._restartPromise;
     }
     public dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
         traceInfoIfCI(`Dispose KernelExecution`);
         this.disposables.forEach((d) => d.dispose());
     }