@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

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

@@ -1,28 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,257 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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;