@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

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

@@ -1,532 +0,0 @@
-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";
-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";
-export function isTirBinaryExpr(thing) {
-    return isObject(thing) && (thing instanceof TirExponentiationExpr // int
-        || thing instanceof TirLessThanExpr // bool
-        || thing instanceof TirGreaterThanExpr // bool
-        || thing instanceof TirLessThanEqualExpr // bool
-        || thing instanceof TirGreaterThanEqualExpr // bool
-        || thing instanceof TirEqualExpr // bool
-        || thing instanceof TirNotEqualExpr // bool
-        || thing instanceof TirAddExpr // int
-        || thing instanceof TirSubExpr // int
-        || thing instanceof TirMultExpr // int
-        || thing instanceof TirDivExpr // int
-        || thing instanceof TirModuloExpr // int
-        || thing instanceof TirShiftLeftExpr // bytes
-        || thing instanceof TirShiftRightExpr // bytes
-        || thing instanceof TirBitwiseAndExpr // bytes
-        || thing instanceof TirBitwiseXorExpr // bytes
-        || thing instanceof TirBitwiseOrExpr // bytes
-        || thing instanceof TirLogicalAndExpr // bool
-        || thing instanceof TirLogicalOrExpr // bool
-    );
-}
-export class TirExponentiationExpr {
-    left;
-    right;
-    range;
-    type = int_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirExponentiationExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative._exponentiateInteger, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirLessThanExpr {
-    left;
-    right;
-    range;
-    type = bool_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirLessThanExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.lessThanInteger :
-            type instanceof TirBytesT ? IRNative.lessThanByteString :
-                undefined);
-        if (!irFunc)
-            throw new Error("invalid left type for TirLessThanExpr");
-        return _ir_apps(irFunc, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirGreaterThanExpr {
-    left;
-    right;
-    range;
-    type = bool_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirGreaterThanExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.lessThanInteger :
-            type instanceof TirBytesT ? IRNative.lessThanByteString :
-                undefined);
-        if (!irFunc)
-            throw new Error("invalid left type for TirLessThanExpr");
-        return _ir_apps(irFunc, 
-        // invert because we only have lessThan
-        this.right.toIR(ctx), this.left.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirLessThanEqualExpr {
-    left;
-    right;
-    range;
-    type = bool_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirLessThanEqualExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.lessThanEqualInteger :
-            type instanceof TirBytesT ? IRNative.lessThanEqualsByteString :
-                undefined);
-        if (!irFunc)
-            throw new Error("invalid left type for TirLessThanExpr");
-        return _ir_apps(irFunc, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirGreaterThanEqualExpr {
-    left;
-    right;
-    range;
-    type = bool_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirGreaterThanEqualExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.lessThanEqualInteger :
-            type instanceof TirBytesT ? IRNative.lessThanEqualsByteString :
-                undefined);
-        if (!irFunc)
-            throw new Error("invalid left type for TirLessThanExpr");
-        return _ir_apps(irFunc, 
-        // invert because we only have lessThanEqual
-        this.right.toIR(ctx), this.left.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirEqualExpr {
-    left;
-    right;
-    range;
-    type = bool_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirEqualExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative.equals(this.left.type), this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirNotEqualExpr {
-    left;
-    right;
-    range;
-    type = bool_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirNotEqualExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative._not, _ir_apps(IRNative.equals(this.left.type), this.left.toIR(ctx), this.right.toIR(ctx)));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirAddExpr {
-    left;
-    right;
-    range;
-    get type() {
-        const leftType = getUnaliased(this.left.type);
-        if (leftType instanceof TirIntT
-            || leftType instanceof TirBytesT)
-            return this.type;
-        throw new Error("invalid type for addition");
-    }
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirAddExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.addInteger :
-            type instanceof TirBytesT ? IRNative.appendByteString :
-                undefined);
-        if (!irFunc)
-            throw new Error("invalid left type for TirAddExpr");
-        return _ir_apps(irFunc, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirSubExpr {
-    left;
-    right;
-    range;
-    type = int_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirSubExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative.subtractInteger, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirMultExpr {
-    left;
-    right;
-    range;
-    type = int_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirMultExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative.multiplyInteger, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirDivExpr {
-    left;
-    right;
-    range;
-    type = int_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirDivExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative.divideInteger, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirModuloExpr {
-    left;
-    right;
-    range;
-    type = int_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirModuloExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative.modInteger, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirShiftLeftExpr {
-    left;
-    right;
-    range;
-    type = bytes_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirShiftLeftExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(
-        // positive shift implies left
-        IRNative.shiftByteString, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirShiftRightExpr {
-    left;
-    right;
-    range;
-    type = bytes_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirShiftRightExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        let nIr = this.right.toIR(ctx);
-        if (this.right.isConstant) {
-            const result = Machine.evalSimple(compileIRToUPLC(nIr));
-            if (result instanceof CEKConst
-                && (typeof result.value === "bigint"
-                    || typeof result.value === "number")) {
-                const n = BigInt(result.value);
-                // positive shift implies left
-                if (n >= 0n) {
-                    nIr = IRConst.int(-n);
-                }
-                else {
-                    nIr = _ir_apps(IRNative._negateInt, nIr);
-                }
-            }
-            else
-                nIr = _ir_apps(IRNative._negateInt, nIr);
-        }
-        else
-            nIr = _ir_apps(IRNative._negateInt, nIr);
-        return _ir_apps(IRNative.shiftByteString, this.left.toIR(ctx), nIr);
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirBitwiseAndExpr {
-    left;
-    right;
-    range;
-    type = bytes_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirBitwiseAndExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative.andByteString, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirBitwiseXorExpr {
-    left;
-    right;
-    range;
-    type = bytes_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirBitwiseXorExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative.xorByteString, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirBitwiseOrExpr {
-    left;
-    right;
-    range;
-    type = bytes_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    clone() {
-        return new TirBitwiseOrExpr(this.left.clone(), this.right.clone(), this.range.clone());
-    }
-    get isConstant() { return this.left.isConstant && this.right.isConstant; }
-    toIR(ctx) {
-        return _ir_apps(IRNative.orByteString, this.left.toIR(ctx), this.right.toIR(ctx));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirLogicalAndExpr {
-    left;
-    right;
-    range;
-    type = bool_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    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));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}
-export class TirLogicalOrExpr {
-    left;
-    right;
-    range;
-    type = bool_t;
-    constructor(left, right, range) {
-        this.left = left;
-        this.right = right;
-        this.range = range;
-    }
-    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));
-    }
-    deps() {
-        const deps = this.left.deps();
-        mergeSortedStrArrInplace(deps, this.right.deps());
-        return deps;
-    }
-}

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

@@ -1,16 +0,0 @@
-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 TirLitArrExpr implements ITirExpr {
-    readonly elems: TirExpr[];
-    readonly type: TirType;
-    readonly range: SourceRange;
-    get isConstant(): boolean;
-    constructor(elems: TirExpr[], type: TirType, range: SourceRange);
-    clone(): TirLitArrExpr;
-    deps(): string[];
-    toIR(ctx: ToIRTermCtx): IRTerm;
-}

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

@@ -1,60 +0,0 @@
-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";
-export class TirLitArrExpr {
-    elems;
-    type;
-    range;
-    get isConstant() {
-        return this.elems.every(elem => elem.isConstant);
-    }
-    constructor(elems, type, range) {
-        this.elems = elems;
-        this.type = type;
-        this.range = range;
-    }
-    clone() {
-        return new TirLitArrExpr(this.elems.map(e => e.clone()), this.type.clone(), this.range.clone());
-    }
-    deps() {
-        return this.elems.reduce((deps, elem) => {
-            const elemDeps = elem.deps();
-            mergeSortedStrArrInplace(deps, elemDeps);
-            return deps;
-        }, []);
-    }
-    toIR(ctx) {
-        let nConstantsFromEnd = 0;
-        const elems = this.elems;
-        const elemsT = getListTypeArg(getUnaliased(this.type));
-        if (!elemsT)
-            throw new Error("invalid type for list");
-        for (let i = elems.length - 1; i >= 0; i--) {
-            if (elems[i].isConstant)
-                nConstantsFromEnd++;
-            else
-                break;
-        }
-        let list = constantList(elems.slice(elems.length - nConstantsFromEnd), elemsT, ctx);
-        // all the elements where constants
-        if (nConstantsFromEnd === elems.length)
-            return list;
-        for (let i = elems.length - nConstantsFromEnd - 1; i >= 0; i--) {
-            list = _ir_apps(IRNative.mkCons, elems[i].toIR(ctx), list);
-        }
-        return list;
-    }
-}
-function constantList(elems, elemsT, ctx) {
-    return IRConst.listOf(elemsT)(elems.map(el => {
-        let res = Machine.evalSimple(compileIRToUPLC(el.toIR(ctx)));
-        if (!(res instanceof CEKConst
-        // || res instanceof CEKError
-        ))
-            throw new Error("invalid constant");
-        return res.value;
-    }));
-}

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

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

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

@@ -1,17 +0,0 @@
-import { bool_t } from "../../program/stdScope/stdScope.js";
-import { IRConst } from "../../../../IR/index.js";
-export class TirLitFalseExpr {
-    range;
-    type = bool_t;
-    isConstant = true;
-    constructor(range) {
-        this.range = range;
-    }
-    clone() {
-        return new TirLitFalseExpr(this.range.clone());
-    }
-    deps() { return []; }
-    toIR(ctx) {
-        return IRConst.bool(false);
-    }
-}

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

@@ -1,15 +0,0 @@
-import { ITirExpr } from "../ITirExpr.js";
-import { SourceRange } from "../../../../ast/Source/SourceRange.js";
-import { TirType } from "../../types/TirType.js";
-import { IRTerm } from "../../../../IR/index.js";
-import { ToIRTermCtx } from "../ToIRTermCtx.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;
-    deps(): string[];
-    toIR(ctx: ToIRTermCtx): IRTerm;
-}

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

@@ -1,19 +0,0 @@
-import { bytes_t } from "../../program/stdScope/stdScope.js";
-import { IRConst } from "../../../../IR/index.js";
-export class TirLitHexBytesExpr {
-    bytes;
-    range;
-    type = bytes_t;
-    isConstant = true;
-    constructor(bytes, range) {
-        this.bytes = bytes;
-        this.range = range;
-    }
-    clone() {
-        return new TirLitHexBytesExpr(new Uint8Array(this.bytes), this.range.clone());
-    }
-    deps() { return []; }
-    toIR(ctx) {
-        return IRConst.bytes(this.bytes);
-    }
-}

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

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