@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

package/dist/compiler/tir/expressions/binary/TirBinaryExpr.d.ts

@@ -16,6 +16,8 @@ export declare class TirExponentiationExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -27,6 +29,8 @@ export declare class TirLessThanExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -38,6 +42,8 @@ export declare class TirGreaterThanExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -49,6 +55,8 @@ export declare class TirLessThanEqualExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -60,6 +68,8 @@ export declare class TirGreaterThanEqualExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -71,6 +81,8 @@ export declare class TirEqualExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -82,6 +94,8 @@ export declare class TirNotEqualExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -91,8 +105,11 @@ export declare class TirAddExpr implements ITirBinaryExpr {
     left: TirExpr;
     right: TirExpr;
     readonly range: SourceRange;
+    private _creationStack;
     get type(): TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -104,6 +121,8 @@ export declare class TirSubExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -115,6 +134,8 @@ export declare class TirMultExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -126,6 +147,8 @@ export declare class TirDivExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -137,6 +160,8 @@ export declare class TirModuloExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -148,6 +173,8 @@ export declare class TirShiftLeftExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -159,6 +186,8 @@ export declare class TirShiftRightExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -170,6 +199,8 @@ export declare class TirBitwiseAndExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -181,6 +212,8 @@ export declare class TirBitwiseXorExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -192,6 +225,8 @@ export declare class TirBitwiseOrExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -203,19 +238,25 @@ export declare class TirLogicalAndExpr implements ITirBinaryExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
     deps(): string[];
 }
+export declare function _ir_and(left: IRTerm, right: IRTerm): IRTerm;
 export declare class TirLogicalOrExpr implements ITirBinaryExpr {
     left: TirExpr;
     right: TirExpr;
     readonly range: SourceRange;
     readonly type: TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
     deps(): string[];
 }
+export declare function _ir_or(left: IRTerm, right: IRTerm): IRTerm;

package/dist/compiler/tir/expressions/binary/TirBinaryExpr.js

@@ -1,7 +1,6 @@
 import { isObject } from "@harmoniclabs/obj-utils";
 import { bool_t, bytes_t, int_t } from "../../program/stdScope/stdScope.js";
 import { mergeSortedStrArrInplace } from "../../../../utils/array/mergeSortedStrArrInplace.js";
-import { _ir_apps } from "../../../../IR/tree_utils/_ir_apps.js";
 import { getUnaliased } from "../../types/utils/getUnaliased.js";
 import { CEKConst, Machine } from "@harmoniclabs/plutus-machine";
 import { TirBytesT } from "../../types/TirNativeType/native/bytes.js";
@@ -9,6 +8,8 @@ import { TirIntT } from "../../types/TirNativeType/native/int.js";
 import { IRNative } from "../../../../IR/IRNodes/IRNative/index.js";
 import { IRConst } from "../../../../IR/IRNodes/IRConst.js";
 import { compileIRToUPLC } from "../../../../IR/toUPLC/compileIRToUPLC.js";
+import { _ir_apps } from "../../../../IR/IRNodes/IRApp.js";
+import { _ir_lazyIfThenElse } from "../../../../IR/tree_utils/_ir_lazyIfThenElse.js";
 export function isTirBinaryExpr(thing) {
     return isObject(thing) && (thing instanceof TirExponentiationExpr // int
         || thing instanceof TirLessThanExpr // bool
@@ -41,6 +42,14 @@ export class TirExponentiationExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} ** ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} ** ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirExponentiationExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -64,6 +73,14 @@ export class TirLessThanExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} < ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} < ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirLessThanExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -93,6 +110,14 @@ export class TirGreaterThanExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} > ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} > ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirGreaterThanExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -124,6 +149,14 @@ export class TirLessThanEqualExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} <= ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} <= ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirLessThanEqualExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -153,6 +186,14 @@ export class TirGreaterThanEqualExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} >= ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} >= ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirGreaterThanEqualExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -184,6 +225,14 @@ export class TirEqualExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} === ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} === ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirEqualExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -207,6 +256,14 @@ export class TirNotEqualExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} !== ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} !== ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirNotEqualExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -220,15 +277,17 @@ export class TirNotEqualExpr {
         return deps;
     }
 }
+let n_logs = 0;
 export class TirAddExpr {
     left;
     right;
     range;
+    _creationStack;
     get type() {
         const leftType = getUnaliased(this.left.type);
         if (leftType instanceof TirIntT
             || leftType instanceof TirBytesT)
-            return this.type;
+            return leftType;
         throw new Error("invalid type for addition");
     }
     constructor(left, right, range) {
@@ -236,6 +295,17 @@ export class TirAddExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} + ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        n_logs++;
+        if (!(n_logs % 100))
+            console.log(this);
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} + ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirAddExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -265,6 +335,14 @@ export class TirSubExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} - ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} - ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirSubExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -288,6 +366,14 @@ export class TirMultExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} * ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} * ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirMultExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -311,6 +397,14 @@ export class TirDivExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} / ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} / ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirDivExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -334,6 +428,14 @@ export class TirModuloExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} % ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} % ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirModuloExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -357,6 +459,14 @@ export class TirShiftLeftExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} << ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} << ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirShiftLeftExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -382,6 +492,14 @@ export class TirShiftRightExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} >> ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} >> ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirShiftRightExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -425,6 +543,14 @@ export class TirBitwiseAndExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} & ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} & ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirBitwiseAndExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -448,6 +574,14 @@ export class TirBitwiseXorExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} ^ ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} ^ ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirBitwiseXorExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -471,6 +605,14 @@ export class TirBitwiseOrExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} | ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} | ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirBitwiseOrExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
@@ -494,12 +636,20 @@ export class TirLogicalAndExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} && ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} && ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirLogicalAndExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
-        return _ir_apps(IRNative._and, this.left.toIR(ctx), this.right.toIR(ctx));
+        return _ir_and(this.left.toIR(ctx), this.right.toIR(ctx));
     }
     deps() {
         const deps = this.left.deps();
@@ -507,6 +657,15 @@ export class TirLogicalAndExpr {
         return deps;
     }
 }
+export function _ir_and(left, right) {
+    return _ir_lazyIfThenElse(
+    // condition
+    left, 
+    // then
+    right, 
+    // else
+    IRConst.bool(false));
+}
 export class TirLogicalOrExpr {
     left;
     right;
@@ -517,12 +676,20 @@ export class TirLogicalOrExpr {
         this.right = right;
         this.range = range;
     }
+    toString() {
+        return `(${this.left.toString()} || ${this.right.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(${this.left.pretty(indent)} || ${this.right.pretty(indent)})`;
+    }
     clone() {
         return new TirLogicalOrExpr(this.left.clone(), this.right.clone(), this.range.clone());
     }
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
-        return _ir_apps(IRNative._or, this.left.toIR(ctx), this.right.toIR(ctx));
+        return _ir_or(this.left.toIR(ctx), this.right.toIR(ctx));
     }
     deps() {
         const deps = this.left.deps();
@@ -530,3 +697,12 @@ export class TirLogicalOrExpr {
         return deps;
     }
 }
+export function _ir_or(left, right) {
+    return _ir_lazyIfThenElse(
+    // condition
+    left, 
+    // then
+    IRConst.bool(true), 
+    // else
+    right);
+}

package/dist/compiler/tir/expressions/litteral/TirLitArrExpr.d.ts

@@ -1,16 +1,18 @@
 import { SourceRange } from "../../../../ast/Source/SourceRange.js";
-import { IRTerm } from "../../../../IR/index.js";
 import { TirType } from "../../types/TirType.js";
 import { ITirExpr } from "../ITirExpr.js";
 import { TirExpr } from "../TirExpr.js";
 import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import type { IRTerm } from "../../../../IR/IRTerm.js";
 export declare class TirLitArrExpr implements ITirExpr {
     readonly elems: TirExpr[];
     readonly type: TirType;
     readonly range: SourceRange;
     get isConstant(): boolean;
     constructor(elems: TirExpr[], type: TirType, range: SourceRange);
-    clone(): TirLitArrExpr;
+    pretty(): string;
+    toString(): string;
+    clone(): TirExpr;
     deps(): string[];
     toIR(ctx: ToIRTermCtx): IRTerm;
 }

package/dist/compiler/tir/expressions/litteral/TirLitArrExpr.js

@@ -1,9 +1,11 @@
 import { Machine, CEKConst } from "@harmoniclabs/plutus-machine";
-import { compileIRToUPLC, IRConst, IRNative } from "../../../../IR/index.js";
 import { mergeSortedStrArrInplace } from "../../../../utils/array/mergeSortedStrArrInplace.js";
 import { getListTypeArg } from "../../types/utils/getListTypeArg.js";
 import { getUnaliased } from "../../types/utils/getUnaliased.js";
-import { _ir_apps } from "../../../../IR/tree_utils/_ir_apps.js";
+import { _ir_apps } from "../../../../IR/IRNodes/IRApp.js";
+import { IRNative } from "../../../../IR/IRNodes/IRNative/index.js";
+import { IRConst } from "../../../../IR/IRNodes/IRConst.js";
+import { compileIRToUPLC } from "../../../../IR/toUPLC/compileIRToUPLC.js";
 export class TirLitArrExpr {
     elems;
     type;
@@ -16,6 +18,10 @@ export class TirLitArrExpr {
         this.type = type;
         this.range = range;
     }
+    pretty() { return this.toString(); }
+    toString() {
+        return `[ ${this.elems.map(e => e.toString()).join(", ")} ]`;
+    }
     clone() {
         return new TirLitArrExpr(this.elems.map(e => e.clone()), this.type.clone(), this.range.clone());
     }

package/dist/compiler/tir/expressions/litteral/TirLitFailExpr.d.ts

@@ -0,0 +1,17 @@
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { IRTerm } from "../../../../IR/index.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 TirLitFailExpr implements ITirExpr {
+    readonly range: SourceRange;
+    readonly type: TirType;
+    readonly isConstant: boolean;
+    constructor(range: SourceRange);
+    pretty(): string;
+    toString(): string;
+    clone(): TirExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/litteral/TirLitFailExpr.js

@@ -0,0 +1,21 @@
+import { IRError } from "../../../../IR/index.js";
+import { void_t } from "../../program/stdScope/stdScope.js";
+export class TirLitFailExpr {
+    range;
+    type = void_t;
+    isConstant = true;
+    constructor(range) {
+        this.range = range;
+    }
+    pretty() { return this.toString(); }
+    toString() {
+        return "fail";
+    }
+    clone() {
+        return new TirLitFailExpr(this.range.clone());
+    }
+    deps() { return []; }
+    toIR(ctx) {
+        return new IRError();
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitFalseExpr.d.ts

@@ -3,12 +3,15 @@ import { SourceRange } from "../../../../ast/Source/SourceRange.js";
 import { TirType } from "../../types/TirType.js";
 import { IRTerm } from "../../../../IR/index.js";
 import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import { TirExpr } from "../TirExpr.js";
 export declare class TirLitFalseExpr implements ITirExpr {
     readonly range: SourceRange;
     readonly type: TirType;
     readonly isConstant: boolean;
     constructor(range: SourceRange);
-    clone(): TirLitFalseExpr;
+    pretty(): string;
+    toString(): string;
+    clone(): TirExpr;
     deps(): string[];
     toIR(ctx: ToIRTermCtx): IRTerm;
 }

package/dist/compiler/tir/expressions/litteral/TirLitFalseExpr.js

@@ -7,6 +7,10 @@ export class TirLitFalseExpr {
     constructor(range) {
         this.range = range;
     }
+    pretty() { return this.toString(); }
+    toString() {
+        return "false";
+    }
     clone() {
         return new TirLitFalseExpr(this.range.clone());
     }

package/dist/compiler/tir/expressions/litteral/TirLitHexBytesExpr.d.ts

@@ -3,13 +3,16 @@ import { SourceRange } from "../../../../ast/Source/SourceRange.js";
 import { TirType } from "../../types/TirType.js";
 import { IRTerm } from "../../../../IR/index.js";
 import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import { TirExpr } from "../TirExpr.js";
 export declare class TirLitHexBytesExpr implements ITirExpr {
     readonly bytes: Uint8Array;
     readonly range: SourceRange;
     readonly type: TirType;
     readonly isConstant: boolean;
     constructor(bytes: Uint8Array, range: SourceRange);
-    clone(): TirLitHexBytesExpr;
+    pretty(): string;
+    toString(): string;
+    clone(): TirExpr;
     deps(): string[];
     toIR(ctx: ToIRTermCtx): IRTerm;
 }

package/dist/compiler/tir/expressions/litteral/TirLitHexBytesExpr.js

@@ -1,5 +1,6 @@
 import { bytes_t } from "../../program/stdScope/stdScope.js";
 import { IRConst } from "../../../../IR/index.js";
+import { toHex } from "@harmoniclabs/uint8array-utils";
 export class TirLitHexBytesExpr {
     bytes;
     range;
@@ -9,6 +10,10 @@ export class TirLitHexBytesExpr {
         this.bytes = bytes;
         this.range = range;
     }
+    pretty() { return this.toString(); }
+    toString() {
+        return `#${toHex(this.bytes)}`;
+    }
     clone() {
         return new TirLitHexBytesExpr(new Uint8Array(this.bytes), this.range.clone());
     }