@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev6

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

@@ -11,7 +11,9 @@ export declare class TirTernaryExpr implements ITirExpr {
     readonly type: TirType;
     readonly range: SourceRange;
     constructor(condition: TirExpr, ifTrue: TirExpr, ifFalse: TirExpr, type: TirType, range: SourceRange);
-    clone(): TirTernaryExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     deps(): string[];
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;

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

@@ -1,7 +1,4 @@
-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 { _ir_lazyIfThenElse } from "../../../IR/tree_utils/_ir_lazyIfThenElse.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
 export class TirTernaryExpr {
     condition;
@@ -16,6 +13,20 @@ export class TirTernaryExpr {
         this.type = type;
         this.range = range;
     }
+    toString() {
+        return `(${this.condition.toString()} ? ${this.ifTrue.toString()} : ${this.ifFalse.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        return (`(` +
+            `${this.condition.pretty(indent)} ?` +
+            `${indent_1}${this.ifTrue.pretty(indent + 1)} :` +
+            `${indent_1}${this.ifFalse.pretty(indent + 1)}` +
+            `)`);
+    }
     clone() {
         return new TirTernaryExpr(this.condition.clone(), this.ifTrue.clone(), this.ifFalse.clone(), this.type.clone(), this.range.clone());
     }
@@ -31,6 +42,6 @@ export class TirTernaryExpr {
             && 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))));
+        return _ir_lazyIfThenElse(this.condition.toIR(ctx), this.ifTrue.toIR(ctx), this.ifFalse.toIR(ctx));
     }
 }

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

@@ -15,7 +15,9 @@ export declare class TirToDataExpr implements ITirExpr {
     expr: TirExpr;
     readonly range: SourceRange;
     constructor(expr: TirExpr, range: SourceRange);
-    clone(): TirToDataExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     get isConstant(): boolean;
     get type(): TirDataT;
     deps(): string[];

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

@@ -5,7 +5,6 @@ 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";
@@ -22,6 +21,8 @@ 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";
+import { hoisted_constr1_empty } from "../../../IR/toUPLC/common_hoisted.js";
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 export function isTirDataEncodedType(type) {
     type = getUnaliased(type) ?? type;
     return (type instanceof TirDataT
@@ -35,6 +36,14 @@ export class TirToDataExpr {
         this.expr = expr;
         this.range = range;
     }
+    toString() {
+        return `toData( ${this.expr.toString()} )`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `toData(${this.expr.pretty(indent)})`;
+    }
     clone() {
         return new TirToDataExpr(this.expr.clone(), this.range.clone());
     }
@@ -67,13 +76,14 @@ export function _inlineToData(origin_t, exprIR) {
         const value_t = getOptTypeArg(from_t);
         if (!isTirType(value_t))
             throw new Error("TirToDataExpr: unreachable");
+        const valueName = Symbol("value");
         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
+            new IRFunc([valueName], // value
+            _ir_apps(IRNative.constrData, IRConst.int(0), _ir_apps(IRNative.mkCons, _inlineToData(value_t, new IRVar(valueName)), // value to data
             IRConst.listOf(data_t)([])))),
             // case Nothing
-            new IRHoisted(IRConst.data(new DataConstr(1, [])))
+            hoisted_constr1_empty.clone()
         ]);
     }
     if (from_t instanceof TirSoPStructType) {
@@ -107,25 +117,22 @@ export function _toDataUplcFunc(origin_t) {
             || 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
-        ))));
+        return mkMapListToData(elems_t);
     }
     if (from_t instanceof TirSopOptT
-        || from_t instanceof TirSoPStructType) {
-        return new IRHoisted(new IRFunc(1, // sop
-        _inlineToData(from_t, new IRVar(0) // sop
-        )));
-    }
+        || from_t instanceof TirSoPStructType)
+        return mkSopToData(from_t);
     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"));
+const _mkUnitData = new IRHoisted(new IRFunc([Symbol("unit")], IRConst.data(new DataConstr(0, []))));
+const bool_var_name = Symbol("bool");
+const _boolToData = new IRHoisted(new IRFunc([bool_var_name], // bool
+_ir_apps(IRNative.strictIfThenElse, new IRVar(bool_var_name), // bool
+new IRHoisted(IRConst.data(new DataConstr(0, []))), new IRHoisted(IRConst.data(new DataConstr(1, []))))));
+const str_var_name = Symbol("str");
+const _strToData = new IRHoisted(new IRFunc([str_var_name], // string
+_ir_apps(IRNative.bData, _ir_apps(IRNative.encodeUtf8, new IRVar(str_var_name) // string
+))));
 export function _inlineSingleSopConstrToData(sop_t, exprIR) {
     if (sop_t.constructors.length !== 1)
         throw new Error("_inilneSingeSopConstrFromData: multiple constructors");
@@ -141,15 +148,16 @@ export function _inlineSingleSopConstrToData(sop_t, exprIR) {
         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 fieldsVarsNames = constr.fields.map(f => Symbol(f.name));
+    for (let i = constr.fields.length - 1; i >= 0; i--) {
+        const filedExpr = new IRVar(fieldsVarsNames[i]);
         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)
+        new IRFunc(fieldsVarsNames, lst)
     ]));
 }
 export function _inlineMultiSopConstrToData(sop_t, exprIR) {
@@ -159,14 +167,37 @@ export function _inlineMultiSopConstrToData(sop_t, exprIR) {
         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 fieldsVarsNames = constr.fields.map(f => Symbol(f.name));
+        for (let i = constr.fields.length - 1; i >= 0; i--) {
+            const filedExpr = new IRVar(fieldsVarsNames[i]);
             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 IRFunc(fieldsVarsNames, _ir_apps(IRNative.constrData, IRConst.int(constrIdx), lst));
     });
     return new IRCase(exprIR, cases);
 }
+const _mapListToDataOfType = {};
+function mkMapListToData(elems_t) {
+    const key = elems_t.toTirTypeKey();
+    if (_mapListToDataOfType[key])
+        return _mapListToDataOfType[key].clone();
+    const hoisted_mapListToData_lst = Symbol("hoisted_mapListToData_lst");
+    _mapListToDataOfType[key] = new IRHoisted(new IRFunc([hoisted_mapListToData_lst], // list
+    _ir_apps(IRNative.listData, _ir_apps(IRNative._mkMapList, IRConst.listOf(elems_t)([]), _toDataUplcFunc(elems_t), new IRVar(hoisted_mapListToData_lst) // list
+    ))));
+    return _mapListToDataOfType[key].clone();
+}
+const _sopToDataOfType = {};
+function mkSopToData(from_t) {
+    const key = from_t.toTirTypeKey();
+    if (_sopToDataOfType[key])
+        return _sopToDataOfType[key].clone();
+    const sop_var = Symbol("sop");
+    _sopToDataOfType[key] = new IRHoisted(new IRFunc([sop_var], // sop
+    _inlineToData(from_t, new IRVar(sop_var) // sop
+    )));
+    return _sopToDataOfType[key].clone();
+}

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

@@ -16,7 +16,9 @@ export declare class TirTraceIfFalseExpr implements ITirExpr {
     condition: TirExpr, 
     /** must be string */
     traceStrExpr: TirExpr, range: SourceRange);
-    clone(): TirTraceIfFalseExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     toIR(ctx: ToIRTermCtx): IRTerm;
     get isConstant(): boolean;
     deps(): string[];

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

@@ -1,10 +1,9 @@
 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";
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
+import { _ir_lazyIfThenElse } from "../../../IR/tree_utils/_ir_lazyIfThenElse.js";
 export class TirTraceIfFalseExpr {
     condition;
     traceStrExpr;
@@ -19,11 +18,29 @@ export class TirTraceIfFalseExpr {
         this.traceStrExpr = traceStrExpr;
         this.range = range;
     }
+    toString() {
+        return `traceIfFalse( ${this.condition.toString()}, ${this.traceStrExpr.toString()} )`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_1 = indent_base + singleIndent;
+        return (`traceIfFalse(` +
+            `\n${indent_1}${this.condition.pretty(indent + 1)},` +
+            `\n${indent_1}${this.traceStrExpr.pretty(indent + 1)}` +
+            `\n${indent_base})`);
+    }
     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)))));
+        return _ir_lazyIfThenElse(
+        // condition
+        this.condition.toIR(ctx), 
+        // then
+        IRConst.bool(true), 
+        // else
+        _ir_apps(IRNative.trace, this.traceStrExpr.toIR(ctx), IRConst.bool(false)));
     }
     get isConstant() { return this.condition.isConstant && this.traceStrExpr.isConstant; }
     deps() {

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

@@ -9,8 +9,10 @@ export declare class TirTypeConversionExpr implements ITirExpr {
     readonly type: TirType;
     readonly range: SourceRange;
     constructor(expr: TirExpr, type: TirType, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     deps(): string[];
     get isConstant(): boolean;
-    clone(): TirTypeConversionExpr;
+    clone(): TirExpr;
     toIR(ctx: ToIRTermCtx): IRTerm;
 }

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

@@ -1,5 +1,5 @@
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 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";
@@ -18,6 +18,14 @@ export class TirTypeConversionExpr {
         this.type = type;
         this.range = range;
     }
+    toString() {
+        return `(${this.expr.toString()} as ${this.type.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return (`(${this.expr.pretty(indent)} as ${this.type.toString()})`);
+    }
     deps() {
         return this.expr.deps();
     }

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

@@ -3,14 +3,18 @@ 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 type { ITirExpr } from "./ITirExpr.js";
+import type { TirExpr } from "./TirExpr.js";
 import { ToIRTermCtx } from "./ToIRTermCtx.js";
 export declare class TirVariableAccessExpr implements ITirExpr {
-    readonly resolvedValue: ResolveValueResult;
     readonly range: SourceRange;
+    readonly resolvedValue: Readonly<ResolveValueResult>;
+    private readonly _creationStack;
     get type(): TirType;
     constructor(resolvedValue: ResolveValueResult, range: SourceRange);
-    clone(): TirVariableAccessExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     get isConstant(): boolean;
     get varName(): string;
     deps(): string[];

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

@@ -1,14 +1,24 @@
 import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
 import { IRVar } from "../../../IR/IRNodes/IRVar.js";
 export class TirVariableAccessExpr {
-    resolvedValue;
     range;
+    resolvedValue;
+    _creationStack;
     get type() {
         return this.resolvedValue.variableInfos.type;
     }
     constructor(resolvedValue, range) {
-        this.resolvedValue = resolvedValue;
         this.range = range;
+        this.resolvedValue = Object.freeze(resolvedValue);
+        this._creationStack = (new Error()).stack;
+    }
+    toString() {
+        return this.varName;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `${this.varName}`;
     }
     clone() {
         return new TirVariableAccessExpr(this.resolvedValue, this.range.clone());
@@ -17,14 +27,14 @@ export class TirVariableAccessExpr {
     get varName() {
         return this.resolvedValue.variableInfos.name;
     }
-    deps() {
-        return [this.varName];
-    }
+    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");
+            || ir instanceof IRSelfCall)) {
+            console.log(this.resolvedValue);
+            throw new Error(`variable '${this.varName}' is missing`);
+        }
         return ir;
     }
 }

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

@@ -2,28 +2,24 @@ 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 readonly localVars;
     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>);
+    constructor(parent: ToIRTermCtx | undefined);
+    allVariables(): string[];
     static root(): ToIRTermCtx;
     newChild(): ToIRTermCtx;
-    private localVarDbn;
-    getVarDeclDbn(name: string): bigint | undefined;
-    getVarAccessDbn(name: string): bigint | undefined;
+    private localVarSym;
+    getVarAccessSym(name: string): symbol | undefined;
     getVarAccessIR(name: string): IRVar | IRSelfCall | undefined;
-    defineVar(name: string): void;
-    defineRecursiveVar(name: string): void;
-    pushUnusedVar(): void;
+    /**
+     * @returns the symbol of the defined variable (for eventual `new IRFunc( ... )`)
+    **/
+    defineVar(varName: string | symbol): symbol;
+    /**
+     * @returns the symbol of the defined recursive variable (for eventual `new IRRecursive( ... )`)
+    **/
+    defineRecursiveVar(name: string): symbol;
+    private _parentDbn;
+    get dbn(): number;
+    pushUnusedVar(postfix?: string): symbol;
 }

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

@@ -3,75 +3,92 @@ 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);
-    }
+    localVars = new Map();
     _firstVariableIsRecursive = false;
-    constructor(parent, 
-    /**
-     * quick access from a variable name to its context
-     * used to resolve the variables in 0(1) time
-     */
-    variableToCtx) {
+    constructor(parent) {
         this.parent = parent;
-        this.variableToCtx = variableToCtx;
-        this._parentDbn = parent ? parent._parentDbn : BigInt(0);
+        this.localVars = new Map();
+        // DO NOT SET _parentDbn HERE
+        // it must be a getter to reflect changes in parent
+        // (parent dbn can change)
         this._firstVariableIsRecursive = false;
     }
+    allVariables() {
+        return ((this.parent?.allVariables() ?? [])
+            .concat([...this.localVars.keys()]));
+    }
     static root() {
-        return new ToIRTermCtx(undefined, new Map());
+        return new ToIRTermCtx(undefined);
     }
     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);
+        return new ToIRTermCtx(this);
     }
-    getVarDeclDbn(name) {
-        const ctx = this.variableToCtx.get(name);
-        if (!ctx)
-            return undefined;
-        return ctx.localVarDbn(name);
+    localVarSym(name) {
+        return this.localVars.get(name);
     }
-    getVarAccessDbn(name) {
-        const declDbn = this.getVarDeclDbn(name);
-        if (typeof declDbn !== "bigint")
-            return undefined;
-        return this.dbn - (declDbn + _1n);
+    getVarAccessSym(name) {
+        return (this.localVarSym(name)
+            ?? this.parent?.getVarAccessSym(name));
     }
     getVarAccessIR(name) {
-        const accessDbn = this.getVarAccessDbn(name);
-        if (typeof accessDbn !== "bigint")
+        const accessSym = this.getVarAccessSym(name);
+        if (typeof accessSym !== "symbol")
             return undefined;
-        if (name === this.variables[0]
-            && this._firstVariableIsRecursive)
-            return new IRSelfCall(accessDbn);
-        return new IRVar(accessDbn);
+        if (this._firstVariableIsRecursive
+            && name === this.localVars.keys().next().value)
+            return new IRSelfCall(accessSym);
+        return new IRVar(accessSym);
     }
-    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`);
-            }
+    /**
+     * @returns the symbol of the defined variable (for eventual `new IRFunc( ... )`)
+    **/
+    defineVar(varName) {
+        const name = typeof varName === "string" ? varName : varName.description;
+        // allow shadowing
+        // const exsistingCtx = this.variableToCtx.get( name );
+        // if(
+        //     exsistingCtx
+        //     && exsistingCtx.localVarSym( name ) !== undefined
+        // ) throw new Error(`variable '${name}' already defined in the current scope`);
+        if (this.localVars.has(name)) {
+            throw new Error(`variable '${name}' already defined in the current scope`);
         }
-        this.variables.push(name);
-        this.variableToCtx.set(name, this);
+        const sym = typeof varName === "string" ? Symbol(name) : varName;
+        this.localVars.set(name, sym);
+        // this.variableToCtx.set( name, this );
+        return sym;
     }
+    /**
+     * @returns the symbol of the defined recursive variable (for eventual `new IRRecursive( ... )`)
+    **/
     defineRecursiveVar(name) {
-        if (this.variables.length > 0
+        if (this.localVars.size > 0
             || this._firstVariableIsRecursive)
             throw new Error("recursive variable must be the first defined variable in the context");
-        this.defineVar(name);
         this._firstVariableIsRecursive = true;
+        return this.defineVar(name);
+    }
+    _parentDbn = undefined;
+    get dbn() {
+        if (typeof this._parentDbn !== "number")
+            this._parentDbn = this.parent instanceof ToIRTermCtx ? this.parent.dbn : 0;
+        return this.localVars.size + this._parentDbn;
     }
-    pushUnusedVar() {
-        this.variables.push(""); // just to increment dbn
+    pushUnusedVar(postfix) {
+        // this.variables.push( "" );
+        // just to increment dbn
+        // we need a new unique name in the `variables` map
+        // (if we just use empty string, or the same string, it will overwrite the previous "unused" entry)
+        // 
+        // we start with the number so we know it is not a valid variable name
+        // but we add "_unused" so the key is not an integer (which would be sorted first in Object.keys)
+        const prefix = this.dbn.toString();
+        if (!(typeof postfix === "string"
+            && postfix.length > 0))
+            postfix = "unused";
+        const name = prefix + "_" + postfix;
+        const sym = Symbol(name);
+        this.localVars.set(name, sym);
+        return sym;
     }
 }