@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

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

@@ -0,0 +1,28 @@
+import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+export class TirCallExpr {
+    func;
+    args;
+    type;
+    range;
+    constructor(func, args, type, range) {
+        this.func = func;
+        this.args = args;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirCallExpr(this.func.clone(), this.args.map(a => a.clone()), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        const deps = this.func.deps();
+        for (const arg of this.args) {
+            mergeSortedStrArrInplace(deps, arg.deps());
+        }
+        return deps;
+    }
+    get isConstant() { return false; }
+    toIR(ctx) {
+        return _ir_apps(this.func.toIR(ctx), ...this.args.map(arg => arg.toIR(ctx)));
+    }
+}

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

@@ -0,0 +1,36 @@
+import { HasSourceRange } from "../../../ast/nodes/HasSourceRange.js";
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirNamedDeconstructVarDecl } from "../statements/TirVarDecl/TirNamedDeconstructVarDecl.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 TirCaseExpr implements ITirExpr {
+    matchExpr: TirExpr;
+    readonly cases: TirCaseMatcher[];
+    readonly wildcardCase: TirWildcardCaseMatcher | undefined;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(matchExpr: TirExpr, cases: TirCaseMatcher[], wildcardCase: TirWildcardCaseMatcher | undefined, type: TirType, range: SourceRange);
+    clone(): TirCaseExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+    private _sopStructToIR;
+    private _dataStructToIR;
+}
+export type TirCasePattern = TirNamedDeconstructVarDecl;
+export declare class TirCaseMatcher implements HasSourceRange {
+    readonly pattern: TirCasePattern;
+    body: TirExpr;
+    readonly range: SourceRange;
+    constructor(pattern: TirCasePattern, body: TirExpr, range: SourceRange);
+    deps(): string[];
+}
+export declare class TirWildcardCaseMatcher implements HasSourceRange {
+    body: TirExpr;
+    readonly range: SourceRange;
+    constructor(body: TirExpr, range: SourceRange);
+    deps(): string[];
+}

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

@@ -0,0 +1,257 @@
+import { IRCase } from "../../../IR/IRNodes/IRCase.js";
+import { IRConst } from "../../../IR/IRNodes/IRConst.js";
+import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
+import { IRError } from "../../../IR/IRNodes/IRError.js";
+import { IRForced } from "../../../IR/IRNodes/IRForced.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { IRVar } from "../../../IR/IRNodes/IRVar.js";
+import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+import { _ir_let } from "../../../IR/tree_utils/_ir_let.js";
+import { filterSortedStrArrInplace } from "../../../utils/array/filterSortedStrArrInplace.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+import { TirSimpleVarDecl } from "../statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
+import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
+import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
+import { getOptTypeArg } from "../types/utils/getOptTypeArg.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+import { _inlineFromData } from "./TirFromDataExpr.js";
+export class TirCaseExpr {
+    matchExpr;
+    cases;
+    wildcardCase;
+    type;
+    range;
+    constructor(matchExpr, cases, wildcardCase, type, range) {
+        this.matchExpr = matchExpr;
+        this.cases = cases;
+        this.wildcardCase = wildcardCase;
+        this.type = type;
+        this.range = range;
+    }
+    /// @ts-ignore Return type annotation circularly references itself.
+    clone() {
+        return new TirCaseExpr(this.matchExpr.clone(), this.cases.map(c => new TirCaseMatcher(c.pattern, c.body.clone(), c.range.clone())), this.wildcardCase ? new TirWildcardCaseMatcher(this.wildcardCase.body.clone(), this.wildcardCase.range.clone()) : undefined, this.type.clone(), this.range.clone());
+    }
+    deps() {
+        const deps = this.matchExpr.deps();
+        for (const matcher of this.cases) {
+            mergeSortedStrArrInplace(deps, matcher.deps());
+        }
+        if (this.wildcardCase)
+            mergeSortedStrArrInplace(deps, this.wildcardCase.deps());
+        return deps;
+    }
+    get isConstant() { return false; }
+    toIR(ctx) {
+        const matchExprType = getUnaliased(this.matchExpr.type);
+        if (matchExprType instanceof TirSoPStructType
+            || matchExprType instanceof TirSopOptT)
+            return this._sopStructToIR(matchExprType, ctx);
+        if (matchExprType instanceof TirDataStructType
+            || matchExprType instanceof TirDataOptT)
+            return this._dataStructToIR(matchExprType, ctx);
+        throw new Error("`case` expressions are only supported on Sum-of-Products or Data Struct types; got: "
+            + this.matchExpr.type.toString());
+    }
+    _sopStructToIR(matchExprType, ctx) {
+        if (matchExprType instanceof TirSopOptT) {
+            const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
+            const someBranchCtx = ctx.newChild();
+            const someBranch = this.cases.find(c => c.pattern.constrName === "Some");
+            if (someBranch) {
+                const varDecl = someBranch.pattern.fields.values().next().value;
+                if (!(varDecl instanceof TirSimpleVarDecl))
+                    throw new Error("case pattern not expressified.");
+                someBranchCtx.defineVar(varDecl.name);
+            }
+            const someBranchIR = someBranch?.body.toIR(someBranchCtx) ?? wildcardBodyIR;
+            const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(ctx) ?? wildcardBodyIR;
+            return new IRCase(this.matchExpr.toIR(ctx), [
+                // Some{ value }
+                new IRFunc(1, someBranchIR),
+                // None
+                noneBranchIR
+            ]);
+        }
+        // TirSopStructType
+        const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
+        const branches = matchExprType.constructors.map(ctor => {
+            const wrapBody = ctor.fields.length === 0
+                ? (body) => body
+                : (body) => new IRFunc(ctor.fields.length, body);
+            const branchCtx = ctx.newChild();
+            const branch = this.cases.find(c => c.pattern.constrName === ctor.name);
+            if (!branch)
+                return wrapBody(wildcardBodyIR);
+            const pattern = branch.pattern;
+            for (const field of ctor.fields) {
+                const varDecl = pattern.fields.get(field.name);
+                if (!varDecl) {
+                    // increment debrujin
+                    // variable is still introduced, even if unused
+                    branchCtx.pushUnusedVar();
+                    continue;
+                }
+                if (!(varDecl instanceof TirSimpleVarDecl))
+                    throw new Error("case pattern not expressified.");
+                branchCtx.defineVar(varDecl.name);
+            }
+            return wrapBody(branch.body.toIR(branchCtx));
+        });
+        // branches at the end that are supposed to "just fail"
+        // can be omitted, as the CEK machine will fail if no branch for
+        // a given constructor is found
+        while (branches[branches.length - 1] instanceof IRError)
+            branches.pop();
+        return branches.length > 0 ? new IRCase(this.matchExpr.toIR(ctx), branches) : new IRError(); // all branches fail, so the whole expression fails
+    }
+    // TODO: optimization
+    // expect data-encoded patterns to be empty after `expressify`
+    // because accessed field should use `IRLetted` instead
+    _dataStructToIR(matchExprType, ctx) {
+        if (matchExprType instanceof TirDataOptT) {
+            const stmtCtx = ctx.newChild();
+            stmtCtx.pushUnusedVar(); // debrujin un constr data result
+            const wildcardBodyIR = this.wildcardCase?.body.toIR(stmtCtx) ?? new IRError();
+            const someBranchCtx = stmtCtx.newChild();
+            const someBranch = this.cases.find(c => c.pattern.constrName === "Some");
+            if (someBranch) {
+                const varDecl = someBranch.pattern.fields.values().next().value;
+                if (varDecl === undefined) {
+                    // increment debrujin
+                    // variable is still introduced, even if unused
+                    someBranchCtx.pushUnusedVar();
+                }
+                else {
+                    if (!(varDecl instanceof TirSimpleVarDecl))
+                        throw new Error("case pattern not expressified.");
+                    someBranchCtx.defineVar(varDecl.name);
+                }
+            }
+            const someBranchIR = someBranch?.body.toIR(someBranchCtx); // ?? wildcardBodyIR;
+            const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(stmtCtx) ?? wildcardBodyIR;
+            if (someBranchIR instanceof IRError && noneBranchIR instanceof IRError)
+                return new IRError();
+            return new IRForced(_ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), _ir_apps(IRNative.strictIfThenElse, _ir_apps(IRNative.equalsInteger, IRConst.int(0), _ir_apps(IRNative.fstPair, new IRVar(0) // unConstrData result
+            )), 
+            // then Just{ value }
+            !someBranchIR ? new IRDelayed(wildcardBodyIR) :
+                _ir_let(_inlineFromData(getOptTypeArg(matchExprType), _ir_apps(IRNative.sndPair, new IRVar(0) // unConstrData result
+                )), new IRDelayed(someBranchIR)), 
+            // else None
+            new IRDelayed(noneBranchIR))));
+        }
+        // TirDataStructType
+        const stmtCtx = ctx.newChild();
+        stmtCtx.pushUnusedVar(); // unconstrStruct
+        stmtCtx.pushUnusedVar(); // isConstrIdx
+        const noVarsWildcardBodyIR = (this.wildcardCase?.body.toIR(stmtCtx)
+            ?? new IRError());
+        const delayedNoVarWildcardBodyIR = new IRDelayed(noVarsWildcardBodyIR);
+        let ifThenElseMatchingStatements = noVarsWildcardBodyIR;
+        if (this.cases.some(({ pattern }) => matchExprType.constructors.findIndex(ctor => ctor.name === pattern.constrName) < 0))
+            throw new Error("case expression includes unknown constructor.");
+        const cases = this.cases.sort((a, b) => {
+            const a_idx = matchExprType.constructors.findIndex(ctor => ctor.name === a.pattern.constrName);
+            const b_idx = matchExprType.constructors.findIndex(ctor => ctor.name === b.pattern.constrName);
+            return a_idx - b_idx;
+        });
+        for (let i = cases.length - 1; i >= 0; i--) {
+            const { pattern, body } = cases[i];
+            const ctorIdx = matchExprType.constructors.findIndex(ctor => ctor.name === pattern.constrName);
+            if (ctorIdx < 0)
+                throw new Error("case expression includes unknown constructor."); // unreachable
+            const ctor = matchExprType.constructors[ctorIdx];
+            const usedFieldsCtorNames = (ctor.fields.map(f => f.name)
+                .filter(fName => pattern.fields.has(fName)));
+            if (usedFieldsCtorNames.length <= 0) {
+                ifThenElseMatchingStatements = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRVar(0), // isConstrIdx
+                IRConst.int(ctorIdx)), 
+                // then
+                new IRDelayed(body.toIR(stmtCtx)), 
+                // else
+                new IRDelayed(ifThenElseMatchingStatements));
+                continue;
+            }
+            function indexOfField(fieldName) {
+                const idx = ctor.fields.findIndex(f => f.name === fieldName);
+                if (idx < 0)
+                    throw new Error("case pattern not expressified.");
+                return idx;
+            }
+            if (usedFieldsCtorNames.length === 1) {
+                const thenCtx = stmtCtx.newChild();
+                const fName = usedFieldsCtorNames[0];
+                const patternVarDecl = pattern.fields.get(fName);
+                if (!(patternVarDecl instanceof TirSimpleVarDecl))
+                    throw new Error("case pattern not expressified.");
+                thenCtx.defineVar(patternVarDecl.name);
+                const thenCase = _ir_let(_inlineFromData(patternVarDecl.type, _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(indexOfField(fName)), // constr field index
+                _ir_apps(// fileds as data list
+                IRNative.sndPair, new IRVar(1) // uncostrStruct
+                )))), body.toIR(thenCtx));
+                ifThenElseMatchingStatements = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRVar(0), // isConstrIdx
+                IRConst.int(ctorIdx)), 
+                // then
+                new IRDelayed(thenCase), 
+                // else
+                new IRDelayed(ifThenElseMatchingStatements));
+                continue;
+            }
+            // multiple fields used
+            const thenCtx = stmtCtx.newChild();
+            const sortedUsedFields = [...usedFieldsCtorNames].sort((a, b) => indexOfField(a) - indexOfField(b));
+            for (const fName of sortedUsedFields) {
+                const patternVarDecl = pattern.fields.get(fName);
+                if (!(patternVarDecl instanceof TirSimpleVarDecl))
+                    throw new Error("case pattern not expressified.");
+                thenCtx.defineVar(patternVarDecl.name);
+            }
+            const extractedFields = sortedUsedFields.map(fName => _inlineFromData(ctor.fields.find(f => f.name === fName).type, _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(indexOfField(fName)), // constr field index
+            new IRVar(0) // fileds as data list
+            ))));
+            const thenCase = _ir_let(_ir_apps(IRNative.sndPair, new IRVar(1) // uncostrStruct
+            ), // fileds as data list
+            _ir_apps(new IRFunc(sortedUsedFields.length, body.toIR(thenCtx)), ...extractedFields));
+            ifThenElseMatchingStatements = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRVar(0), // isConstrIdx
+            IRConst.int(ctorIdx)), 
+            // then
+            new IRDelayed(thenCase), 
+            // else
+            new IRDelayed(ifThenElseMatchingStatements));
+        }
+        return new IRForced(_ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), // uncostrStruct
+        _ir_let(_ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(0) // unConstrData result
+        )), // isConstrIdx
+        ifThenElseMatchingStatements)));
+    }
+}
+export class TirCaseMatcher {
+    pattern;
+    body;
+    range;
+    constructor(pattern, body, range) {
+        this.pattern = pattern;
+        this.body = body;
+        this.range = range;
+    }
+    deps() {
+        const nonDeps = this.pattern.introducedVars();
+        const deps = this.body.deps();
+        filterSortedStrArrInplace(deps, nonDeps);
+        return deps;
+    }
+}
+export class TirWildcardCaseMatcher {
+    body;
+    range;
+    constructor(body, range) {
+        this.body = body;
+        this.range = range;
+    }
+    deps() {
+        return this.body.deps();
+    }
+}

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

@@ -0,0 +1,20 @@
+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";
+/**
+ * `arrLikeExpr[ indexExpr ]`
+ */
+export declare class TirElemAccessExpr implements ITirExpr {
+    arrLikeExpr: TirExpr;
+    indexExpr: TirExpr;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(arrLikeExpr: TirExpr, indexExpr: TirExpr, type: TirType, range: SourceRange);
+    clone(): TirElemAccessExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

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

@@ -0,0 +1,43 @@
+import { CEKConst, Machine } from "@harmoniclabs/plutus-machine";
+import { IRConst } from "../../../IR/IRNodes/IRConst.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+import { compileIRToUPLC } from "../../../IR/toUPLC/compileIRToUPLC.js";
+/**
+ * `arrLikeExpr[ indexExpr ]`
+ */
+export class TirElemAccessExpr {
+    arrLikeExpr;
+    indexExpr;
+    type;
+    range;
+    constructor(arrLikeExpr, indexExpr, type, range) {
+        this.arrLikeExpr = arrLikeExpr;
+        this.indexExpr = indexExpr;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirElemAccessExpr(this.arrLikeExpr.clone(), this.indexExpr.clone(), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        const deps = this.arrLikeExpr.deps();
+        mergeSortedStrArrInplace(deps, this.indexExpr.deps());
+        return deps;
+    }
+    get isConstant() {
+        return this.arrLikeExpr.isConstant && this.indexExpr.isConstant;
+    }
+    toIR(ctx) {
+        let irArr = this.arrLikeExpr.toIR(ctx);
+        let irIndex = this.indexExpr.toIR(ctx);
+        if (this.indexExpr.isConstant) {
+            const result = Machine.evalSimple(compileIRToUPLC(irIndex));
+            if ((result instanceof CEKConst)
+                && (typeof result.value === "number" || typeof result.value === "bigint"))
+                return _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(result.value), irArr));
+        }
+        return _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, irIndex, irArr));
+    }
+}

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

@@ -0,0 +1,23 @@
+import { TirLitteralExpr } from "./litteral/TirLitteralExpr.js";
+import { TirCallExpr } from "./TirCallExpr.js";
+import { TirCaseExpr } from "./TirCaseExpr.js";
+import { TirElemAccessExpr } from "./TirElemAccessExpr.js";
+import { TirFuncExpr } from "./TirFuncExpr.js";
+import { TirParentesizedExpr } from "./TirParentesizedExpr.js";
+import { TirPropAccessExpr } from "./TirPropAccessExpr.js";
+import { TirTernaryExpr } from "./TirTernaryExpr.js";
+import { TirUnaryPrefixExpr } from "./unary/TirUnaryPrefixExpr.js";
+import { TirBinaryExpr } from "./binary/TirBinaryExpr.js";
+import { TirVariableAccessExpr } from "./TirVariableAccessExpr.js";
+import { TirTypeConversionExpr } from "./TirTypeConversionExpr.js";
+import { TirLettedExpr } from "./TirLettedExpr.js";
+import { TirFromDataExpr } from "./TirFromDataExpr.js";
+import { TirFailExpr } from "./TirFailExpr.js";
+import { TirHoistedExpr } from "./TirHoistedExpr.js";
+import { TirToDataExpr } from "./TirToDataExpr.js";
+import { TirAssertAndContinueExpr } from "./TirAssertAndContinueExpr.js";
+import { TirTraceIfFalseExpr } from "./TirTraceIfFalseExpr.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 declare function isTirExpr(thing: any): thing is TirExpr;

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

@@ -0,0 +1,46 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { isTirLitteralExpr } from "./litteral/TirLitteralExpr.js";
+import { TirCallExpr } from "./TirCallExpr.js";
+import { TirCaseExpr } from "./TirCaseExpr.js";
+import { TirElemAccessExpr } from "./TirElemAccessExpr.js";
+import { TirFuncExpr } from "./TirFuncExpr.js";
+import { TirParentesizedExpr } from "./TirParentesizedExpr.js";
+import { TirPropAccessExpr } from "./TirPropAccessExpr.js";
+import { TirTernaryExpr } from "./TirTernaryExpr.js";
+import { isTirUnaryPrefixExpr } from "./unary/TirUnaryPrefixExpr.js";
+import { isTirBinaryExpr } from "./binary/TirBinaryExpr.js";
+import { TirVariableAccessExpr } from "./TirVariableAccessExpr.js";
+import { TirTypeConversionExpr } from "./TirTypeConversionExpr.js";
+import { TirLettedExpr } from "./TirLettedExpr.js";
+import { TirFromDataExpr } from "./TirFromDataExpr.js";
+import { TirFailExpr } from "./TirFailExpr.js";
+import { TirHoistedExpr } from "./TirHoistedExpr.js";
+import { TirToDataExpr } from "./TirToDataExpr.js";
+import { TirAssertAndContinueExpr } from "./TirAssertAndContinueExpr.js";
+import { TirTraceIfFalseExpr } from "./TirTraceIfFalseExpr.js";
+import { TirNativeFunc } from "./TirNativeFunc.js";
+import { TirInlineClosedIR } from "./TirInlineClosedIR.js";
+export function isTirExpr(thing) {
+    return isObject(thing) && (isTirUnaryPrefixExpr(thing)
+        || isTirLitteralExpr(thing)
+        || thing instanceof TirParentesizedExpr
+        || thing instanceof TirFuncExpr
+        || thing instanceof TirCallExpr
+        || thing instanceof TirCaseExpr
+        || thing instanceof TirTypeConversionExpr
+        // || thing instanceof TirIsExpr
+        || thing instanceof TirElemAccessExpr
+        || thing instanceof TirTernaryExpr
+        || thing instanceof TirPropAccessExpr
+        || isTirBinaryExpr(thing)
+        || thing instanceof TirVariableAccessExpr
+        || thing instanceof TirLettedExpr
+        || thing instanceof TirNativeFunc
+        || thing instanceof TirFailExpr
+        || thing instanceof TirHoistedExpr
+        || thing instanceof TirFromDataExpr
+        || thing instanceof TirToDataExpr
+        || thing instanceof TirAssertAndContinueExpr
+        || thing instanceof TirTraceIfFalseExpr
+        || thing instanceof TirInlineClosedIR);
+}

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

@@ -0,0 +1,19 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirExpr } from "../expressions/TirExpr.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirFailExpr implements ITirExpr {
+    /** must be string (or utf8 bytes) */
+    failMsgExpr: TirExpr | undefined;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(
+    /** must be string (or utf8 bytes) */
+    failMsgExpr: TirExpr | undefined, type: TirType, range: SourceRange);
+    clone(): TirFailExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

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

@@ -0,0 +1,28 @@
+import { IRError } from "../../../IR/IRNodes/IRError.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+export class TirFailExpr {
+    failMsgExpr;
+    type;
+    range;
+    constructor(
+    /** must be string (or utf8 bytes) */
+    failMsgExpr, type, range) {
+        this.failMsgExpr = failMsgExpr;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirFailExpr(this.failMsgExpr?.clone(), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        return this.failMsgExpr?.deps() ?? [];
+    }
+    get isConstant() { return true; }
+    toIR(ctx) {
+        const err = new IRError();
+        if (!this.failMsgExpr)
+            return err;
+        return _ir_apps(IRNative.trace, this.failMsgExpr.toIR(ctx), err);
+    }
+}

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

@@ -0,0 +1,22 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirSoPStructType } from "../types/TirStructType.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 TirFromDataExpr implements ITirExpr {
+    dataExpr: TirExpr;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(dataExpr: TirExpr, type: TirType, range: SourceRange);
+    clone(): TirFromDataExpr;
+    get isConstant(): boolean;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+    toString(): string;
+}
+export declare function _inlineFromData(target_t: TirType, dataExprIR: IRTerm): IRTerm;
+export declare function _fromDataUplcFunc(_target_t: TirType): IRTerm;
+export declare function _inilneSingeSopConstrFromData(sop_t: TirSoPStructType, dataExprIR: IRTerm): IRTerm;
+export declare function _inlineMultiSopConstrFromData(sop_t: TirSoPStructType, dataExprIR: IRTerm): IRTerm;