@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

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

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

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

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

@@ -1,18 +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";
-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

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

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

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

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

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

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

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

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

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

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

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