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

package/dist/debugger/DebugInfoCache.js

@@ -14,13 +14,31 @@ function registerCompiledContract(c) {
     const sm = {};
     for (let i = 0; i < locations.length; i++) {
         const di = locations[i];
-        if (di.ret || di.vars === undefined)
-            continue;
-        sm[i] = {
+        const common = {
             path: (0, node_path_1.resolve)(di.file),
             line: di.line,
-            variables: di.vars ?? [],
+            function: di.func,
         };
+        if (di.ret) {
+            sm[i] = {
+                ...common,
+                type: 'return',
+            };
+        }
+        else if (di.is_catch) {
+            sm[i] = {
+                ...common,
+                type: 'catch',
+            };
+        }
+        else {
+            sm[i] = {
+                ...common,
+                type: 'statement',
+                variables: di.vars ?? [],
+                firstStatement: di.first_stmt,
+            };
+        }
     }
     exports.defaultDebugInfoCache.set(c.code.hash().toString('base64'), {
         sourceMap: sm,

package/dist/debugger/Debuggee.d.ts

@@ -2,11 +2,19 @@
 import EventEmitter from 'node:events';
 import { Executor, GetMethodArgs, RunTransactionArgs } from '../executor/Executor';
 import { Cell, TupleItem } from '@ton/core';
-export type SourceMapEntry = {
+export type SourceMapEntry = ({
     path: string;
     line: number;
+    function: string;
+}) & ({
+    type: 'statement';
     variables: string[];
-};
+    firstStatement?: true;
+} | {
+    type: 'return';
+} | {
+    type: 'catch';
+});
 export type SourceMap = {
     [k: number]: SourceMapEntry;
 };
@@ -26,6 +34,11 @@ export type Variable = {
     name: string;
     value: TupleItem;
 };
+type StackFrame = {
+    function: string;
+    path: string;
+    line: number;
+};
 export declare class Debuggee extends EventEmitter {
     executor: Executor;
     ptr: number;
@@ -37,7 +50,7 @@ export declare class Debuggee extends EventEmitter {
     codeCells: Map<string, Cell>;
     breakpoints: Map<string, Breakpoint[]>;
     breakpointID: number;
-    frames: string[];
+    frames: StackFrame[];
     globals: GlobalEntry[];
     finishedCallback: (v: any) => void;
     constructor(executor: Executor, finishedCallback: (v: any) => void);
@@ -49,7 +62,9 @@ export declare class Debuggee extends EventEmitter {
     getAvailableLines(path: string): number[];
     isLineAvailable(path: string, line: number): boolean;
     continue(): void;
-    step(stopEvent?: string): void;
+    stepIn(): void;
+    stepOver(): void;
+    stepOut(): void;
     startGetMethod(args: GetMethodArgs): void;
     startTransaction(args: RunTransactionArgs): void;
     getC7(): TupleItem;
@@ -59,6 +74,8 @@ export declare class Debuggee extends EventEmitter {
         offset: number;
     };
     getStack(): TupleItem[];
+    getContParam(): number;
+    setContParam(param: number): number;
     getLocalVariables(): Variable[] | undefined;
     getGlobalVariables(): Variable[] | undefined;
     currentDebugInfoNumber(): number | undefined;
@@ -73,7 +90,17 @@ export declare class Debuggee extends EventEmitter {
     setBreakpoint(path: string, line: number): Breakpoint;
     sendEvent(event: string, ...args: any[]): void;
     onFinished(): void;
-    stepUntilLine(breakpointsOnly: boolean, stopEvent?: string): void;
+    stackFrames(): StackFrame[];
+    stepUntil(what: {
+        type: 'breakpoint';
+    } | {
+        type: 'any-line';
+        stopEvent: 'stopOnBreakpoint' | 'stopOnStep';
+    } | {
+        type: 'next-line';
+    } | {
+        type: 'out';
+    }): void;
     prepareGetMethod(args: GetMethodArgs, debugInfo: DebugInfo): void;
     prepareTransaction(args: RunTransactionArgs, code: Cell, debugInfo: DebugInfo): void;
     start(debug: boolean, stopOnEntry: boolean): void;

package/dist/debugger/Debuggee.js

@@ -63,10 +63,16 @@ class Debuggee extends node_events_1.default {
         return lines.indexOf(line) >= 0;
     }
     continue() {
-        this.stepUntilLine(true);
+        this.stepUntil({ type: 'breakpoint' });
     }
-    step(stopEvent = 'stopOnStep') {
-        this.stepUntilLine(false, stopEvent);
+    stepIn() {
+        this.stepUntil({ type: 'any-line', stopEvent: 'stopOnStep' });
+    }
+    stepOver() {
+        this.stepUntil({ type: 'next-line' });
+    }
+    stepOut() {
+        this.stepUntil({ type: 'out' });
     }
     startGetMethod(args) {
         this.ptr = this.executor.sbsGetMethodSetup(args);
@@ -112,9 +118,25 @@ class Debuggee extends node_events_1.default {
                 return this.executor.sbsTransactionStack(this.ptr);
         }
     }
+    getContParam() {
+        switch (this.debugType) {
+            case 'get':
+                return this.executor.sbsGetMethodGetContParam(this.ptr);
+            case 'tx':
+                return this.executor.sbsTransactionGetContParam(this.ptr);
+        }
+    }
+    setContParam(param) {
+        switch (this.debugType) {
+            case 'get':
+                return this.executor.sbsGetMethodSetContParam(this.ptr, param);
+            case 'tx':
+                return this.executor.sbsTransactionSetContParam(this.ptr, param);
+        }
+    }
     getLocalVariables() {
         const sme = this.currentSourceMapEntry();
-        if (sme === undefined) {
+        if (sme === undefined || sme.type !== 'statement') {
             return undefined;
         }
         const vars = [];
@@ -231,7 +253,20 @@ class Debuggee extends node_events_1.default {
         }
         this.finishedCallback(r);
     }
-    stepUntilLine(breakpointsOnly, stopEvent) {
+    stackFrames() {
+        return this.frames;
+    }
+    stepUntil(what) {
+        let until;
+        switch (what.type) {
+            case 'next-line':
+            case 'out': {
+                until = { type: what.type, depth: this.frames.length };
+                break;
+            }
+            default:
+                until = what;
+        }
         while (true) {
             const finished = this.vmStep();
             if (finished) {
@@ -239,14 +274,56 @@ class Debuggee extends node_events_1.default {
                 return;
             }
             const sme = this.currentSourceMapEntry();
-            if (sme !== undefined && (!breakpointsOnly || this.hasBreakpoint(sme.path, sme.line))) {
-                if (breakpointsOnly) {
-                    this.sendEvent('stopOnBreakpoint');
+            if (sme !== undefined) {
+                switch (sme.type) {
+                    case 'statement': {
+                        if (sme.firstStatement) {
+                            this.frames.push({
+                                function: sme.function,
+                                path: sme.path,
+                                line: sme.line,
+                            });
+                            this.setContParam(this.frames.length);
+                        }
+                        this.frames[this.frames.length - 1].line = sme.line;
+                        switch (until.type) {
+                            case 'breakpoint': {
+                                if (this.hasBreakpoint(sme.path, sme.line)) {
+                                    this.sendEvent('stopOnBreakpoint');
+                                    return;
+                                }
+                                break;
+                            }
+                            case 'any-line': {
+                                this.sendEvent(until.stopEvent);
+                                return;
+                            }
+                            case 'next-line': {
+                                if (this.frames.length <= until.depth) {
+                                    this.sendEvent('stopOnStep');
+                                    return;
+                                }
+                                break;
+                            }
+                            case 'out': {
+                                if (this.frames.length < until.depth) {
+                                    this.sendEvent('stopOnStep');
+                                    return;
+                                }
+                                break;
+                            }
+                        }
+                        break;
+                    }
+                    case 'return': {
+                        this.frames.pop();
+                        break;
+                    }
+                    case 'catch': {
+                        this.frames = this.frames.slice(0, this.getContParam());
+                        break;
+                    }
                 }
-                else if (stopEvent !== undefined) {
-                    this.sendEvent(stopEvent);
-                }
-                return;
             }
         }
     }
@@ -263,7 +340,7 @@ class Debuggee extends node_events_1.default {
     start(debug, stopOnEntry) {
         if (debug) {
             if (stopOnEntry) {
-                this.step('stopOnEntry');
+                this.stepUntil({ type: 'any-line', stopEvent: 'stopOnBreakpoint' });
             }
             else {
                 this.continue();

package/dist/debugger/TVMDebugSession.js

@@ -139,15 +139,15 @@ class TVMDebugSession extends debugadapter_1.LoggingDebugSession {
         this.sendResponse(response);
     }
     nextRequest(response, args, request) {
-        this.debuggee.step();
+        this.debuggee.stepOver();
         this.sendResponse(response);
     }
     stepInRequest(response, args, request) {
-        this.debuggee.step();
+        this.debuggee.stepIn();
         this.sendResponse(response);
     }
     stepOutRequest(response, args, request) {
-        this.debuggee.step();
+        this.debuggee.stepOut();
         this.sendResponse(response);
     }
     stackTraceRequest(response, args, request) {
@@ -159,26 +159,37 @@ class TVMDebugSession extends debugadapter_1.LoggingDebugSession {
             this.sendResponse(response);
             return;
         }
-        response.body.totalFrames = 1;
-        if (args.startFrame ?? 0 > 0) {
+        const frames = this.debuggee.stackFrames();
+        response.body.totalFrames = frames.length;
+        if (args.startFrame ?? 0 >= frames.length) {
             response.body.stackFrames = [];
             this.sendResponse(response);
             return;
         }
-        response.body.stackFrames = [{
-                id: TVMDebugSession.stackFrameID,
-                name: 'func',
-                line: sme.line,
+        response.body.stackFrames = [];
+        for (let i = args.startFrame ?? 0; i < frames.length; i++) {
+            const frame = frames[i];
+            response.body.stackFrames.push({
+                id: i === frames.length - 1 ? TVMDebugSession.stackFrameID : 0,
+                name: frame.function,
+                line: frame.line,
                 column: 0,
                 source: {
-                    name: (0, node_path_1.basename)(sme.path),
-                    path: sme.path,
+                    name: (0, node_path_1.basename)(frame.path),
+                    path: frame.path,
                 },
-            }];
+            });
+        }
+        response.body.stackFrames.reverse();
         this.sendResponse(response);
     }
     scopesRequest(response, args, request) {
         response.body = response.body || {};
+        if (args.frameId !== TVMDebugSession.stackFrameID) {
+            response.body.scopes = [];
+            this.sendResponse(response);
+            return;
+        }
         const sme = this.debuggee.currentSourceMapEntry();
         if (sme === undefined) {
             response.body.scopes = [];

package/dist/executor/Executor.d.ts

@@ -99,6 +99,8 @@ export declare class Executor implements IExecutor {
     sbsGetMethodStep(ptr: number): boolean;
     sbsGetMethodStack(ptr: number): TupleItem[];
     sbsGetMethodC7(ptr: number): TupleItem;
+    sbsGetMethodGetContParam(ptr: number): number;
+    sbsGetMethodSetContParam(ptr: number, param: number): number;
     sbsGetMethodCodePos(ptr: number): {
         hash: string;
         offset: number;
@@ -116,5 +118,7 @@ export declare class Executor implements IExecutor {
     };
     sbsTransactionStack(ptr: number): TupleItem[];
     sbsTransactionC7(ptr: number): TupleItem;
+    sbsTransactionGetContParam(ptr: number): number;
+    sbsTransactionSetContParam(ptr: number, param: number): number;
     sbsTransactionResult(ptr: number): EmulationResult;
 }

package/dist/executor/Executor.js

@@ -253,6 +253,17 @@ class Executor {
         ]));
         return (0, core_1.parseTuple)((0, core_1.beginCell)().storeUint(1, 24).storeRef(core_1.Cell.EMPTY).storeSlice(core_1.Cell.fromBase64(resp).beginParse()).endCell())[0];
     }
+    sbsGetMethodGetContParam(ptr) {
+        return this.invoke('_sbs_get_cont_param', [
+            ptr
+        ]);
+    }
+    sbsGetMethodSetContParam(ptr, param) {
+        return this.invoke('_sbs_set_cont_param', [
+            ptr,
+            param
+        ]);
+    }
     sbsGetMethodCodePos(ptr) {
         const resp = this.extractString(this.invoke('_sbs_get_code_pos', [
             ptr
@@ -317,6 +328,17 @@ class Executor {
         ]));
         return (0, core_1.parseTuple)((0, core_1.beginCell)().storeUint(1, 24).storeRef(core_1.Cell.EMPTY).storeSlice(core_1.Cell.fromBase64(resp).beginParse()).endCell())[0];
     }
+    sbsTransactionGetContParam(ptr) {
+        return this.invoke('_em_sbs_get_cont_param', [
+            ptr
+        ]);
+    }
+    sbsTransactionSetContParam(ptr, param) {
+        return this.invoke('_em_sbs_set_cont_param', [
+            ptr,
+            param
+        ]);
+    }
     sbsTransactionResult(ptr) {
         const result = JSON.parse(this.extractString(this.invoke('_em_sbs_result', [
             ptr