@harmoniclabs/pebble 0.1.3-dev1 → 0.1.3-dev2

package/dist/IR/tree_utils/intToUtf8Bytes.d.ts

@@ -0,0 +1,8 @@
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+/**
+ * Hoisted IR term: `int -> bytes`
+ *
+ * Converts an integer to its decimal UTF-8 byte representation.
+ * Handles negative numbers by prepending '-' (0x2d).
+ */
+export declare const hoisted_intToUtf8Bytes: IRHoisted;

package/dist/IR/tree_utils/intToUtf8Bytes.js

@@ -0,0 +1,49 @@
+import { IRApp, _ir_apps } from "../IRNodes/IRApp.js";
+import { IRConst } from "../IRNodes/IRConst.js";
+import { IRFunc } from "../IRNodes/IRFunc.js";
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+import { IRNative } from "../IRNodes/IRNative/index.js";
+import { IRRecursive } from "../IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../IRNodes/IRSelfCall.js";
+import { IRVar } from "../IRNodes/IRVar.js";
+import { _ir_lazyIfThenElse } from "./_ir_lazyIfThenElse.js";
+// digitToBytes(n) = consByteString( addInteger(n, 48), #"" )
+// positiveIntToBs = fix \self \n ->
+//   ifThenElse (lessThanInteger n 10)
+//     (consByteString (addInteger n 48) #"")
+//     (appendByteString (self (divideInteger n 10)) (consByteString (addInteger (modInteger n 10) 48) #""))
+// intToUtf8Bytes(n) =
+//   ifThenElse (lessThanEqualInteger 0 n)
+//     (positiveIntToBs n)
+//     (appendByteString (consByteString 45 #"") (positiveIntToBs (subtractInteger 0 n)))
+const self_sym = Symbol("intToUtf8Bytes_self");
+const n_sym = Symbol("intToUtf8Bytes_n");
+const outer_n_sym = Symbol("intToUtf8Bytes_outer_n");
+const emptyBs = IRConst.bytes(new Uint8Array(0));
+function digitToBytes(n) {
+    return _ir_apps(IRNative.consByteString, _ir_apps(IRNative.addInteger, n, IRConst.int(48)), emptyBs.clone());
+}
+const hoisted_positiveIntToBs = new IRHoisted(new IRRecursive(self_sym, new IRFunc([n_sym], _ir_lazyIfThenElse(
+// condition: n < 10
+_ir_apps(IRNative.lessThanInteger, new IRVar(n_sym), IRConst.int(10)), 
+// then: digitToBytes(n)
+digitToBytes(new IRVar(n_sym)), 
+// else: appendByteString( self(n / 10), digitToBytes(n % 10) )
+_ir_apps(IRNative.appendByteString, new IRApp(new IRSelfCall(self_sym), _ir_apps(IRNative.divideInteger, new IRVar(n_sym), IRConst.int(10))), digitToBytes(_ir_apps(IRNative.modInteger, new IRVar(n_sym), IRConst.int(10))))))));
+hoisted_positiveIntToBs.hash;
+/**
+ * Hoisted IR term: `int -> bytes`
+ *
+ * Converts an integer to its decimal UTF-8 byte representation.
+ * Handles negative numbers by prepending '-' (0x2d).
+ */
+export const hoisted_intToUtf8Bytes = new IRHoisted(new IRFunc([outer_n_sym], _ir_lazyIfThenElse(
+// condition: 0 <= n
+_ir_apps(IRNative.lessThanEqualInteger, IRConst.int(0), new IRVar(outer_n_sym)), 
+// then: positiveIntToBs(n)
+_ir_apps(hoisted_positiveIntToBs.clone(), new IRVar(outer_n_sym)), 
+// else: appendByteString( consByteString(45, #""), positiveIntToBs(0 - n) )
+_ir_apps(IRNative.appendByteString, 
+// "-" as bytes
+_ir_apps(IRNative.consByteString, IRConst.int(45), emptyBs.clone()), _ir_apps(hoisted_positiveIntToBs.clone(), _ir_apps(IRNative.subtractInteger, IRConst.int(0), new IRVar(outer_n_sym)))))));
+hoisted_intToUtf8Bytes.hash;

package/dist/ast/nodes/statements/PebbleStmt.d.ts

@@ -24,7 +24,8 @@ import { FuncDecl } from "./declarations/FuncDecl.js";
 import { ExportStmt } from "./ExportStmt.js";
 import { InterfaceDecl } from "./declarations/InterfaceDecl.js";
 import { ContractDecl } from "./declarations/ContractDecl.js";
+import { TraceStmt } from "./TraceStmt.js";
 export type TopLevelStmt = EmptyStmt | VarStmt | PebbleTypeDecl | InterfaceDecl | FuncDecl | TestStmt | ExportStmt | ExportStarStmt | ExportImportStmt | ImportStmt | ImportStarStmt | TypeImplementsStmt | UsingStmt | ContractDecl;
 export declare function isTopLevelStmt(stmt: any): stmt is TopLevelStmt;
-export type BodyStmt = IfStmt | VarStmt | ForStmt | ForOfStmt | WhileStmt | ReturnStmt | BlockStmt | BreakStmt | ContinueStmt | EmptyStmt | FailStmt | AssertStmt | MatchStmt | AssignmentStmt | UsingStmt;
+export type BodyStmt = IfStmt | VarStmt | ForStmt | ForOfStmt | WhileStmt | ReturnStmt | BlockStmt | BreakStmt | ContinueStmt | EmptyStmt | FailStmt | AssertStmt | TraceStmt | MatchStmt | AssignmentStmt | UsingStmt;
 export declare function isBodyStmt(stmt: any): stmt is BodyStmt;

package/dist/ast/nodes/statements/PebbleStmt.js

@@ -26,6 +26,7 @@ import { UsingStmt } from "./UsingStmt.js";
 import { FuncDecl } from "./declarations/FuncDecl.js";
 import { ExportStmt } from "./ExportStmt.js";
 import { ContractDecl } from "./declarations/ContractDecl.js";
+import { TraceStmt } from "./TraceStmt.js";
 export function isTopLevelStmt(stmt) {
     return (stmt instanceof EmptyStmt
         || stmt instanceof VarStmt
@@ -55,6 +56,7 @@ export function isBodyStmt(stmt) {
         || stmt instanceof EmptyStmt
         || stmt instanceof FailStmt
         || stmt instanceof AssertStmt
+        || stmt instanceof TraceStmt
         || stmt instanceof MatchStmt
         || isAssignmentStmt(stmt)
         // || stmt instanceof ExprStmt

package/dist/ast/nodes/statements/TraceStmt.d.ts

@@ -0,0 +1,11 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+export declare class TraceStmt implements HasSourceRange {
+    /** expression to trace (must be string) */
+    expr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(
+    /** expression to trace (must be string) */
+    expr: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/statements/TraceStmt.js

@@ -0,0 +1,10 @@
+export class TraceStmt {
+    expr;
+    range;
+    constructor(
+    /** expression to trace (must be string) */
+    expr, range) {
+        this.expr = expr;
+        this.range = range;
+    }
+}

package/dist/compiler/AstCompiler/AstCompiler.d.ts

@@ -43,6 +43,17 @@ export declare class AstCompiler extends DiagnosticEmitter {
     constructor(cfg: CompilerOptions, io?: CompilerIoApi, diagnostics?: DiagnosticMessage[]);
     private _isExporting;
     export(funcName: string, modulePath?: string): Promise<TypedProgram>;
+    /**
+     * Parses the entry file, wraps all top-level statements
+     * (except functions, contracts, type declarations, imports, and exports)
+     * into a synthetic function, then compiles via export.
+     *
+     * The wrapping is done at the source text level (before parsing)
+     * so that statements which are not parseable at the top level
+     * (e.g. for loops, assignments, trace calls) become valid
+     * inside a function body.
+     */
+    run(): Promise<TypedProgram>;
     /**
      * compiles the entry file specified in the config
      *

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -104,6 +104,38 @@ export class AstCompiler extends DiagnosticEmitter {
         this.program.contractTirFuncName = funcName;
         return await this.compile();
     }
+    /**
+     * Parses the entry file, wraps all top-level statements
+     * (except functions, contracts, type declarations, imports, and exports)
+     * into a synthetic function, then compiles via export.
+     *
+     * The wrapping is done at the source text level (before parsing)
+     * so that statements which are not parseable at the top level
+     * (e.g. for loops, assignments, trace calls) become valid
+     * inside a function body.
+     */
+    async run() {
+        const RUN_FUNC_NAME = "__pebble_run__";
+        this._isExporting = true;
+        this.program.contractTirFuncName = RUN_FUNC_NAME;
+        const filePath = this.cfg.entry;
+        if (!filePath) {
+            this.error(DiagnosticCode.File_0_not_found, undefined, this.cfg.entry);
+            throw new Error("entry file not found");
+        }
+        if (!this.io.exsistSync(filePath))
+            throw new Error("AstCompiler.run: entry file does not exist: " + filePath);
+        const src = await this.getAbsoulteProjPathSource(filePath);
+        if (!src)
+            throw new Error("AstCompiler.run: could not read source: " + filePath);
+        // 1) Rewrite the source text: wrap non-declaration statements in a function
+        src.text = _wrapSourceTextForRun(src.text, RUN_FUNC_NAME);
+        // update range to match the new text length
+        src.range.end = src.text.length;
+        // 2) Use the normal compilation pipeline (parse + semantic analysis)
+        //    which now sees the entry source as having a top-level function
+        return await this.compile();
+    }
     /**
      * compiles the entry file specified in the config
      *
@@ -676,3 +708,156 @@ function isImportStmtLike(stmt) {
         || stmt instanceof ImportStarStmt
         || stmt instanceof ExportStarStmt);
 }
+/** Keywords that start a top-level declaration (kept outside the run wrapper). */
+const _declKeywords = new Set([
+    "import",
+    "export",
+    "function",
+    "struct",
+    "enum",
+    "type",
+    "interface",
+    "contract",
+    "data",
+    "runtime",
+]);
+/**
+ * Splits source text into declaration blocks and body blocks
+ * using a simple character scanner, then wraps body blocks
+ * in a `function <funcName>(): void { ... }`.
+ *
+ * Declaration keywords (import, export, function, struct, enum, type, interface,
+ * contract, data, runtime) are recognized at the start of each top-level statement
+ * and kept outside the wrapper. Everything else goes inside the wrapper function.
+ */
+function _wrapSourceTextForRun(text, funcName) {
+    const len = text.length;
+    const ranges = [];
+    let pos = 0;
+    while (pos < len) {
+        // skip whitespace
+        while (pos < len && _isWhitespace(text.charCodeAt(pos)))
+            pos++;
+        if (pos >= len)
+            break;
+        const stmtStart = pos;
+        // read the first word to determine if this is a declaration
+        const word = _readWord(text, pos);
+        const isDecl = _declKeywords.has(word);
+        // find the end of this statement:
+        // track brace/paren depth, respect strings and comments
+        let braceDepth = 0;
+        let parenDepth = 0;
+        let ended = false;
+        while (pos < len && !ended) {
+            const ch = text.charCodeAt(pos);
+            // single-line comment
+            if (ch === 0x2F /* / */ && pos + 1 < len && text.charCodeAt(pos + 1) === 0x2F /* / */) {
+                pos += 2;
+                while (pos < len && text.charCodeAt(pos) !== 0x0A /* \n */)
+                    pos++;
+                continue;
+            }
+            // multi-line comment
+            if (ch === 0x2F /* / */ && pos + 1 < len && text.charCodeAt(pos + 1) === 0x2A /* * */) {
+                pos += 2;
+                while (pos < len && !(text.charCodeAt(pos) === 0x2A && pos + 1 < len && text.charCodeAt(pos + 1) === 0x2F))
+                    pos++;
+                pos += 2; // skip */
+                continue;
+            }
+            // string literals
+            if (ch === 0x22 /* " */ || ch === 0x27 /* ' */ || ch === 0x60 /* ` */) {
+                pos++;
+                while (pos < len) {
+                    const sc = text.charCodeAt(pos);
+                    if (sc === 0x5C /* \ */) {
+                        pos += 2;
+                        continue;
+                    } // escaped char
+                    if (sc === ch) {
+                        pos++;
+                        break;
+                    }
+                    pos++;
+                }
+                continue;
+            }
+            if (ch === 0x28 /* ( */) {
+                parenDepth++;
+                pos++;
+            }
+            else if (ch === 0x29 /* ) */) {
+                parenDepth--;
+                pos++;
+            }
+            else if (ch === 0x7B /* { */) {
+                braceDepth++;
+                pos++;
+            }
+            else if (ch === 0x7D /* } */) {
+                braceDepth--;
+                pos++;
+                if (braceDepth <= 0 && parenDepth <= 0) {
+                    // consume optional trailing semicolon
+                    let p2 = pos;
+                    while (p2 < len && _isWhitespace(text.charCodeAt(p2)))
+                        p2++;
+                    if (p2 < len && text.charCodeAt(p2) === 0x3B /* ; */)
+                        pos = p2 + 1;
+                    ended = true;
+                }
+            }
+            else if (ch === 0x3B /* ; */ && braceDepth === 0 && parenDepth === 0) {
+                pos++;
+                ended = true;
+            }
+            else {
+                pos++;
+            }
+        }
+        const stmtEnd = pos;
+        // skip empty ranges
+        if (stmtEnd > stmtStart) {
+            ranges.push({ start: stmtStart, end: stmtEnd, isDecl });
+        }
+    }
+    // If there are no body ranges, nothing to wrap
+    if (ranges.every(r => r.isDecl)) {
+        return text;
+    }
+    // Build the new source text
+    const declarations = [];
+    const bodyParts = [];
+    for (const r of ranges) {
+        const slice = text.substring(r.start, r.end);
+        if (r.isDecl)
+            declarations.push(slice);
+        else
+            bodyParts.push(slice);
+    }
+    return (declarations.join("\n") +
+        (declarations.length > 0 ? "\n" : "") +
+        "function " + funcName + "(): void {\n" +
+        bodyParts.join("\n") + "\n" +
+        "}\n");
+}
+function _isWhitespace(ch) {
+    return ch === 0x20 || ch === 0x09 || ch === 0x0A || ch === 0x0D;
+}
+function _readWord(text, pos) {
+    const start = pos;
+    const len = text.length;
+    while (pos < len) {
+        const ch = text.charCodeAt(pos);
+        if ((ch >= 0x61 && ch <= 0x7A) || // a-z
+            (ch >= 0x41 && ch <= 0x5A) || // A-Z
+            (ch >= 0x30 && ch <= 0x39) || // 0-9
+            ch === 0x5F // _
+        )
+            pos++;
+        else
+            break;
+    }
+    return text.substring(start, pos);
+}

package/dist/compiler/AstCompiler/internal/_deriveContractBody/_deriveContractBody.js

@@ -40,6 +40,7 @@ import { ForStmt } from "../../../../ast/nodes/statements/ForStmt.js";
 import { IfStmt } from "../../../../ast/nodes/statements/IfStmt.js";
 import { MatchStmtCase, MatchStmt, MatchStmtElseCase } from "../../../../ast/nodes/statements/MatchStmt.js";
 import { ReturnStmt } from "../../../../ast/nodes/statements/ReturnStmt.js";
+import { TraceStmt } from "../../../../ast/nodes/statements/TraceStmt.js";
 import { UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
 import { VarStmt } from "../../../../ast/nodes/statements/VarStmt.js";
 import { WhileStmt } from "../../../../ast/nodes/statements/WhileStmt.js";
@@ -589,6 +590,13 @@ function _getMatchedRedeemerBlockStatements(compiler, stmts, paramsInternalNames
             stmt.body = new BlockStmt(nextBodyStmts, stmt.body.range);
             continue;
         }
+        if (stmt instanceof TraceStmt) {
+            const newExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.expr, paramsInternalNamesMap, renamedVariables);
+            if (!newExpr)
+                return undefined;
+            stmt.expr = newExpr;
+            continue;
+        }
         const tsEnsureExhaustiveCheck = stmt;
         console.error(stmt);
         throw new Error("unreachable::_getMatchedRedeemerBlockStatements::stmt::");

package/dist/compiler/AstCompiler/internal/statements/_compileStatement.js

@@ -6,6 +6,7 @@ import { ContinueStmt } from "../../../../ast/nodes/statements/ContinueStmt.js";
 import { isVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/VarDecl.js";
 import { EmptyStmt } from "../../../../ast/nodes/statements/EmptyStmt.js";
 import { FailStmt } from "../../../../ast/nodes/statements/FailStmt.js";
+import { TraceStmt } from "../../../../ast/nodes/statements/TraceStmt.js";
 import { ForOfStmt } from "../../../../ast/nodes/statements/ForOfStmt.js";
 import { ForStmt } from "../../../../ast/nodes/statements/ForStmt.js";
 import { IfStmt } from "../../../../ast/nodes/statements/IfStmt.js";
@@ -20,6 +21,7 @@ import { _compileBlockStmt } from "./_compileBlockStmt.js";
 import { _compileBreakStmt } from "./_compileBreakStmt.js";
 import { _compileContinueStmt } from "./_compileContinueStmt.js";
 import { _compileFailStmt } from "./_compileFailStmt.js";
+import { _compileTraceStmt } from "./_compileTraceStmt.js";
 import { _compileForOfStmt } from "./_compileForOfStmt.js";
 import { _compileForStmt } from "./_compileForStmt.js";
 import { _compileIfStmt } from "./_compileIfStmt.js";
@@ -62,6 +64,8 @@ export function _compileStatement(ctx, stmt) {
         return _compileFailStmt(ctx, stmt);
     if (stmt instanceof AssertStmt)
         return _compileAssertStmt(ctx, stmt);
+    if (stmt instanceof TraceStmt)
+        return _compileTraceStmt(ctx, stmt);
     // if( stmt instanceof TestStmt ) return _compileTestStmt( ctx, stmt );
     if (stmt instanceof MatchStmt)
         return _compileMatchStmt(ctx, stmt);

package/dist/compiler/AstCompiler/internal/statements/_compileTraceStmt.d.ts

@@ -0,0 +1,4 @@
+import { TraceStmt } from "../../../../ast/nodes/statements/TraceStmt.js";
+import { TirTraceStmt } from "../../../tir/statements/TirTraceStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileTraceStmt(ctx: AstCompilationCtx, stmt: TraceStmt): [TirTraceStmt] | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileTraceStmt.js

@@ -0,0 +1,15 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirTraceStmt } from "../../../tir/statements/TirTraceStmt.js";
+import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "../exprs/_compileExpr.js";
+export function _compileTraceStmt(ctx, stmt) {
+    const bytes_t = ctx.program.stdTypes.bytes;
+    const int_t = ctx.program.stdTypes.int;
+    let expr = _compileExpr(ctx, stmt.expr, undefined);
+    if (!expr)
+        return undefined;
+    if (!canAssignTo(expr.type, bytes_t) &&
+        !canAssignTo(expr.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.expr.range, expr.type.toString(), "bytes | int");
+    return [new TirTraceStmt(expr, stmt.range)];
+}

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,6 +61,29 @@ 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);

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/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;
+}