@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

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

@@ -0,0 +1,17 @@
+import { HasSourceRange } from "../../../ast/nodes/HasSourceRange.js";
+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";
+export declare class TirParentesizedExpr implements HasSourceRange, ITirExpr {
+    expr: TirExpr;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(expr: TirExpr, type: TirType, range: SourceRange);
+    clone(): TirParentesizedExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

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

@@ -0,0 +1,20 @@
+export class TirParentesizedExpr {
+    expr;
+    type;
+    range;
+    constructor(expr, type, range) {
+        this.expr = expr;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirParentesizedExpr(this.expr.clone(), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        return this.expr.deps();
+    }
+    get isConstant() { return this.expr.isConstant; }
+    toIR(ctx) {
+        return this.expr.toIR(ctx);
+    }
+}

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

@@ -0,0 +1,18 @@
+import { TirExpr } from "./TirExpr.js";
+import { Identifier } from "../../../ast/nodes/common/Identifier.js";
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirType } from "../types/TirType.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirPropAccessExpr implements ITirExpr {
+    object: TirExpr;
+    readonly prop: Identifier;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(object: TirExpr, prop: Identifier, type: TirType, range: SourceRange);
+    clone(): TirPropAccessExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

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

@@ -0,0 +1,29 @@
+import { TirCallExpr } from "./TirCallExpr.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+export class TirPropAccessExpr {
+    object;
+    prop;
+    type;
+    range;
+    constructor(object, prop, type, range) {
+        this.object = object;
+        this.prop = prop;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirPropAccessExpr(this.object.clone(), this.prop.clone(), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        const deps = this.object.deps();
+        // not sure about this
+        if (this.prop instanceof TirCallExpr) {
+            mergeSortedStrArrInplace(deps, this.prop.deps());
+        }
+        return deps;
+    }
+    get isConstant() { return false; }
+    toIR(ctx) {
+        throw new Error("property access cannot be translated to IR");
+    }
+}

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

@@ -0,0 +1,18 @@
+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";
+export declare class TirTernaryExpr implements ITirExpr {
+    condition: TirExpr;
+    ifTrue: TirExpr;
+    ifFalse: TirExpr;
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(condition: TirExpr, ifTrue: TirExpr, ifFalse: TirExpr, type: TirType, range: SourceRange);
+    clone(): TirTernaryExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

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

@@ -0,0 +1,36 @@
+import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
+import { IRForced } from "../../../IR/IRNodes/IRForced.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+export class TirTernaryExpr {
+    condition;
+    ifTrue;
+    ifFalse;
+    type;
+    range;
+    constructor(condition, ifTrue, ifFalse, type, range) {
+        this.condition = condition;
+        this.ifTrue = ifTrue;
+        this.ifFalse = ifFalse;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirTernaryExpr(this.condition.clone(), this.ifTrue.clone(), this.ifFalse.clone(), this.type.clone(), this.range.clone());
+    }
+    deps() {
+        const deps = this.condition.deps();
+        mergeSortedStrArrInplace(deps, this.ifTrue.deps());
+        mergeSortedStrArrInplace(deps, this.ifFalse.deps());
+        return deps;
+    }
+    get isConstant() {
+        return (this.condition.isConstant
+            && this.ifTrue.isConstant
+            && this.ifFalse.isConstant);
+    }
+    toIR(ctx) {
+        return new IRForced(_ir_apps(IRNative.strictIfThenElse, this.condition.toIR(ctx), new IRDelayed(this.ifTrue.toIR(ctx)), new IRDelayed(this.ifFalse.toIR(ctx))));
+    }
+}

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

@@ -0,0 +1,28 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirAliasType } from "../types/TirAliasType.js";
+import { TirDataStructType, 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";
+import { TirDataT } from "../types/TirNativeType/native/data.js";
+import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
+type TirUnaliasedDataEncodedType = TirDataT | TirDataOptT | TirDataStructType;
+export type TirDataEncodedType = TirUnaliasedDataEncodedType | TirAliasType<TirUnaliasedDataEncodedType>;
+export declare function isTirDataEncodedType(type: TirType): type is TirDataEncodedType;
+export declare class TirToDataExpr implements ITirExpr {
+    expr: TirExpr;
+    readonly range: SourceRange;
+    constructor(expr: TirExpr, range: SourceRange);
+    clone(): TirToDataExpr;
+    get isConstant(): boolean;
+    get type(): TirDataT;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}
+export declare function _inlineToData(origin_t: TirType, exprIR: IRTerm): IRTerm;
+export declare function _toDataUplcFunc(origin_t: TirType): IRTerm;
+export declare function _inlineSingleSopConstrToData(sop_t: TirSoPStructType, exprIR: IRTerm): IRTerm;
+export declare function _inlineMultiSopConstrToData(sop_t: TirSoPStructType, exprIR: IRTerm): IRTerm;
+export {};

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

@@ -0,0 +1,172 @@
+import { DataConstr } from "@harmoniclabs/plutus-data";
+import { IRCase } from "../../../IR/IRNodes/IRCase.js";
+import { IRConst } from "../../../IR/IRNodes/IRConst.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { IRHoisted } from "../../../IR/IRNodes/IRHoisted.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 { data_t } from "../program/stdScope/stdScope.js";
+import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
+import { isTirType } from "../types/TirType.js";
+import { getListTypeArg } from "../types/utils/getListTypeArg.js";
+import { getOptTypeArg } from "../types/utils/getOptTypeArg.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+import { TirBoolT } from "../types/TirNativeType/native/bool.js";
+import { TirBytesT } from "../types/TirNativeType/native/bytes.js";
+import { TirDataT } from "../types/TirNativeType/native/data.js";
+import { TirIntT } from "../types/TirNativeType/native/int.js";
+import { TirLinearMapT } from "../types/TirNativeType/native/linearMap.js";
+import { TirListT } from "../types/TirNativeType/native/list.js";
+import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
+import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
+import { TirStringT } from "../types/TirNativeType/native/string.js";
+import { TirVoidT } from "../types/TirNativeType/native/void.js";
+export function isTirDataEncodedType(type) {
+    type = getUnaliased(type) ?? type;
+    return (type instanceof TirDataT
+        || type instanceof TirDataOptT
+        || type instanceof TirDataStructType);
+}
+export class TirToDataExpr {
+    expr;
+    range;
+    constructor(expr, range) {
+        this.expr = expr;
+        this.range = range;
+    }
+    clone() {
+        return new TirToDataExpr(this.expr.clone(), this.range.clone());
+    }
+    get isConstant() { return this.expr.isConstant; }
+    get type() { return data_t; }
+    deps() {
+        return this.expr.deps();
+    }
+    toIR(ctx) {
+        return _inlineToData(this.expr.type, this.expr.toIR(ctx));
+    }
+}
+export function _inlineToData(origin_t, exprIR) {
+    const from_t = getUnaliased(origin_t);
+    if (from_t instanceof TirDataT
+        || from_t instanceof TirDataOptT
+        || from_t instanceof TirDataStructType)
+        return exprIR;
+    if (from_t instanceof TirLinearMapT)
+        return _ir_apps(IRNative.mapData, exprIR);
+    if (from_t instanceof TirListT) {
+        const elems_t = getUnaliased(getListTypeArg(from_t));
+        if (elems_t instanceof TirDataStructType
+            || elems_t instanceof TirDataT
+            || elems_t instanceof TirDataOptT)
+            return _ir_apps(IRNative.listData, exprIR);
+        return _ir_apps(IRNative._mkMapList, IRConst.listOf(elems_t)([]), _toDataUplcFunc(elems_t), exprIR);
+    }
+    if (from_t instanceof TirSopOptT) {
+        const value_t = getOptTypeArg(from_t);
+        if (!isTirType(value_t))
+            throw new Error("TirToDataExpr: unreachable");
+        return new IRCase(exprIR, [
+            // case Just{ value }
+            new IRFunc(1, // value
+            _ir_apps(IRNative.constrData, IRConst.int(0), _ir_apps(IRNative.mkCons, _inlineToData(value_t, new IRVar(0)), // value to data
+            IRConst.listOf(data_t)([])))),
+            // case Nothing
+            new IRHoisted(IRConst.data(new DataConstr(1, [])))
+        ]);
+    }
+    if (from_t instanceof TirSoPStructType) {
+        return _inlineMultiSopConstrToData(from_t, exprIR);
+    }
+    return _ir_apps(_toDataUplcFunc(from_t), exprIR);
+}
+export function _toDataUplcFunc(origin_t) {
+    const from_t = getUnaliased(origin_t);
+    if (from_t instanceof TirDataT
+        || from_t instanceof TirDataOptT
+        || from_t instanceof TirDataStructType)
+        return IRNative._id;
+    if (from_t instanceof TirIntT)
+        return IRNative.iData;
+    if (from_t instanceof TirBytesT)
+        return IRNative.bData;
+    if (from_t instanceof TirVoidT)
+        return _mkUnitData;
+    if (from_t instanceof TirBoolT)
+        return _boolToData;
+    if (from_t instanceof TirStringT)
+        return _strToData;
+    if (from_t instanceof TirLinearMapT)
+        // linear maps only have pairs as elements
+        // and we only support pairs of data (bc we only have `mkPairData`)
+        return IRNative.mapData;
+    if (from_t instanceof TirListT) {
+        const elems_t = getUnaliased(getListTypeArg(from_t));
+        if (elems_t instanceof TirDataStructType
+            || elems_t instanceof TirDataOptT
+            || elems_t instanceof TirDataT)
+            return IRNative.listData;
+        return new IRHoisted(new IRFunc(1, // list
+        _ir_apps(IRNative.listData, _ir_apps(IRNative._mkMapList, IRConst.listOf(elems_t)([]), _toDataUplcFunc(elems_t), new IRVar(0) // list
+        ))));
+    }
+    if (from_t instanceof TirSopOptT
+        || from_t instanceof TirSoPStructType) {
+        return new IRHoisted(new IRFunc(1, // sop
+        _inlineToData(from_t, new IRVar(0) // sop
+        )));
+    }
+    throw new Error(`TirFromDataExpr: cannot convert from Data to type ${from_t.toString()}`);
+}
+const _mkUnitData = new IRHoisted(new IRFunc(1, IRConst.data(new DataConstr(0, [])), "~_mkUnitData"));
+const _boolToData = new IRHoisted(new IRFunc(1, // bool
+_ir_apps(IRNative.strictIfThenElse, new IRVar(0), // bool
+new IRHoisted(IRConst.data(new DataConstr(0, []))), new IRHoisted(IRConst.data(new DataConstr(1, [])))), "~_boolToData"));
+const _strToData = new IRHoisted(new IRFunc(1, // string
+_ir_apps(IRNative.bData, _ir_apps(IRNative.encodeUtf8, new IRVar(0) // string
+)), "~_strToData"));
+export function _inlineSingleSopConstrToData(sop_t, exprIR) {
+    if (sop_t.constructors.length !== 1)
+        throw new Error("_inilneSingeSopConstrFromData: multiple constructors");
+    const constr = sop_t.constructors[0];
+    if (constr.fields.length === 0)
+        return new IRHoisted(IRConst.data(new DataConstr(0, [])));
+    if (constr.fields.length === 1) {
+        const value_t = getUnaliased(constr.fields[0].type);
+        if (!isTirType(value_t))
+            throw new Error("TirFromDataExpr: unreachable");
+        return _ir_apps(IRNative.constrData, IRConst.int(0), _ir_apps(IRNative.mkCons, _inlineToData(value_t, 
+        // get unique field
+        new IRCase(exprIR, [IRNative._id])), IRConst.listOf(data_t)([])));
+    }
+    let lst = IRConst.listOf(data_t)([]);
+    for (let i = constr.fields.length - 1, fieldDbnIdx = 0; i >= 0; i--, fieldDbnIdx++) {
+        const filedExpr = new IRVar(fieldDbnIdx);
+        const field_t = getUnaliased(constr.fields[i].type);
+        if (!isTirType(field_t))
+            throw new Error("TirFromDataExpr: unreachable");
+        lst = _ir_apps(IRNative.mkCons, _inlineToData(field_t, filedExpr), lst);
+    }
+    return _ir_apps(IRNative.constrData, IRConst.int(0), new IRCase(exprIR, [
+        new IRFunc(constr.fields.length, lst)
+    ]));
+}
+export function _inlineMultiSopConstrToData(sop_t, exprIR) {
+    if (sop_t.constructors.length <= 1)
+        return _inlineSingleSopConstrToData(sop_t, exprIR);
+    const cases = sop_t.constructors.map((constr, constrIdx) => {
+        if (constr.fields.length === 0)
+            return new IRHoisted(IRConst.data(new DataConstr(constrIdx, [])));
+        let lst = IRConst.listOf(data_t)([]);
+        for (let i = constr.fields.length - 1, fieldDbnIdx = 0; i >= 0; i--, fieldDbnIdx++) {
+            const filedExpr = new IRVar(fieldDbnIdx);
+            const field_t = getUnaliased(constr.fields[i].type);
+            if (!isTirType(field_t))
+                throw new Error("TirFromDataExpr: unreachable");
+            lst = _ir_apps(IRNative.mkCons, _inlineToData(field_t, filedExpr), lst);
+        }
+        return new IRFunc(constr.fields.length, _ir_apps(IRNative.constrData, IRConst.int(constrIdx), lst));
+    });
+    return new IRCase(exprIR, cases);
+}

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

@@ -0,0 +1,23 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { TirType } from "../types/TirType.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+export declare class TirTraceIfFalseExpr implements ITirExpr {
+    /** must be boolean or Optional */
+    condition: TirExpr;
+    /** must be string */
+    traceStrExpr: TirExpr;
+    readonly range: SourceRange;
+    readonly type: TirType;
+    constructor(
+    /** must be boolean or Optional */
+    condition: TirExpr, 
+    /** must be string */
+    traceStrExpr: TirExpr, range: SourceRange);
+    clone(): TirTraceIfFalseExpr;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+    get isConstant(): boolean;
+    deps(): string[];
+}

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

@@ -0,0 +1,32 @@
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+import { bool_t } from "../program/stdScope/stdScope.js";
+import { IRConst } from "../../../IR/IRNodes/IRConst.js";
+import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
+import { IRForced } from "../../../IR/IRNodes/IRForced.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+export class TirTraceIfFalseExpr {
+    condition;
+    traceStrExpr;
+    range;
+    type = bool_t;
+    constructor(
+    /** must be boolean or Optional */
+    condition, 
+    /** must be string */
+    traceStrExpr, range) {
+        this.condition = condition;
+        this.traceStrExpr = traceStrExpr;
+        this.range = range;
+    }
+    clone() {
+        return new TirTraceIfFalseExpr(this.condition.clone(), this.traceStrExpr.clone(), this.range.clone());
+    }
+    toIR(ctx) {
+        return new IRForced(_ir_apps(IRNative.strictIfThenElse, this.condition.toIR(ctx), new IRDelayed(IRConst.bool(true)), new IRDelayed(_ir_apps(IRNative.trace, this.traceStrExpr.toIR(ctx), IRConst.bool(false)))));
+    }
+    get isConstant() { return this.condition.isConstant && this.traceStrExpr.isConstant; }
+    deps() {
+        return mergeSortedStrArrInplace(this.condition.deps(), this.traceStrExpr.deps());
+    }
+}

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

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

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

@@ -0,0 +1,66 @@
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+import { TirBoolT } from "../types/TirNativeType/native/bool.js";
+import { TirBytesT } from "../types/TirNativeType/native/bytes.js";
+import { TirDataT } from "../types/TirNativeType/native/data.js";
+import { TirIntT } from "../types/TirNativeType/native/int.js";
+import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
+import { TirDataStructType } from "../types/TirStructType.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+import { _inlineFromData } from "./TirFromDataExpr.js";
+import { _inlineToData } from "./TirToDataExpr.js";
+export class TirTypeConversionExpr {
+    expr;
+    type;
+    range;
+    constructor(expr, type, range) {
+        this.expr = expr;
+        this.type = type;
+        this.range = range;
+    }
+    deps() {
+        return this.expr.deps();
+    }
+    get isConstant() { return this.expr.isConstant; }
+    clone() {
+        return new TirTypeConversionExpr(this.expr.clone(), this.type.clone(), this.range.clone());
+    }
+    toIR(ctx) {
+        const from_t = getUnaliased(this.expr.type);
+        const to_t = getUnaliased(this.type);
+        const exprIR = this.expr.toIR(ctx);
+        if (from_t instanceof TirDataT
+            || from_t instanceof TirDataOptT
+            || from_t instanceof TirDataStructType)
+            return _inlineFromData(to_t, exprIR);
+        if (to_t instanceof TirDataT
+            || to_t instanceof TirDataOptT
+            || to_t instanceof TirDataStructType)
+            return _inlineToData(from_t, exprIR);
+        if (to_t instanceof TirIntT) {
+            if (from_t instanceof TirIntT)
+                return exprIR;
+            if (from_t instanceof TirBytesT)
+                return _ir_apps(IRNative._bytesToIntBE, exprIR);
+            if (from_t instanceof TirBoolT)
+                return _ir_apps(IRNative._boolToInt, exprIR);
+            throw new Error(`Cannot convert from ${from_t.toString()} to ${to_t.toString()}`);
+        }
+        if (to_t instanceof TirBytesT) {
+            if (from_t instanceof TirBytesT)
+                return exprIR;
+            if (from_t instanceof TirIntT)
+                return _ir_apps(IRNative._intToBytesBE, // internally handles int size
+                exprIR);
+            throw new Error(`Cannot convert from ${from_t.toString()} to ${to_t.toString()}`);
+        }
+        if (to_t instanceof TirBoolT) {
+            if (from_t instanceof TirBoolT)
+                return exprIR;
+            if (from_t instanceof TirIntT)
+                return _ir_apps(IRNative._intToBool, exprIR);
+            throw new Error(`Cannot convert from ${from_t.toString()} to ${to_t.toString()}`);
+        }
+        throw new Error(`Cannot convert from ${from_t.toString()} to ${to_t.toString()}`);
+    }
+}

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

@@ -0,0 +1,18 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
+import { IRVar } from "../../../IR/IRNodes/IRVar.js";
+import { ResolveValueResult } from "../../AstCompiler/scope/AstScope.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirVariableAccessExpr implements ITirExpr {
+    readonly resolvedValue: ResolveValueResult;
+    readonly range: SourceRange;
+    get type(): TirType;
+    constructor(resolvedValue: ResolveValueResult, range: SourceRange);
+    clone(): TirVariableAccessExpr;
+    get isConstant(): boolean;
+    get varName(): string;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRVar | IRSelfCall;
+}

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

@@ -0,0 +1,30 @@
+import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
+import { IRVar } from "../../../IR/IRNodes/IRVar.js";
+export class TirVariableAccessExpr {
+    resolvedValue;
+    range;
+    get type() {
+        return this.resolvedValue.variableInfos.type;
+    }
+    constructor(resolvedValue, range) {
+        this.resolvedValue = resolvedValue;
+        this.range = range;
+    }
+    clone() {
+        return new TirVariableAccessExpr(this.resolvedValue, this.range.clone());
+    }
+    get isConstant() { return false; }
+    get varName() {
+        return this.resolvedValue.variableInfos.name;
+    }
+    deps() {
+        return [this.varName];
+    }
+    toIR(ctx) {
+        const ir = ctx.getVarAccessIR(this.varName);
+        if (!(ir instanceof IRVar
+            || ir instanceof IRSelfCall))
+            throw new Error("Invalid variable access context");
+        return ir;
+    }
+}

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

@@ -0,0 +1,29 @@
+import { IRVar } from "../../../IR/IRNodes/IRVar.js";
+import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
+export declare class ToIRTermCtx {
+    readonly parent: ToIRTermCtx | undefined;
+    /**
+     * quick access from a variable name to its context
+     * used to resolve the variables in 0(1) time
+     */
+    private readonly variableToCtx;
+    private readonly variables;
+    private readonly _parentDbn;
+    get dbn(): bigint;
+    private _firstVariableIsRecursive;
+    constructor(parent: ToIRTermCtx | undefined, 
+    /**
+     * quick access from a variable name to its context
+     * used to resolve the variables in 0(1) time
+     */
+    variableToCtx: Map<string, ToIRTermCtx>);
+    static root(): ToIRTermCtx;
+    newChild(): ToIRTermCtx;
+    private localVarDbn;
+    getVarDeclDbn(name: string): bigint | undefined;
+    getVarAccessDbn(name: string): bigint | undefined;
+    getVarAccessIR(name: string): IRVar | IRSelfCall | undefined;
+    defineVar(name: string): void;
+    defineRecursiveVar(name: string): void;
+    pushUnusedVar(): void;
+}

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

@@ -0,0 +1,77 @@
+import { IRVar } from "../../../IR/IRNodes/IRVar.js";
+import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
+const _1n = BigInt(1);
+export class ToIRTermCtx {
+    parent;
+    variableToCtx;
+    variables = [];
+    _parentDbn;
+    get dbn() {
+        return this._parentDbn + BigInt(this.variables.length);
+    }
+    _firstVariableIsRecursive = false;
+    constructor(parent, 
+    /**
+     * quick access from a variable name to its context
+     * used to resolve the variables in 0(1) time
+     */
+    variableToCtx) {
+        this.parent = parent;
+        this.variableToCtx = variableToCtx;
+        this._parentDbn = parent ? parent._parentDbn : BigInt(0);
+        this._firstVariableIsRecursive = false;
+    }
+    static root() {
+        return new ToIRTermCtx(undefined, new Map());
+    }
+    newChild() {
+        return new ToIRTermCtx(this, this.variableToCtx);
+    }
+    localVarDbn(name) {
+        const idx = this.variables.indexOf(name);
+        if (idx < 0)
+            return undefined;
+        return this._parentDbn + BigInt(idx);
+    }
+    getVarDeclDbn(name) {
+        const ctx = this.variableToCtx.get(name);
+        if (!ctx)
+            return undefined;
+        return ctx.localVarDbn(name);
+    }
+    getVarAccessDbn(name) {
+        const declDbn = this.getVarDeclDbn(name);
+        if (typeof declDbn !== "bigint")
+            return undefined;
+        return this.dbn - (declDbn + _1n);
+    }
+    getVarAccessIR(name) {
+        const accessDbn = this.getVarAccessDbn(name);
+        if (typeof accessDbn !== "bigint")
+            return undefined;
+        if (name === this.variables[0]
+            && this._firstVariableIsRecursive)
+            return new IRSelfCall(accessDbn);
+        return new IRVar(accessDbn);
+    }
+    defineVar(name) {
+        if (this.variableToCtx.has(name)) {
+            const ctx = this.variableToCtx.get(name);
+            if (ctx.localVarDbn(name) !== undefined) {
+                throw new Error(`variable '${name}' already defined in the current scope`);
+            }
+        }
+        this.variables.push(name);
+        this.variableToCtx.set(name, this);
+    }
+    defineRecursiveVar(name) {
+        if (this.variables.length > 0
+            || this._firstVariableIsRecursive)
+            throw new Error("recursive variable must be the first defined variable in the context");
+        this.defineVar(name);
+        this._firstVariableIsRecursive = true;
+    }
+    pushUnusedVar() {
+        this.variables.push(""); // just to increment dbn
+    }
+}