@ton/sandbox 0.21.0-debugger.0 → 0.21.0-debugger.2

package/dist/blockchain/SmartContract.js

@@ -16,7 +16,7 @@ exports.SmartContract = exports.EmulationError = exports.TimeError = exports.Get
 const core_1 = require("@ton/core");
 const selector_1 = require("../utils/selector");
 const debug_1 = require("../debugger/debug");
-const SourceMapCache_1 = require("../debugger/SourceMapCache");
+const DebugInfoCache_1 = require("../debugger/DebugInfoCache");
 function createShardAccount(args) {
     let wc = args.workchain ?? 0;
     let address = args.address ?? (0, core_1.contractAddress)(wc, { code: args.code, data: args.data });
@@ -232,7 +232,7 @@ class SmartContract {
                 console.log('Debugging uninitialized accounts is unsupported in debugger beta');
                 return await this.runCommon(() => this.blockchain.executor.runTransaction(args));
             }
-            const sm = SourceMapCache_1.defaultSourceMapCache.get(code.hash().toString('base64'));
+            const sm = DebugInfoCache_1.defaultDebugInfoCache.get(code.hash().toString('base64'));
             if (sm === undefined) {
                 return await this.runCommon(() => this.blockchain.executor.runTransaction(args));
             }
@@ -294,12 +294,12 @@ class SmartContract {
         };
         let res;
         if (this.debug) {
-            const sm = SourceMapCache_1.defaultSourceMapCache.get(args.code.hash().toString('base64'));
-            if (sm === undefined) {
+            const di = DebugInfoCache_1.defaultDebugInfoCache.get(args.code.hash().toString('base64'));
+            if (di === undefined) {
                 res = await this.blockchain.executor.runGetMethod(args);
             }
             else {
-                res = await (0, debug_1.debugGetMethod)(this.blockchain.executor, args, sm);
+                res = await (0, debug_1.debugGetMethod)(this.blockchain.executor, args, di);
             }
         }
         else {

package/dist/debugger/DebugInfoCache.d.ts

@@ -0,0 +1,5 @@
+import { DebugInfo } from "./Debuggee";
+import { CompileResult } from '@ton/blueprint';
+export type DebugInfoCache = Map<string, DebugInfo>;
+export declare const defaultDebugInfoCache: DebugInfoCache;
+export declare function registerCompiledContract(c: CompileResult): import("@ton/core").Cell;

package/dist/debugger/{SourceMapCache.js → DebugInfoCache.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerCompiledContract = exports.defaultSourceMapCache = void 0;
+exports.registerCompiledContract = exports.defaultDebugInfoCache = void 0;
 const node_path_1 = require("node:path");
-exports.defaultSourceMapCache = new Map();
+exports.defaultDebugInfoCache = new Map();
 function registerCompiledContract(c) {
     if (c.lang !== 'func') {
         throw new Error('Can only register func contracts');
@@ -10,9 +10,10 @@ function registerCompiledContract(c) {
     if (c.debugInfo === undefined) {
         throw new Error('No debug info');
     }
+    const { locations, globals } = c.debugInfo;
     const sm = {};
-    for (let i = 0; i < c.debugInfo.length; i++) {
-        const di = c.debugInfo[i];
+    for (let i = 0; i < locations.length; i++) {
+        const di = locations[i];
         if (di.ret || di.vars === undefined)
             continue;
         sm[i] = {
@@ -21,7 +22,10 @@ function registerCompiledContract(c) {
             variables: di.vars ?? [],
         };
     }
-    exports.defaultSourceMapCache.set(c.code.hash().toString('base64'), sm);
+    exports.defaultDebugInfoCache.set(c.code.hash().toString('base64'), {
+        sourceMap: sm,
+        globals,
+    });
     return c.code;
 }
 exports.registerCompiledContract = registerCompiledContract;

package/dist/debugger/Debuggee.d.ts

@@ -2,8 +2,6 @@
 import EventEmitter from 'node:events';
 import { Executor, GetMethodArgs, RunTransactionArgs } from '../executor/Executor';
 import { Cell, TupleItem } from '@ton/core';
-import { LoggingDebugSession } from '@vscode/debugadapter';
-import { DebugProtocol } from '@vscode/debugprotocol';
 export type SourceMapEntry = {
     path: string;
     line: number;
@@ -12,11 +10,22 @@ export type SourceMapEntry = {
 export type SourceMap = {
     [k: number]: SourceMapEntry;
 };
+export type GlobalEntry = {
+    name: string;
+};
+export type DebugInfo = {
+    sourceMap: SourceMap;
+    globals: GlobalEntry[];
+};
 type Breakpoint = {
     id: number;
     line: number;
     verified: boolean;
 };
+export type Variable = {
+    name: string;
+    value: TupleItem;
+};
 export declare class Debuggee extends EventEmitter {
     executor: Executor;
     ptr: number;
@@ -29,10 +38,13 @@ export declare class Debuggee extends EventEmitter {
     breakpoints: Map<string, Breakpoint[]>;
     breakpointID: number;
     frames: string[];
+    globals: GlobalEntry[];
     finishedCallback: (v: any) => void;
     constructor(executor: Executor, finishedCallback: (v: any) => void);
     setCodeCells(code: Cell): void;
+    setDebugInfo(debugInfo: DebugInfo): void;
     setSourceMap(sourceMap: SourceMap): void;
+    setGlobals(globals: GlobalEntry[]): void;
     getAvailableSourcePaths(): string[];
     getAvailableLines(path: string): number[];
     isLineAvailable(path: string, line: number): boolean;
@@ -40,12 +52,15 @@ export declare class Debuggee extends EventEmitter {
     step(stopEvent?: string): void;
     startGetMethod(args: GetMethodArgs): void;
     startTransaction(args: RunTransactionArgs): void;
+    getC7(): TupleItem;
     vmStep(): boolean;
     codePos(): {
         hash: string;
         offset: number;
     };
     getStack(): TupleItem[];
+    getLocalVariables(): Variable[] | undefined;
+    getGlobalVariables(): Variable[] | undefined;
     currentDebugInfoNumber(): number | undefined;
     currentSourceMapEntry(): SourceMapEntry | undefined;
     breakpointKey(path: string, line: number): string;
@@ -59,30 +74,8 @@ export declare class Debuggee extends EventEmitter {
     sendEvent(event: string, ...args: any[]): void;
     onFinished(): void;
     stepUntilLine(breakpointsOnly: boolean, stopEvent?: string): void;
-    prepareGetMethod(args: GetMethodArgs, sourceMap: SourceMap): void;
-    prepareTransaction(args: RunTransactionArgs, code: Cell, sourceMap: SourceMap): void;
+    prepareGetMethod(args: GetMethodArgs, debugInfo: DebugInfo): void;
+    prepareTransaction(args: RunTransactionArgs, code: Cell, debugInfo: DebugInfo): void;
     start(debug: boolean, stopOnEntry: boolean): void;
 }
-export declare class TVMDebugSession extends LoggingDebugSession {
-    static readonly threadID = 1;
-    static readonly stackFrameID = 1;
-    static readonly variablesReference = 1;
-    debuggee: Debuggee;
-    constructor(debuggee: Debuggee);
-    protected initializeRequest(response: DebugProtocol.InitializeResponse, args: DebugProtocol.InitializeRequestArguments): void;
-    protected loadedSourcesRequest(response: DebugProtocol.LoadedSourcesResponse, args: DebugProtocol.LoadedSourcesArguments, request?: DebugProtocol.Request | undefined): void;
-    protected breakpointLocationsRequest(response: DebugProtocol.BreakpointLocationsResponse, args: DebugProtocol.BreakpointLocationsArguments, request?: DebugProtocol.Request | undefined): void;
-    protected launchRequest(response: DebugProtocol.LaunchResponse, args: DebugProtocol.LaunchRequestArguments, request?: DebugProtocol.Request | undefined): void;
-    protected attachRequest(response: DebugProtocol.AttachResponse, args: DebugProtocol.AttachRequestArguments, request?: DebugProtocol.Request | undefined): void;
-    protected setBreakPointsRequest(response: DebugProtocol.SetBreakpointsResponse, args: DebugProtocol.SetBreakpointsArguments, request?: DebugProtocol.Request | undefined): void;
-    protected threadsRequest(response: DebugProtocol.ThreadsResponse, request?: DebugProtocol.Request | undefined): void;
-    protected continueRequest(response: DebugProtocol.ContinueResponse, args: DebugProtocol.ContinueArguments, request?: DebugProtocol.Request | undefined): void;
-    protected nextRequest(response: DebugProtocol.NextResponse, args: DebugProtocol.NextArguments, request?: DebugProtocol.Request | undefined): void;
-    protected stepInRequest(response: DebugProtocol.StepInResponse, args: DebugProtocol.StepInArguments, request?: DebugProtocol.Request | undefined): void;
-    protected stepOutRequest(response: DebugProtocol.StepOutResponse, args: DebugProtocol.StepOutArguments, request?: DebugProtocol.Request | undefined): void;
-    protected stackTraceRequest(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments, request?: DebugProtocol.Request | undefined): void;
-    protected scopesRequest(response: DebugProtocol.ScopesResponse, args: DebugProtocol.ScopesArguments, request?: DebugProtocol.Request | undefined): void;
-    protected variablesRequest(response: DebugProtocol.VariablesResponse, args: DebugProtocol.VariablesArguments, request?: DebugProtocol.Request | undefined): void;
-    protected disconnectRequest(response: DebugProtocol.DisconnectResponse, args: DebugProtocol.DisconnectArguments, request?: DebugProtocol.Request | undefined): void;
-}
 export {};

package/dist/debugger/Debuggee.js

@@ -3,10 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TVMDebugSession = exports.Debuggee = void 0;
+exports.Debuggee = void 0;
 const node_events_1 = __importDefault(require("node:events"));
-const debugadapter_1 = require("@vscode/debugadapter");
-const node_path_1 = require("node:path");
 class Debuggee extends node_events_1.default {
     constructor(executor, finishedCallback) {
         super();
@@ -18,6 +16,7 @@ class Debuggee extends node_events_1.default {
         this.breakpoints = new Map();
         this.breakpointID = 0;
         this.frames = [];
+        this.globals = [];
         this.executor = executor;
         this.executor.debugLogFunc = (s) => { this.sendEvent('output', s); };
         this.finishedCallback = finishedCallback;
@@ -33,6 +32,10 @@ class Debuggee extends node_events_1.default {
             }
         }
     }
+    setDebugInfo(debugInfo) {
+        this.setSourceMap(debugInfo.sourceMap);
+        this.setGlobals(debugInfo.globals);
+    }
     setSourceMap(sourceMap) {
         this.sourceMap = sourceMap;
         for (const di in sourceMap) {
@@ -43,6 +46,9 @@ class Debuggee extends node_events_1.default {
             this.availableLines[sem.path].push(sem.line);
         }
     }
+    setGlobals(globals) {
+        this.globals = globals;
+    }
     getAvailableSourcePaths() {
         return Object.keys(this.availableLines);
     }
@@ -74,6 +80,14 @@ class Debuggee extends node_events_1.default {
         this.ptr = emptr;
         this.debugType = 'tx';
     }
+    getC7() {
+        switch (this.debugType) {
+            case 'get':
+                return this.executor.sbsGetMethodC7(this.ptr);
+            case 'tx':
+                return this.executor.sbsTransactionC7(this.ptr);
+        }
+    }
     vmStep() {
         switch (this.debugType) {
             case 'get':
@@ -98,6 +112,43 @@ class Debuggee extends node_events_1.default {
                 return this.executor.sbsTransactionStack(this.ptr);
         }
     }
+    getLocalVariables() {
+        const sme = this.currentSourceMapEntry();
+        if (sme === undefined) {
+            return undefined;
+        }
+        const vars = [];
+        const stack = this.getStack();
+        for (let i = 0; i < sme.variables.length; i++) {
+            vars.push({
+                name: sme.variables[i],
+                value: stack[i],
+            });
+        }
+        return vars;
+    }
+    getGlobalVariables() {
+        const vars = [];
+        const c7item = this.getC7();
+        if (c7item.type !== 'tuple') {
+            return undefined;
+        }
+        const c7 = c7item.items;
+        for (let i = 0; i < this.globals.length; i++) {
+            if (i + 1 < c7.length) {
+                vars.push({
+                    name: this.globals[i].name,
+                    value: c7[i + 1],
+                });
+                continue;
+            }
+            vars.push({
+                name: this.globals[i].name,
+                value: { type: 'null' },
+            });
+        }
+        return vars;
+    }
     currentDebugInfoNumber() {
         const codepos = this.codePos();
         const cell = this.codeCells.get(codepos.hash);
@@ -199,15 +250,15 @@ class Debuggee extends node_events_1.default {
             }
         }
     }
-    prepareGetMethod(args, sourceMap) {
+    prepareGetMethod(args, debugInfo) {
         this.startGetMethod(args);
         this.setCodeCells(args.code);
-        this.setSourceMap(sourceMap);
+        this.setDebugInfo(debugInfo);
     }
-    prepareTransaction(args, code, sourceMap) {
+    prepareTransaction(args, code, debugInfo) {
         this.startTransaction(args);
         this.setCodeCells(code);
-        this.setSourceMap(sourceMap);
+        this.setDebugInfo(debugInfo);
     }
     start(debug, stopOnEntry) {
         if (debug) {
@@ -224,244 +275,3 @@ class Debuggee extends node_events_1.default {
     }
 }
 exports.Debuggee = Debuggee;
-class TVMDebugSession extends debugadapter_1.LoggingDebugSession {
-    constructor(debuggee) {
-        super();
-        this.debuggee = debuggee;
-        this.debuggee.on('stopOnEntry', () => {
-            this.sendEvent(new debugadapter_1.StoppedEvent('entry', TVMDebugSession.threadID));
-        });
-        this.debuggee.on('stopOnBreakpoint', () => {
-            this.sendEvent(new debugadapter_1.StoppedEvent('breakpoint', TVMDebugSession.threadID));
-        });
-        this.debuggee.on('stopOnStep', () => {
-            this.sendEvent(new debugadapter_1.StoppedEvent('step', TVMDebugSession.threadID));
-        });
-        this.debuggee.on('end', () => {
-            this.sendEvent(new debugadapter_1.TerminatedEvent());
-        });
-        this.debuggee.on('output', (s) => {
-            this.sendEvent(new debugadapter_1.OutputEvent(s + '\n', 'stdout'));
-        });
-    }
-    initializeRequest(response, args) {
-        response.body = response.body || {};
-        const b = response.body;
-        b.supportsConfigurationDoneRequest = false;
-        b.supportsFunctionBreakpoints = false;
-        b.supportsConditionalBreakpoints = false;
-        b.supportsHitConditionalBreakpoints = false;
-        b.supportsEvaluateForHovers = false;
-        b.supportsStepBack = false;
-        b.supportsSetVariable = false;
-        b.supportsRestartFrame = false;
-        b.supportsGotoTargetsRequest = false;
-        b.supportsStepInTargetsRequest = false;
-        b.supportsCompletionsRequest = false;
-        b.supportsModulesRequest = false;
-        b.supportsRestartRequest = false;
-        b.supportsValueFormattingOptions = false;
-        b.supportsExceptionInfoRequest = false;
-        b.supportTerminateDebuggee = false;
-        b.supportSuspendDebuggee = false;
-        b.supportsDelayedStackTraceLoading = false;
-        b.supportsLoadedSourcesRequest = true;
-        b.supportsLogPoints = false;
-        b.supportsTerminateThreadsRequest = false;
-        b.supportsSetExpression = false;
-        b.supportsTerminateRequest = false;
-        b.supportsDataBreakpoints = false;
-        b.supportsReadMemoryRequest = false;
-        b.supportsWriteMemoryRequest = false;
-        b.supportsDisassembleRequest = false;
-        b.supportsCancelRequest = false;
-        b.supportsBreakpointLocationsRequest = true;
-        b.supportsClipboardContext = false;
-        b.supportsSteppingGranularity = false;
-        b.supportsInstructionBreakpoints = false;
-        b.supportsExceptionFilterOptions = false;
-        b.supportsSingleThreadExecutionRequests = false;
-        this.sendResponse(response);
-        this.sendEvent(new debugadapter_1.InitializedEvent());
-    }
-    loadedSourcesRequest(response, args, request) {
-        response.body = response.body || {};
-        response.body.sources = this.debuggee.getAvailableSourcePaths().map(v => ({
-            path: v,
-            name: (0, node_path_1.basename)(v),
-        }));
-        this.sendResponse(response);
-    }
-    breakpointLocationsRequest(response, args, request) {
-        response.body = response.body || {};
-        const path = args.source.path;
-        if (path === undefined) {
-            this.sendErrorResponse(response, {
-                id: 1001,
-                format: 'No path',
-            });
-            return;
-        }
-        response.body.breakpoints = this.debuggee.getAvailableLines(path).filter(l => l >= args.line && l <= (args.endLine ?? args.line)).map(l => ({
-            line: l,
-        }));
-        this.sendResponse(response);
-    }
-    launchRequest(response, args, request) {
-        debugadapter_1.logger.setup(debugadapter_1.Logger.LogLevel.Verbose);
-        this.debuggee.start(!args.noDebug, true);
-        this.sendResponse(response);
-    }
-    attachRequest(response, args, request) {
-        this.launchRequest(response, args, request);
-    }
-    setBreakPointsRequest(response, args, request) {
-        const path = args.source.path;
-        if (path === undefined) {
-            this.sendErrorResponse(response, {
-                id: 1001,
-                format: 'No path',
-            });
-            return;
-        }
-        const breakpoints = args.breakpoints;
-        if (breakpoints === undefined) {
-            this.sendErrorResponse(response, {
-                id: 1002,
-                format: 'No breakpoints',
-            });
-            return;
-        }
-        this.debuggee.clearBreakpoints(path);
-        const bps = [];
-        for (const bp of breakpoints) {
-            const sbp = this.debuggee.setBreakpoint(path, bp.line);
-            bps.push({
-                id: sbp.id,
-                line: sbp.line,
-                verified: sbp.verified,
-            });
-        }
-        response.body = {
-            breakpoints: bps,
-        };
-        this.sendResponse(response);
-    }
-    threadsRequest(response, request) {
-        response.body = {
-            threads: [
-                new debugadapter_1.Thread(TVMDebugSession.threadID, 'main'),
-            ],
-        };
-        this.sendResponse(response);
-    }
-    continueRequest(response, args, request) {
-        this.debuggee.continue();
-        this.sendResponse(response);
-    }
-    nextRequest(response, args, request) {
-        this.debuggee.step();
-        this.sendResponse(response);
-    }
-    stepInRequest(response, args, request) {
-        this.debuggee.step();
-        this.sendResponse(response);
-    }
-    stepOutRequest(response, args, request) {
-        this.debuggee.step();
-        this.sendResponse(response);
-    }
-    stackTraceRequest(response, args, request) {
-        response.body = response.body || {};
-        const sme = this.debuggee.currentSourceMapEntry();
-        if (sme === undefined) {
-            response.body.stackFrames = [];
-            response.body.totalFrames = 0;
-            this.sendResponse(response);
-            return;
-        }
-        response.body.totalFrames = 1;
-        if (args.startFrame ?? 0 > 0) {
-            response.body.stackFrames = [];
-            this.sendResponse(response);
-            return;
-        }
-        response.body.stackFrames = [{
-                id: TVMDebugSession.stackFrameID,
-                name: 'func',
-                line: sme.line,
-                column: 0,
-                source: {
-                    name: (0, node_path_1.basename)(sme.path),
-                    path: sme.path,
-                },
-            }];
-        this.sendResponse(response);
-    }
-    scopesRequest(response, args, request) {
-        response.body = response.body || {};
-        const sme = this.debuggee.currentSourceMapEntry();
-        if (sme === undefined) {
-            response.body.scopes = [];
-            this.sendResponse(response);
-            return;
-        }
-        response.body.scopes = [{
-                name: 'Locals',
-                variablesReference: TVMDebugSession.variablesReference,
-                expensive: false,
-            }];
-        this.sendResponse(response);
-    }
-    variablesRequest(response, args, request) {
-        response.body = response.body || {};
-        response.body.variables = [];
-        const sme = this.debuggee.currentSourceMapEntry();
-        if (sme === undefined) {
-            this.sendResponse(response);
-            return;
-        }
-        const stack = this.debuggee.getStack();
-        for (let i = 0; i < sme.variables.length; i++) {
-            response.body.variables.push({
-                name: sme.variables[i],
-                value: tupleItemToString(stack[i]),
-                type: stack[i].type,
-                variablesReference: 0,
-            });
-        }
-        response.body.variables.sort((a, b) => (a.name < b.name) ? -1 : (a.name > b.name ? 1 : 0));
-        this.sendResponse(response);
-    }
-    disconnectRequest(response, args, request) {
-        if (args.restart) {
-            this.sendErrorResponse(response, {
-                id: 1003,
-                format: 'Cannot restart',
-            });
-        }
-        else {
-            this.sendResponse(response);
-        }
-    }
-}
-exports.TVMDebugSession = TVMDebugSession;
-TVMDebugSession.threadID = 1;
-TVMDebugSession.stackFrameID = 1;
-TVMDebugSession.variablesReference = 1;
-function tupleItemToString(ti) {
-    switch (ti.type) {
-        case 'int':
-            return ti.value.toString();
-        case 'null':
-            return 'null';
-        case 'nan':
-            return 'NaN';
-        case 'cell':
-        case 'slice':
-        case 'builder':
-            return ti.cell.toBoc().toString('base64');
-        case 'tuple':
-            return `[${ti.items.map(v => tupleItemToString(v)).join(', ')}]`;
-    }
-}

package/dist/debugger/TVMDebugSession.d.ts

@@ -0,0 +1,26 @@
+import { LoggingDebugSession } from "@vscode/debugadapter";
+import { Debuggee } from "./Debuggee";
+import { DebugProtocol } from "@vscode/debugprotocol";
+export declare class TVMDebugSession extends LoggingDebugSession {
+    static readonly threadID = 1;
+    static readonly stackFrameID = 1;
+    static readonly localVariablesReference = 1;
+    static readonly globalVariablesReference = 2;
+    debuggee: Debuggee;
+    constructor(debuggee: Debuggee);
+    protected initializeRequest(response: DebugProtocol.InitializeResponse, args: DebugProtocol.InitializeRequestArguments): void;
+    protected loadedSourcesRequest(response: DebugProtocol.LoadedSourcesResponse, args: DebugProtocol.LoadedSourcesArguments, request?: DebugProtocol.Request | undefined): void;
+    protected breakpointLocationsRequest(response: DebugProtocol.BreakpointLocationsResponse, args: DebugProtocol.BreakpointLocationsArguments, request?: DebugProtocol.Request | undefined): void;
+    protected launchRequest(response: DebugProtocol.LaunchResponse, args: DebugProtocol.LaunchRequestArguments, request?: DebugProtocol.Request | undefined): void;
+    protected attachRequest(response: DebugProtocol.AttachResponse, args: DebugProtocol.AttachRequestArguments, request?: DebugProtocol.Request | undefined): void;
+    protected setBreakPointsRequest(response: DebugProtocol.SetBreakpointsResponse, args: DebugProtocol.SetBreakpointsArguments, request?: DebugProtocol.Request | undefined): void;
+    protected threadsRequest(response: DebugProtocol.ThreadsResponse, request?: DebugProtocol.Request | undefined): void;
+    protected continueRequest(response: DebugProtocol.ContinueResponse, args: DebugProtocol.ContinueArguments, request?: DebugProtocol.Request | undefined): void;
+    protected nextRequest(response: DebugProtocol.NextResponse, args: DebugProtocol.NextArguments, request?: DebugProtocol.Request | undefined): void;
+    protected stepInRequest(response: DebugProtocol.StepInResponse, args: DebugProtocol.StepInArguments, request?: DebugProtocol.Request | undefined): void;
+    protected stepOutRequest(response: DebugProtocol.StepOutResponse, args: DebugProtocol.StepOutArguments, request?: DebugProtocol.Request | undefined): void;
+    protected stackTraceRequest(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments, request?: DebugProtocol.Request | undefined): void;
+    protected scopesRequest(response: DebugProtocol.ScopesResponse, args: DebugProtocol.ScopesArguments, request?: DebugProtocol.Request | undefined): void;
+    protected variablesRequest(response: DebugProtocol.VariablesResponse, args: DebugProtocol.VariablesArguments, request?: DebugProtocol.Request | undefined): void;
+    protected disconnectRequest(response: DebugProtocol.DisconnectResponse, args: DebugProtocol.DisconnectArguments, request?: DebugProtocol.Request | undefined): void;
+}