@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

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

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

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

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

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

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

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

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

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