Function constructor

src/notebooks/debugger/kernelDebugAdapterBase.ts:66–141

(
        protected session: DebugSession,
        protected notebookDocument: NotebookDocument,
        protected readonly jupyterSession: IKernelSession,
        private readonly kernel: IKernel | undefined,
        private readonly platformService: IPlatformService,
        private readonly debugService: IDebugService
    )

    public readonly debugCell: NotebookCell | undefined;
    private disconnected: boolean = false;
    constructor(
        protected session: DebugSession,
        protected notebookDocument: NotebookDocument,
        protected readonly jupyterSession: IKernelSession,
        private readonly kernel: IKernel | undefined,
        private readonly platformService: IPlatformService,
        private readonly debugService: IDebugService
    ) {
        logger.ci(`Creating kernel debug adapter for debugging notebooks`);
        const configuration = this.session.configuration;
        assertIsDebugConfig(configuration);
        this.configuration = configuration;
        this.debugCell = notebookDocument.cellAt(configuration.__cellIndex!);

        this.addDebuggingDelegates([new ResetKernelController(this)]);

        this.jupyterSession.kernel?.iopubMessage.connect(this.onIOPubMessage, this);
        this.disposables.push(
            new Disposable(() => this.jupyterSession.kernel?.iopubMessage.disconnect(this.onIOPubMessage, this))
        );

        if (this.kernel) {
            this.kernel.addHook('willRestart', () => this.disconnect(), this, this.disposables);
            this.kernel.addHook('interruptCompleted', () => this.disconnect(), this, this.disposables);
            this.disposables.push(
                this.kernel.onDisposed(() => {
                    if (!this.disconnected) {
                        debug.stopDebugging(this.session).then(noop, noop);
                        this.disconnect().catch(noop);
                        sendTelemetryEvent(DebuggingTelemetry.endedSession, undefined, { reason: 'onKernelDisposed' });
                    }
                })
            );
        }

        this.disposables.push(
            notebookCellExecutions.onDidChangeNotebookCellExecutionState(
                (cellStateChange: NotebookCellExecutionStateChangeEvent) => {
                    // If a cell has moved to idle, stop the debug session
                    if (
                        this.configuration.__cellIndex === cellStateChange.cell.index &&
                        cellStateChange.state === NotebookCellExecutionState.Idle &&
                        !this.disconnected
                    ) {
                        sendTelemetryEvent(DebuggingTelemetry.endedSession, undefined, { reason: 'normally' });
                        this.disconnect().catch(noop);
                    }
                },
                this,
                this.disposables
            )
        );

        this.disposables.push(
            workspace.onDidChangeNotebookDocument(
                (e) => {
                    e.contentChanges.forEach((change) => {
                        change.removedCells.forEach((cell: NotebookCell) => {