@harmoniclabs/pebble 0.1.3-dev0 → 0.1.3-dev2

package/dist/compiler/Compiler.d.ts

@@ -8,6 +8,11 @@ export declare class Compiler extends DiagnosticEmitter {
     constructor(io?: CompilerIoApi, cfg?: CompilerOptions, diagnostics?: DiagnosticMessage[]);
     compile(config?: Partial<CompilerOptions>): Promise<Uint8Array>;
     export(config: Partial<ExportOptions> & HasFuncitonName): Promise<Uint8Array>;
+    run(config?: Partial<CompilerOptions>): Promise<{
+        result: import("@harmoniclabs/plutus-machine").CEKValueObj;
+        budgetSpent: import("@harmoniclabs/plutus-machine").ExBudget;
+        logs: string[];
+    }>;
     private _compileBackend;
 }
 interface HasFuncitonName {

package/dist/compiler/Compiler.js

@@ -1,4 +1,5 @@
-import { compileUPLC, UPLCProgram } from "@harmoniclabs/uplc";
+import { compileUPLC, parseUPLC, UPLCProgram } from "@harmoniclabs/uplc";
+import { Machine } from "@harmoniclabs/plutus-machine";
 import { DiagnosticEmitter } from "../diagnostics/DiagnosticEmitter.js";
 import { defaultOptions } from "../IR/toUPLC/CompilerOptions.js";
 import { AstCompiler } from "./AstCompiler/AstCompiler.js";
@@ -60,11 +61,34 @@ export class Compiler extends DiagnosticEmitter {
         }
         return this._compileBackend(cfg, program);
     }
+    async run(config) {
+        const cfg = {
+            ...this.cfg,
+            ...config,
+            // NEVER generate markers when running
+            addMarker: false,
+        };
+        const astCompiler = new AstCompiler(cfg, this.io, this.diagnostics);
+        const program = await astCompiler.run();
+        if (this.diagnostics.length > 0) {
+            let msg;
+            globalThis.console && console.log(this.diagnostics);
+            const fstErrorMsg = this.diagnostics[0].toString();
+            const nDiags = this.diagnostics.length;
+            while (msg = this.diagnostics.shift()) {
+                this.io.stdout.write(msg.toString() + "\n");
+            }
+            throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
+        }
+        const serialized = this._compileBackend(cfg, program);
+        const uplcProgram = parseUPLC(serialized);
+        return Machine.eval(uplcProgram.body);
+    }
     _compileBackend(cfg, program) {
         // backend starts here
         const ir = compileTypedProgram(cfg, program);
         const uplc = compileIRToUPLC(ir, cfg);
-        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc)).toBuffer().buffer;
+        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc));
         const outDir = cfg.outDir;
         const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
         this.io.writeFile(outPath, serialized, cfg.root);

package/dist/compiler/TirCompiler/expressify/determineReassignedVariablesAndReturn.js

@@ -9,6 +9,7 @@ import { TirBlockStmt } from "../../tir/statements/TirBlockStmt.js";
 import { TirBreakStmt } from "../../tir/statements/TirBreakStmt.js";
 import { TirContinueStmt } from "../../tir/statements/TirContinueStmt.js";
 import { TirFailStmt } from "../../tir/statements/TirFailStmt.js";
+import { TirTraceStmt } from "../../tir/statements/TirTraceStmt.js";
 import { TirForOfStmt } from "../../tir/statements/TirForOfStmt.js";
 import { TirForStmt } from "../../tir/statements/TirForStmt.js";
 import { TirIfStmt } from "../../tir/statements/TirIfStmt.js";
@@ -25,6 +26,7 @@ export function determineReassignedVariablesAndReturn(stmt) {
     let returns = false;
     while (stmt = stack.pop()) {
         if (stmt instanceof TirFailStmt
+            || stmt instanceof TirTraceStmt
             || isTirVarDecl(stmt)
             || stmt instanceof TirBreakStmt
             || stmt instanceof TirContinueStmt
@@ -84,9 +86,8 @@ export function determineReassignedVariablesAndFlowInfos(stmt) {
     let canContinue = false;
     while (stmt = stack.pop()) {
         if (stmt instanceof TirFailStmt
+            || stmt instanceof TirTraceStmt
             || isTirVarDecl(stmt)
-            || stmt instanceof TirBreakStmt
-            || stmt instanceof TirContinueStmt
             || stmt instanceof TirAssertStmt)
             continue;
         if (stmt instanceof TirBreakStmt) {
@@ -193,7 +194,8 @@ export function definitelyFails(stmt) {
             || stmt instanceof TirBreakStmt
             || stmt instanceof TirContinueStmt
             || stmt instanceof TirAssertStmt
-            || stmt instanceof TirAssignmentStmt)
+            || stmt instanceof TirAssignmentStmt
+            || stmt instanceof TirTraceStmt)
             continue;
         // const tsEnsureExsaustiveCheck: never = stmt;
     }

package/dist/compiler/TirCompiler/expressify/expressify.js

@@ -3,6 +3,7 @@ import { getUniqueInternalName } from "../../internalVar.js";
 import { TirLitVoidExpr } from "../../tir/expressions/litteral/TirLitVoidExpr.js";
 import { TirCaseExpr, TirCaseMatcher, TirWildcardCaseMatcher } from "../../tir/expressions/TirCaseExpr.js";
 import { TirFailExpr } from "../../tir/expressions/TirFailExpr.js";
+import { TirTraceExpr } from "../../tir/expressions/TirTraceExpr.js";
 import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.js";
 import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
 import { TirAssertStmt } from "../../tir/statements/TirAssertStmt.js";
@@ -11,6 +12,7 @@ import { TirBlockStmt } from "../../tir/statements/TirBlockStmt.js";
 import { TirBreakStmt } from "../../tir/statements/TirBreakStmt.js";
 import { TirContinueStmt } from "../../tir/statements/TirContinueStmt.js";
 import { TirFailStmt } from "../../tir/statements/TirFailStmt.js";
+import { TirTraceStmt } from "../../tir/statements/TirTraceStmt.js";
 import { TirForOfStmt } from "../../tir/statements/TirForOfStmt.js";
 import { TirForStmt } from "../../tir/statements/TirForStmt.js";
 import { TirIfStmt } from "../../tir/statements/TirIfStmt.js";
@@ -217,6 +219,12 @@ loopReplacements, assertions = []) {
                 return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirFailExpr(undefined, ctx.returnType, stmt.range));
             }
         }
+        else if (stmt instanceof TirTraceStmt) {
+            const modifiedExpr = expressifyVars(ctx, stmt.expr);
+            stmt.expr = modifiedExpr;
+            const continuation = expressifyFuncBody(ctx, bodyStmts, loopReplacements);
+            return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirTraceExpr(modifiedExpr, continuation, stmt.range));
+        }
         else if (stmt instanceof TirAssertStmt) {
             const condition = expressifyVars(ctx, stmt.condition);
             stmt.condition = condition;

package/dist/compiler/TirCompiler/expressify/expressifyIfBranch.js

@@ -8,6 +8,7 @@ import { TirBlockStmt } from "../../tir/statements/TirBlockStmt.js";
 import { TirBreakStmt } from "../../tir/statements/TirBreakStmt.js";
 import { TirContinueStmt } from "../../tir/statements/TirContinueStmt.js";
 import { TirFailStmt } from "../../tir/statements/TirFailStmt.js";
+import { TirTraceStmt } from "../../tir/statements/TirTraceStmt.js";
 import { TirForOfStmt } from "../../tir/statements/TirForOfStmt.js";
 import { TirForStmt } from "../../tir/statements/TirForStmt.js";
 import { TirIfStmt } from "../../tir/statements/TirIfStmt.js";
@@ -60,6 +61,7 @@ function replaceReturnStatements(body, wrapReturnExpr, sopType) {
             || stmt instanceof TirBreakStmt
             || stmt instanceof TirContinueStmt
             || stmt instanceof TirFailStmt
+            || stmt instanceof TirTraceStmt
             || stmt instanceof TirAssertStmt
             || stmt instanceof TirAssignmentStmt)
             continue;

package/dist/compiler/TirCompiler/expressify/expressifyVars.js

@@ -28,6 +28,7 @@ import { TirPropAccessExpr } from "../../tir/expressions/TirPropAccessExpr.js";
 import { TirTernaryExpr } from "../../tir/expressions/TirTernaryExpr.js";
 import { TirToDataExpr } from "../../tir/expressions/TirToDataExpr.js";
 import { TirTraceIfFalseExpr } from "../../tir/expressions/TirTraceIfFalseExpr.js";
+import { TirTraceExpr } from "../../tir/expressions/TirTraceExpr.js";
 import { TirTypeConversionExpr } from "../../tir/expressions/TirTypeConversionExpr.js";
 import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
 import { TirUnaryExclamation } from "../../tir/expressions/unary/TirUnaryExclamation.js";
@@ -212,6 +213,13 @@ export function expressifyVars(ctx, expr) {
         expr.traceStrExpr = modifiedTraceStrExpr;
         return expr;
     }
+    if (expr instanceof TirTraceExpr) {
+        const modifiedTraceExpr = expressifyVars(ctx, expr.traceExpr);
+        const modifiedContinuation = expressifyVars(ctx, expr.continuation);
+        expr.traceExpr = modifiedTraceExpr;
+        expr.continuation = modifiedContinuation;
+        return expr;
+    }
     if (expr instanceof TirInlineClosedIR)
         return expr;
     const tsEnsureExhautstiveCheck = expr;
@@ -243,9 +251,10 @@ function expressifyPropAccess(ctx, propAccessExpr) {
         || expr instanceof TirFuncExpr // functions have no properties
         || expr instanceof TirParentesizedExpr // typescript being stupid
         || isTirBinaryExpr(expr) // all of these return either int, bytes or boolean
-        // TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirInlineClosedIR
+        // TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirTraceExpr | TirInlineClosedIR
         || expr instanceof TirAssertAndContinueExpr
         || expr instanceof TirTraceIfFalseExpr
+        || expr instanceof TirTraceExpr
         || expr instanceof TirInlineClosedIR)
         throw new Error("Invalid property access expression");
     if (expr instanceof TirLitThisExpr) {

package/dist/compiler/tir/expressions/TirExpr.d.ts

@@ -17,7 +17,8 @@ import { TirHoistedExpr } from "./TirHoistedExpr.js";
 import { TirToDataExpr } from "./TirToDataExpr.js";
 import { TirAssertAndContinueExpr } from "./TirAssertAndContinueExpr.js";
 import { TirTraceIfFalseExpr } from "./TirTraceIfFalseExpr.js";
+import { TirTraceExpr } from "./TirTraceExpr.js";
 import { TirNativeFunc } from "./TirNativeFunc.js";
 import { TirInlineClosedIR } from "./TirInlineClosedIR.js";
-export type TirExpr = (TirUnaryPrefixExpr | TirLitteralExpr | TirParentesizedExpr | TirFuncExpr | TirCallExpr | TirCaseExpr | TirTypeConversionExpr | TirElemAccessExpr | TirTernaryExpr | TirPropAccessExpr | TirBinaryExpr | TirVariableAccessExpr | TirLettedExpr | TirNativeFunc | TirFailExpr | TirHoistedExpr | TirFromDataExpr | TirToDataExpr | TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirInlineClosedIR);
+export type TirExpr = (TirUnaryPrefixExpr | TirLitteralExpr | TirParentesizedExpr | TirFuncExpr | TirCallExpr | TirCaseExpr | TirTypeConversionExpr | TirElemAccessExpr | TirTernaryExpr | TirPropAccessExpr | TirBinaryExpr | TirVariableAccessExpr | TirLettedExpr | TirNativeFunc | TirFailExpr | TirHoistedExpr | TirFromDataExpr | TirToDataExpr | TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirTraceExpr | TirInlineClosedIR);
 export declare function isTirExpr(thing: any): thing is TirExpr;

package/dist/compiler/tir/expressions/TirExpr.js

@@ -18,6 +18,7 @@ import { TirHoistedExpr } from "./TirHoistedExpr.js";
 import { TirToDataExpr } from "./TirToDataExpr.js";
 import { TirAssertAndContinueExpr } from "./TirAssertAndContinueExpr.js";
 import { TirTraceIfFalseExpr } from "./TirTraceIfFalseExpr.js";
+import { TirTraceExpr } from "./TirTraceExpr.js";
 import { TirNativeFunc } from "./TirNativeFunc.js";
 import { TirInlineClosedIR } from "./TirInlineClosedIR.js";
 export function isTirExpr(thing) {
@@ -42,5 +43,6 @@ export function isTirExpr(thing) {
         || thing instanceof TirToDataExpr
         || thing instanceof TirAssertAndContinueExpr
         || thing instanceof TirTraceIfFalseExpr
+        || thing instanceof TirTraceExpr
         || thing instanceof TirInlineClosedIR);
 }

package/dist/compiler/tir/expressions/TirNativeFunc.js

@@ -117,7 +117,7 @@ export class TirNativeFunc {
             int_t
         ], bool_t));
     }
-    // ByteString operations
+    // bytes operations
     static get appendByteString() {
         return new TirNativeFunc(IRNativeTag.appendByteString, new TirFuncT([
             // left
@@ -512,7 +512,7 @@ export class TirNativeFunc {
             bytes_t
         ], bytes_t));
     }
-    // ByteString manipulation
+    // bytes manipulation
     static get integerToByteString() {
         return new TirNativeFunc(IRNativeTag.integerToByteString, new TirFuncT([
             // flag
@@ -585,7 +585,7 @@ export class TirNativeFunc {
             bool_t
         ], bytes_t));
     }
-    // Additional ByteString operations
+    // Additional bytes operations
     static get replicateByte() {
         return new TirNativeFunc(IRNativeTag.replicateByte, new TirFuncT([
             // count

package/dist/compiler/tir/expressions/TirTraceExpr.d.ts

@@ -0,0 +1,22 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirTraceExpr implements ITirExpr {
+    /** must be bytes or int (converted to string via decodeUtf8 in toIR) */
+    traceExpr: TirExpr;
+    continuation: TirExpr;
+    readonly range: SourceRange;
+    get type(): TirType;
+    constructor(
+    /** must be bytes or int (converted to string via decodeUtf8 in toIR) */
+    traceExpr: TirExpr, continuation: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/TirTraceExpr.js

@@ -0,0 +1,53 @@
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { hoisted_intToUtf8Bytes } from "../../../IR/tree_utils/intToUtf8Bytes.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+import { TirIntT } from "../types/TirNativeType/index.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+export class TirTraceExpr {
+    traceExpr;
+    continuation;
+    range;
+    get type() { return this.continuation.type; }
+    constructor(
+    /** must be bytes or int (converted to string via decodeUtf8 in toIR) */
+    traceExpr, continuation, range) {
+        this.traceExpr = traceExpr;
+        this.continuation = continuation;
+        this.range = range;
+    }
+    toString() {
+        return `(trace ${this.traceExpr.toString()} ${this.continuation.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_1 = indent_base + singleIndent;
+        return (`(trace` +
+            `\n${indent_1}${this.traceExpr.pretty(indent + 1)}` +
+            `\n${indent_1}${this.continuation.pretty(indent + 1)}` +
+            `\n${indent_base})`);
+    }
+    clone() {
+        return new TirTraceExpr(this.traceExpr.clone(), this.continuation.clone(), this.range.clone());
+    }
+    deps() {
+        return mergeSortedStrArrInplace(this.traceExpr.deps(), this.continuation.deps());
+    }
+    get isConstant() { return this.traceExpr.isConstant && this.continuation.isConstant; }
+    toIR(ctx) {
+        let bytesIR;
+        const exprType = getUnaliased(this.traceExpr.type);
+        if (exprType instanceof TirIntT) {
+            // int -> bytes via intToUtf8Bytes
+            bytesIR = _ir_apps(hoisted_intToUtf8Bytes.clone(), this.traceExpr.toIR(ctx));
+        }
+        else {
+            // assume bytes
+            bytesIR = this.traceExpr.toIR(ctx);
+        }
+        return _ir_apps(IRNative.trace, 
+        // bytes -> string via decodeUtf8
+        _ir_apps(IRNative.decodeUtf8, bytesIR), this.continuation.toIR(ctx));
+    }
+}

package/dist/compiler/tir/expressions/TirTypeConversionExpr.js

@@ -5,6 +5,7 @@ import { TirBytesT } from "../types/TirNativeType/native/bytes.js";
 import { TirDataT } from "../types/TirNativeType/native/data.js";
 import { TirIntT } from "../types/TirNativeType/native/int.js";
 import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
+import { TirStringT } from "../types/TirNativeType/native/string.js";
 import { TirDataStructType } from "../types/TirStructType.js";
 import { getUnaliased } from "../types/utils/getUnaliased.js";
 import { _inlineFromData } from "./TirFromDataExpr.js";
@@ -69,6 +70,11 @@ export class TirTypeConversionExpr {
                 return _ir_apps(IRNative._intToBool, exprIR);
             throw new Error(`Cannot convert from ${from_t.toString()} to ${to_t.toString()}`);
         }
+        if (to_t instanceof TirStringT) {
+            if (from_t instanceof TirBytesT)
+                return _ir_apps(IRNative.decodeUtf8, exprIR);
+            throw new Error(`Cannot convert from ${from_t.toString()} to ${to_t.toString()}`);
+        }
         throw new Error(`Cannot convert from ${from_t.toString()} to ${to_t.toString()}`);
     }
 }

package/dist/compiler/tir/statements/TirStmt.d.ts

@@ -4,6 +4,7 @@ import { TirBlockStmt } from "./TirBlockStmt.js";
 import { TirBreakStmt } from "./TirBreakStmt.js";
 import { TirContinueStmt } from "./TirContinueStmt.js";
 import { TirFailStmt } from "./TirFailStmt.js";
+import { TirTraceStmt } from "./TirTraceStmt.js";
 import { TirForOfStmt } from "./TirForOfStmt.js";
 import { TirForStmt } from "./TirForStmt.js";
 import { TirIfStmt } from "./TirIfStmt.js";
@@ -30,5 +31,5 @@ export interface ITirStmt extends HasSourceRange {
     toString: () => string;
     pretty: (indent: number) => string;
 }
-export type TirStmt = TirVarDecl | TirIfStmt | TirForStmt | TirForOfStmt | TirWhileStmt | TirReturnStmt | TirBlockStmt | TirBreakStmt | TirContinueStmt | TirFailStmt | TirAssertStmt | TirMatchStmt | TirAssignmentStmt;
+export type TirStmt = TirVarDecl | TirIfStmt | TirForStmt | TirForOfStmt | TirWhileStmt | TirReturnStmt | TirBlockStmt | TirBreakStmt | TirContinueStmt | TirFailStmt | TirAssertStmt | TirTraceStmt | TirMatchStmt | TirAssignmentStmt;
 export declare function isTirStmt(thing: any): thing is TirStmt;

package/dist/compiler/tir/statements/TirStmt.js

@@ -5,6 +5,7 @@ import { TirBlockStmt } from "./TirBlockStmt.js";
 import { TirBreakStmt } from "./TirBreakStmt.js";
 import { TirContinueStmt } from "./TirContinueStmt.js";
 import { TirFailStmt } from "./TirFailStmt.js";
+import { TirTraceStmt } from "./TirTraceStmt.js";
 import { TirForOfStmt } from "./TirForOfStmt.js";
 import { TirForStmt } from "./TirForStmt.js";
 import { TirIfStmt } from "./TirIfStmt.js";
@@ -32,6 +33,7 @@ export function isTirStmt(thing) {
         || thing instanceof TirContinueStmt
         || thing instanceof TirFailStmt
         || thing instanceof TirAssertStmt
+        || thing instanceof TirTraceStmt
         // || thing instanceof TirTestStmt
         || thing instanceof TirMatchStmt
         || thing instanceof TirAssignmentStmt

package/dist/compiler/tir/statements/TirTraceStmt.d.ts

@@ -0,0 +1,15 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { ITirStmt } from "./TirStmt.js";
+export declare class TirTraceStmt implements ITirStmt {
+    /** must be string */
+    expr: TirExpr;
+    readonly range: SourceRange;
+    constructor(
+    /** must be string */
+    expr: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirTraceStmt.js

@@ -0,0 +1,20 @@
+export class TirTraceStmt {
+    expr;
+    range;
+    constructor(
+    /** must be string */
+    expr, range) {
+        this.expr = expr;
+        this.range = range;
+    }
+    toString() {
+        return `trace ${this.expr.toString()}`;
+    }
+    pretty(indent) {
+        return `trace ${this.expr.pretty(indent)}`;
+    }
+    definitelyTerminates() { return false; }
+    deps() {
+        return this.expr.deps();
+    }
+}

package/dist/index.d.ts

@@ -1,7 +1,5 @@
-export * from "@harmoniclabs/bytestring";
 export * from "@harmoniclabs/cbor";
 export * from "@harmoniclabs/obj-utils";
-export * from "@harmoniclabs/pair";
 export * from "@harmoniclabs/plutus-data";
 export * from "@harmoniclabs/plutus-machine";
 export * from "@harmoniclabs/uint8array-utils";

package/dist/index.js

@@ -1,7 +1,5 @@
-export * from "@harmoniclabs/bytestring";
 export * from "@harmoniclabs/cbor";
 export * from "@harmoniclabs/obj-utils";
-export * from "@harmoniclabs/pair";
 export * from "@harmoniclabs/plutus-data";
 export * from "@harmoniclabs/plutus-machine";
 export * from "@harmoniclabs/uint8array-utils";

package/dist/parser/Parser.d.ts

@@ -22,6 +22,7 @@ import { IfStmt } from "../ast/nodes/statements/IfStmt.js";
 import { ReturnStmt } from "../ast/nodes/statements/ReturnStmt.js";
 import { FuncDecl } from "../ast/nodes/statements/declarations/FuncDecl.js";
 import { FailStmt } from "../ast/nodes/statements/FailStmt.js";
+import { TraceStmt } from "../ast/nodes/statements/TraceStmt.js";
 import { AssertStmt } from "../ast/nodes/statements/AssertStmt.js";
 import { TestStmt } from "../ast/nodes/statements/TestStmt.js";
 import { MatchStmt } from "../ast/nodes/statements/MatchStmt.js";
@@ -131,6 +132,7 @@ export declare class Parser extends DiagnosticEmitter {
     parseTestStatement(): TestStmt | undefined;
     parseMatchStatement(): MatchStmt | undefined;
     parseFailStatement(): FailStmt | undefined;
+    parseTraceStatement(): TraceStmt | undefined;
     parseAssertStatement(): AssertStmt | undefined;
     parseWhileStatement(): WhileStmt | undefined;
     /**

package/dist/parser/Parser.js

@@ -41,6 +41,7 @@ import { ReturnStmt } from "../ast/nodes/statements/ReturnStmt.js";
 import { EmptyStmt } from "../ast/nodes/statements/EmptyStmt.js";
 import { FuncDecl } from "../ast/nodes/statements/declarations/FuncDecl.js";
 import { FailStmt } from "../ast/nodes/statements/FailStmt.js";
+import { TraceStmt } from "../ast/nodes/statements/TraceStmt.js";
 import { AssertStmt } from "../ast/nodes/statements/AssertStmt.js";
 import { TestStmt } from "../ast/nodes/statements/TestStmt.js";
 import { MatchStmt, MatchStmtCase, MatchStmtElseCase } from "../ast/nodes/statements/MatchStmt.js";
@@ -1919,6 +1920,12 @@ export class Parser extends DiagnosticEmitter {
                     break;
                 }
                 ;
+            case Token.Trace:
+                {
+                    statement = this.parseTraceStatement();
+                    break;
+                }
+                ;
             // case Token.Try: {
             //     statement = this.parseTryStatement();
             //     break;
@@ -2319,6 +2326,14 @@ export class Parser extends DiagnosticEmitter {
             return undefined;
         return new FailStmt(expr, tn.range());
     }
+    parseTraceStatement() {
+        const tn = this.tn;
+        // at 'trace': Expression ';'?
+        const expr = this.parseExpr();
+        if (!expr)
+            return this.error(DiagnosticCode.Expression_expected, tn.range());
+        return new TraceStmt(expr, tn.range());
+    }
     parseAssertStatement() {
         const tn = this.tn;
         const startPos = tn.tokenPos;