@harmoniclabs/pebble 0.1.0-dev4 → 0.1.0-dev6

package/dist/IR/IRNodes/IRHoisted.js

@@ -10,15 +10,27 @@ import { IRLetted } from "./IRLetted.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
 import { IRConstr } from "./IRConstr.js";
 import { IRCase } from "./IRCase.js";
-import { equalIrHash, hashIrData, irHashToHex, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
 import { IRNodeKind } from "../IRNodeKind.js";
 import { IRRecursive } from "./IRRecursive.js";
+import { isIRHash, hashIrData, irHashToBytes, equalIrHash, irHashToHex } from "../IRHash.js";
+import { IRNative } from "./IRNative/index.js";
+import { nativeTagToString } from "./IRNative/IRNativeTag.js";
 const defaultHoistedMeta = freezeAll({
     forceHoist: false
 });
+const _hoisted_hash_to_symbol = new Map();
 export class IRHoisted {
     meta;
+    get name() {
+        const hash = this.hash;
+        const cached = _hoisted_hash_to_symbol.get(hash)?.deref();
+        if (typeof cached === "symbol")
+            return cached;
+        const sym = Symbol(tryInferName(this.hoisted) ?? "hoisted_" + irHashToHex(hash));
+        /// @ts-ignore Argument of type 'WeakRef<object>' is not assignable to parameter of type 'WeakRef<Symbol>'
+        _hoisted_hash_to_symbol.set(hash, new WeakRef(sym));
+        return sym;
+    }
     constructor(hoisted, metadata = {}, _unsafeHash) {
         // unwrap
         // !!! IMPORTANT !!!
@@ -27,43 +39,45 @@ export class IRHoisted {
         if (!isClosedIRTerm(hoisted)) {
             throw new BasePlutsError("only closed terms can be hoisted");
         }
+        this._parent = undefined;
         // initialize without calling "set"
         this._hoisted = hoisted;
         this._hoisted.parent = this;
         this._deps = undefined;
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
-        this._parent = undefined;
         this.meta = {
             ...defaultHoistedMeta,
             ...metadata,
             name: this._hoisted.meta?.name ?? metadata.name
         };
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+    }
+    toUPLC() {
+        throw new Error("Can't convert 'IRHoisted' to valid UPLC;");
     }
-    static get kind() { return IRNodeKind.Hoisted; }
-    get kind() { return IRHoisted.kind; }
-    static get tag() { return new Uint8Array([IRHoisted.kind]); }
     _hash;
     get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = hashIrData(concatUint8Arr(IRHoisted.tag, this.hoisted.hash));
-        }
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRHoisted.tag, irHashToBytes(this.hoisted.hash)));
         return this._hash;
     }
+    isHashPresent() { return isIRHash(this._hash); }
     markHashAsInvalid() {
         this._hash = undefined;
-        this._deps = undefined;
         this.parent?.markHashAsInvalid();
     }
-    isHashPresent() {
-        return isIRHash(this._hash);
+    children() {
+        return [this.hoisted];
     }
+    static get kind() { return IRNodeKind.Hoisted; }
+    get kind() { return IRHoisted.kind; }
+    static get tag() { return new Uint8Array([IRHoisted.kind]); }
     _hoisted;
+    get value() { return this._hoisted; }
     get hoisted() { return this._hoisted; }
     set hoisted(newHoisted) {
         if (!isClosedIRTerm(newHoisted))
             throw new BasePlutsError("only closed terms can be hoisted");
-        if (!shallowEqualIRTermHash(this._hoisted, newHoisted))
-            this.markHashAsInvalid();
         // dependencies need to be updated EVEN if hash is the same
         // since the terms might be the same but maybe cloned
         this._deps = undefined;
@@ -91,13 +105,12 @@ export class IRHoisted {
         this._parent = newParent;
     }
     clone() {
-        return new IRHoisted(this.hoisted.clone(), { ...this.meta }, this.isHashPresent() ? this.hash : undefined);
+        return new IRHoisted(this.value.clone(), { ...this.meta }, this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {
         return {
             type: "IRHoisted",
-            hash: irHashToHex(this.hash),
             hoisted: this.hoisted.toJson()
         };
     }
@@ -124,7 +137,7 @@ export function getSortedHoistedSet(hoistedTerms) {
         for (let i = 0; i < _terms.length; i++) {
             const thisHoistedEntry = _terms[i];
             const thisHash = thisHoistedEntry.hoisted.hash;
-            const idxInSet = hashesSet.findIndex(hash => equalIrHash(hash, thisHash));
+            const idxInSet = hashesSet.findIndex(h => equalIrHash(h, thisHash));
             // if( !hashesSet.includes( compiled ) )
             // "includes" uses standard equality (===)
             if (idxInSet < 0) // not present
@@ -210,3 +223,8 @@ export function cloneHoistedSetEntry({ hoisted, nReferences }) {
         nReferences
     };
 }
+export function tryInferName(value) {
+    if (value instanceof IRNative)
+        return nativeTagToString(value.tag);
+    return undefined;
+}

package/dist/IR/IRNodes/IRLetted.d.ts

@@ -1,22 +1,24 @@
 import { IRMetadata } from "../interfaces/IRMetadata.js";
 import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
 import { ToJson } from "../../utils/ToJson.js";
-import { IRTerm } from "../IRTerm.js";
-import { IHash, IIRParent } from "../interfaces/index.js";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
+import { IIRParent } from "../interfaces/index.js";
 import { IRParentTerm } from "../utils/isIRParentTerm.js";
 import { BaseIRMetadata } from "./BaseIRMetadata.js";
 import { IRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
 export type LettedSetEntry = {
     letted: IRLetted;
     nReferences: number;
 };
 export declare function jsonLettedSetEntry(entry: LettedSetEntry): {
-    letted: string;
+    letted: string | undefined;
     nReferences: number;
 };
 export declare function expandedJsonLettedSetEntry(entry: LettedSetEntry): {
-    letted: string;
+    letted: string | undefined;
+    letted_value: string[];
     nReferences: number;
 };
 export interface IRLettedMeta extends BaseIRMetadata {
@@ -32,33 +34,25 @@ export interface IRLettedMeta extends BaseIRMetadata {
 export interface IRLettedMetadata extends IRMetadata {
     meta: IRLettedMeta;
 }
-export declare class IRLetted implements Cloneable<IRLetted>, IHash, IIRParent, ToJson, IRLettedMetadata {
+export declare class IRLetted implements IIRTerm, Cloneable<IRLetted>, IIRParent, ToJson, IRLettedMetadata {
+    private _name;
+    readonly meta: IRLettedMeta;
+    get name(): symbol;
+    constructor(name: symbol, toLet: IRTerm, metadata?: Partial<IRLettedMeta>, _unsafeHash?: IRHash | undefined);
+    toUPLC(): UPLCTerm;
     private _hash;
     get hash(): IRHash;
-    markHashAsInvalid(): void;
     isHashPresent(): boolean;
+    markHashAsInvalid(): void;
     private _value;
     get value(): IRTerm;
     set value(newVal: IRTerm);
-    private _dbn;
-    /**
-     * we need to keep track of the debruijn at which the `IRLetted` is instantiated
-     *
-     * this is because stuff like `new IRLetted( new IRVar(0) )` has different meaning
-     * at different DeBruijn levels
-     *
-     * knowing the DeBruijn we can differentiate them
-     */
-    get dbn(): number;
-    set dbn(newDbn: number);
-    isClosedAtDbn(dbn: number): boolean;
     private _deps;
     get dependencies(): LettedSetEntry[];
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRParentTerm | undefined);
-    readonly meta: IRLettedMeta;
-    constructor(DeBruijn: number | bigint, toLet: IRTerm, metadata?: Partial<IRLettedMeta>, _unsafeHash?: IRHash | undefined);
+    children(): IRTerm[];
     static get kind(): IRNodeKind.Letted;
     get kind(): IRNodeKind.Letted;
     static get tag(): Uint8Array;
@@ -92,17 +86,3 @@ export declare const default_getLettedTermsOptions: GetLettedTermsOptions;
  * @returns direct letted terms (no possible dependencies)
  */
 export declare function getLettedTerms(irTerm: IRTerm, options?: Partial<GetLettedTermsOptions>): LettedSetEntry[];
-export declare function getNormalizedLettedArgs(lettedDbn: number, value: IRTerm): [normalized_dbn: number, noramlized_value: IRTerm] | undefined;
-/**
- *
- * @param term the ir term to iter to search for vars
- * @returns {number | undefined}
- *
- * @example
- * ```ts
- * let minDbn = getMinVarDbn( new IRVar(0) ); // 0
- * minDbn = getMinVarDbn( IRConst.unit ); // undefined
- * minDbn = getMinVarDbn( new IRFunc( 1, new IRVar( 0 ) ) ); // 0
- * ```
- */
-export declare function getMinVarDbn(term: IRTerm): number | undefined;

package/dist/IR/IRNodes/IRLetted.js

@@ -1,35 +1,22 @@
-import { iterTree } from "../toUPLC/_internal/iterTree.js";
-import { IRVar } from "./IRVar.js";
-import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
 import { freezeAll } from "@harmoniclabs/obj-utils";
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
 import { concatUint8Arr } from "../utils/concatUint8Arr.js";
 import { isIRTerm } from "../utils/isIRTerm.js";
-import { IRApp } from "./IRApp.js";
-import { IRDelayed } from "./IRDelayed.js";
-import { IRForced } from "./IRForced.js";
-import { IRFunc } from "./IRFunc.js";
 import { IRHoisted } from "./IRHoisted.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { _modifyChildFromTo } from "../toUPLC/_internal/_modifyChildFromTo.js";
-import { _getMinUnboundDbn } from "../toUPLC/subRoutines/handleLetted/groupByScope.js";
-import { IRConstr } from "./IRConstr.js";
-import { IRCase } from "./IRCase.js";
-import { equalIrHash, hashIrData, irHashToHex, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
+import { hashIrData, irHashToBytes, isIRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
-import { IRRecursive } from "./IRRecursive.js";
-import { IRSelfCall } from "./IRSelfCall.js";
+import { prettyIR } from "../utils/showIR.js";
 export function jsonLettedSetEntry(entry) {
     return {
-        letted: irHashToHex(entry.letted.hash),
+        letted: entry.letted.name.description,
         nReferences: entry.nReferences
     };
 }
 export function expandedJsonLettedSetEntry(entry) {
     return {
-        letted: irHashToHex(entry.letted.hash),
-        // letted_value: prettyIR( entry.letted.value ).text.split("\n"),
+        letted: entry.letted.name.description,
+        letted_value: prettyIR(entry.letted.value).text.split("\n"),
         nReferences: entry.nReferences
     };
 }
@@ -38,65 +25,67 @@ const defaultLettedMeta = freezeAll({
     __src__: undefined,
     isClosed: false
 });
-let n_hash_access = 0;
+const _letted_hash_to_symbol = new Map();
 export class IRLetted {
+    _name;
+    meta;
+    get name() {
+        const hash = this.hash;
+        const cached = _letted_hash_to_symbol.get(hash)?.deref();
+        if (typeof cached === "symbol")
+            return cached;
+        if (typeof this._name !== "symbol")
+            throw new Error("IRLetted had invalid name");
+        const sym = this._name;
+        /// @ts-ignore Argument of type 'WeakRef<object>' is not assignable to parameter of type 'WeakRef<Symbol>'
+        _letted_hash_to_symbol.set(hash, new WeakRef(sym));
+        return sym;
+    }
+    constructor(name, toLet, metadata = {}, _unsafeHash) {
+        if (!(typeof name === "symbol"
+            && typeof name.description === "string"
+            && name.description.length > 0))
+            throw new BasePlutsError("invalid name for IRVar");
+        this._name = name;
+        while (toLet instanceof IRLetted
+            || toLet instanceof IRHoisted)
+            toLet = toLet instanceof IRLetted ? toLet.value : toLet.hoisted;
+        if (!isIRTerm(toLet))
+            throw new BasePlutsError("letted value was not an IRTerm");
+        this._value = toLet;
+        this._value.parent = this;
+        this._deps = undefined;
+        this._parent = undefined;
+        this.meta = {
+            ...defaultLettedMeta,
+            ...metadata,
+            // isClosed: metadata.isClosed || this.isClosedAtDbn( 0 )
+        };
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+    }
+    toUPLC() {
+        throw new Error("Can't convert 'IRLetted' to valid UPLC");
+    }
     _hash;
     get hash() {
-        if (!isIRHash(this._hash)) {
-            /*
-            NOTE TO SELF:
-
-            NEVER
-            NEVER
-            NEVER
-
-            NEVER GET THE HASH BASED ON THE METADATA
-
-            NEVER
-            */
-            const normalized = getNormalizedLettedArgs(this.dbn, this._value);
-            if (normalized === undefined) {
-                // `_value` doesn't includes any `IRVar`
-                // aka. there is nothing to normalize
-                // just use the value regardless of the
-                // `IRLetted` dbn instantiation
-                this._hash = hashIrData(concatUint8Arr(IRLetted.tag, this._value.hash));
-            }
-            else {
-                this._hash = hashIrData(concatUint8Arr(IRLetted.tag, positiveIntAsBytes(normalized[0]), normalized[1].hash));
-                /*
-                const [ normalized_dbn, normalized_value] = normalized;
-                if( toHex( hash ) === "ee84fb036ed2726e01b0415109246927" )
-                {
-                    const original_value = _value.clone();
-                    const minDbn = getMinVarDbn( original_value );
-                    const minUnb = _getMinUnboundDbn( original_value );
-                    console.log(
-                        "_ee84fb036ed2726e01b0415109246927_",
-                        "\noriginal value:", prettyIRJsonStr( original_value, 2, { hoisted: false } ),
-                        "\nmin dbn:", minDbn,
-                        "\nmin unbound:", minUnb,
-                        "\nnormalized dbn:", normalized_dbn,
-                    );
-                }
-                //*/
-            }
-        }
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRLetted.tag, irHashToBytes(this.value.hash)));
         return this._hash;
     }
+    isHashPresent() { return isIRHash(this._hash); }
     markHashAsInvalid() {
         this._hash = undefined;
-        this._deps = undefined;
         this.parent?.markHashAsInvalid();
     }
-    isHashPresent() { return isIRHash(this._hash); }
     _value;
     get value() { return this._value; }
     set value(newVal) {
+        while (newVal instanceof IRLetted
+            || newVal instanceof IRHoisted)
+            newVal = newVal instanceof IRLetted ? newVal.value : newVal.hoisted;
         if (!isIRTerm(newVal))
             throw new BasePlutsError("letted term was not IRTerm");
-        if (!shallowEqualIRTermHash(this._value, newVal))
-            this.markHashAsInvalid();
         // remove deps even if the value is the same
         // newValue might be a clone of the current value
         // and so have different (new) objects
@@ -106,35 +95,6 @@ export class IRLetted {
         this._value = newVal;
         this._value.parent = this;
     }
-    _dbn;
-    /**
-     * we need to keep track of the debruijn at which the `IRLetted` is instantiated
-     *
-     * this is because stuff like `new IRLetted( new IRVar(0) )` has different meaning
-     * at different DeBruijn levels
-     *
-     * knowing the DeBruijn we can differentiate them
-     */
-    get dbn() { return this._dbn; }
-    set dbn(newDbn) {
-        if (!(Number.isSafeInteger(newDbn) && newDbn >= 0))
-            throw new BasePlutsError("invalid index for an `IRLetted` instance");
-        if (newDbn === this._dbn) {
-            // everything ok
-            // avoid calling `markHashAsInvalid` 
-            return;
-        }
-        this.markHashAsInvalid();
-        this._dbn = newDbn;
-    }
-    isClosedAtDbn(dbn) {
-        if (!Number.isSafeInteger(dbn))
-            throw new Error("unexpected unsafe dbn integer");
-        const minUnbound = _getMinUnboundDbn(this._value);
-        if (minUnbound === undefined)
-            return true;
-        return minUnbound < dbn;
-    }
     _deps;
     get dependencies() {
         if (this._deps === undefined)
@@ -153,41 +113,20 @@ export class IRLetted {
             return;
         this._parent = newParent;
     }
-    meta;
-    constructor(DeBruijn, toLet, metadata = {}, _unsafeHash = undefined) {
-        DeBruijn = typeof DeBruijn === "bigint" ? Number(DeBruijn) : DeBruijn;
-        if (!(Number.isSafeInteger(DeBruijn) && DeBruijn >= 0))
-            throw new BasePlutsError("invalid index for an `IRLetted` instance");
-        while (toLet instanceof IRLetted ||
-            toLet instanceof IRHoisted) {
-            toLet = toLet instanceof IRLetted ? toLet.value : toLet.hoisted;
-        }
-        if (!isIRTerm(toLet))
-            throw new BasePlutsError("letted value was not an IRTerm");
-        this._dbn = DeBruijn;
-        this._value = toLet;
-        this._value.parent = this;
-        // we need the has before setting dependecies
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
-        this._deps = undefined;
-        this._parent = undefined;
-        this.meta = {
-            ...defaultLettedMeta,
-            ...metadata,
-            // isClosed: metadata.isClosed || this.isClosedAtDbn( 0 )
-        };
+    children() {
+        return [this._value];
     }
     static get kind() { return IRNodeKind.Letted; }
     get kind() { return IRLetted.kind; }
     static get tag() { return new Uint8Array([IRLetted.kind]); }
     clone() {
-        return new IRLetted(this.dbn, this.value.clone(), { ...this.meta }, this.isHashPresent() ? this.hash : undefined);
+        return new IRLetted(this.name, this.value.clone(), { ...this.meta }, this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {
         return {
             type: "IRLetted",
-            hash: irHashToHex(this.hash),
+            name: this.name.description,
             value: this.value.toJson()
         };
     }
@@ -213,19 +152,12 @@ export function getSortedLettedSet(lettedTerms) {
     function addToSet(_terms) {
         for (let i = 0; i < _terms.length; i++) {
             const thisLettedEntry = _terms[i];
-            const thisHash = thisLettedEntry.letted.hash;
-            const idxInSet = hashesSet.findIndex(hash => equalIrHash(hash, thisHash));
-            // if( !hashesSet.includes( hash ) )
-            // "includes" uses standard equality (===)
+            const thisHash = thisLettedEntry.letted.name;
+            const idxInSet = hashesSet.indexOf(thisHash);
             if (idxInSet < 0) // not present
              {
                 // add dependencies first
                 // dependencies don't have references to the current letted
-                // (of course, wouldn't be much of a dependecy otherwhise)
-                //
-                // don't add dependecies of dependecies since `dependecies` proerty
-                // already calls `getSortedLettedSet( getLettedTerms( _value ) )`
-                // so repeating it here would count deps twice (exponentially for deps of deps)
                 addToSet(getLettedTerms(thisLettedEntry.letted.value));
                 hashesSet.push(thisHash);
                 set.push({
@@ -263,182 +195,18 @@ export function getLettedTerms(irTerm, options) {
     const stack = [irTerm];
     while (stack.length > 0) {
         const t = stack.pop();
+        if (t instanceof IRHoisted) {
+            if (includeHoisted)
+                stack.push(t.hoisted);
+            continue;
+        }
         if (t instanceof IRLetted) {
             lettedTerms.push({ letted: t, nReferences: 1 });
-            if (all) {
+            if (all)
                 stack.push(t.value);
-            }
-            continue;
-        }
-        if (t instanceof IRApp) {
-            stack.push(t.fn, t.arg);
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...Array.from(t.fields));
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push(t.constrTerm, ...Array.from(t.continuations));
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(t.body);
             continue;
         }
-        if (t instanceof IRRecursive) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(t.forced);
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(t.delayed);
-            continue;
-        }
-        if (includeHoisted) {
-            if (t instanceof IRHoisted) {
-                stack.push(t.hoisted);
-                continue;
-            }
-        }
+        stack.push(...t.children());
     }
     return lettedTerms;
 }
-export function getNormalizedLettedArgs(lettedDbn, value) {
-    const normalized_value = value.clone();
-    const minDbn = getMinVarDbn(normalized_value);
-    if (minDbn === undefined)
-        return undefined;
-    if (minDbn !== 0)
-        iterTree(normalized_value, (node, relativeDbn) => {
-            if (node instanceof IRVar) {
-                node.dbn -= minDbn;
-            }
-            else if (node instanceof IRSelfCall) {
-                node.dbn -= minDbn;
-            }
-            //*
-            else if (node instanceof IRLetted) {
-                const max = getMaxVarDbn(node.value);
-                if (
-                // no vars
-                typeof max !== "number" ||
-                    // defined outside of letted
-                    max >= relativeDbn) {
-                    node.dbn -= minDbn;
-                }
-                else // if depends on vars in this letted
-                 {
-                    // TODO: fix double checking already inlined values
-                    //
-                    // this is currently a workaround
-                    //
-                    // the real problem is that sometimes (when?)
-                    // `iterTree` goes back checking some value that was already modified
-                    // in the case of `IRApp` as parent, throwing an error
-                    // because we don't know which value we should modify
-                    if (node.parent instanceof IRApp) {
-                        const parent = node.parent;
-                        const currentChild = node;
-                        if ( // parent is actually pointing to child
-                        currentChild === parent.arg ||
-                            currentChild === parent.fn ||
-                            equalIrHash(parent.arg.hash, currentChild.hash) ||
-                            equalIrHash(parent.fn.hash, currentChild.hash)) {
-                            // inline
-                            _modifyChildFromTo(node.parent, node, node.value);
-                            return true; // modified parent
-                        }
-                        else
-                            return false; // modified parent
-                    }
-                    else {
-                        if (node.parent) // only modify if not root
-                         {
-                            // inline
-                            _modifyChildFromTo(node.parent, node, node.value);
-                            return true; // modified parent
-                        }
-                        else
-                            return false;
-                    }
-                }
-            }
-            //*/
-        }, 
-        // shouldSkipNode ?
-        // hoisted terms are not really here
-        // will be substituted to variables when the time comes
-        // however now are here and we need to skip them
-        //
-        // !!! WARNING !! removing this causes strange uplc compilation BUGS
-        (node, dbn) => node instanceof IRHoisted);
-    // !!! IMPORTANT !!! _getMinUnboundDbn( value ) MUST be called on the original value; NOT the **modified** `normalized_value`
-    return [lettedDbn - (_getMinUnboundDbn(value) ?? minDbn), normalized_value];
-}
-/**
- *
- * @param term the ir term to iter to search for vars
- * @returns {number | undefined}
- *
- * @example
- * ```ts
- * let minDbn = getMinVarDbn( new IRVar(0) ); // 0
- * minDbn = getMinVarDbn( IRConst.unit ); // undefined
- * minDbn = getMinVarDbn( new IRFunc( 1, new IRVar( 0 ) ) ); // 0
- * ```
- */
-export function getMinVarDbn(term) {
-    let min = undefined;
-    let foundAny = false;
-    iterTree(term, (node) => {
-        if (node instanceof IRVar ||
-            node instanceof IRSelfCall) {
-            if (foundAny) {
-                min = Math.min(min, node.dbn);
-            }
-            else {
-                foundAny = true;
-                min = node.dbn;
-            }
-        }
-    }, 
-    // shouldSkipNode ?
-    // hoisted terms are not really here
-    // will be substituted to variables when the time comes
-    // however now are here and we need to skip them
-    node => node instanceof IRHoisted // skip if hoisted
-    );
-    return min;
-}
-/**
- *
- * @param term the ir term to iter to search for vars
- * @returns {number | undefined}
- */
-function getMaxVarDbn(term) {
-    let max = undefined;
-    let foundAny = false;
-    iterTree(term, (node) => {
-        if (node instanceof IRVar ||
-            node instanceof IRSelfCall) {
-            if (foundAny) {
-                max = Math.max(max, node.dbn);
-            }
-            else {
-                foundAny = true;
-                max = node.dbn;
-            }
-        }
-    }, 
-    // shouldSkipNode ?
-    // hoisted terms are not really here
-    // will be substituted to variables when the time comes
-    // however now are here and we need to skip them
-    node => node instanceof IRHoisted // skip if hoisted
-    );
-    return max;
-}

package/dist/IR/IRNodes/IRNative/IRNativeTag.d.ts

@@ -104,9 +104,7 @@ export declare enum IRNativeTag {
     _id = -15,
     _not = -16,
     _strictAnd = -17,
-    _and = -18,
     _strictOr = -19,
-    _or = -20,
     _gtBS = -21,
     _gtEqBS = -22,
     _gtInt = -23,

package/dist/IR/IRNodes/IRNative/IRNativeTag.js

@@ -126,9 +126,7 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["_id"] = -15] = "_id";
     IRNativeTag[IRNativeTag["_not"] = -16] = "_not";
     IRNativeTag[IRNativeTag["_strictAnd"] = -17] = "_strictAnd";
-    IRNativeTag[IRNativeTag["_and"] = -18] = "_and";
     IRNativeTag[IRNativeTag["_strictOr"] = -19] = "_strictOr";
-    IRNativeTag[IRNativeTag["_or"] = -20] = "_or";
     IRNativeTag[IRNativeTag["_gtBS"] = -21] = "_gtBS";
     IRNativeTag[IRNativeTag["_gtEqBS"] = -22] = "_gtEqBS";
     IRNativeTag[IRNativeTag["_gtInt"] = -23] = "_gtInt";
@@ -175,9 +173,7 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._id: return "id";
         case IRNativeTag._not: return "not";
         case IRNativeTag._strictAnd: return "strictAnd";
-        case IRNativeTag._and: return "and";
         case IRNativeTag._strictOr: return "strictOr";
-        case IRNativeTag._or: return "or";
         case IRNativeTag._gtBS: return "gtBS";
         case IRNativeTag._gtEqBS: return "gtEqBS";
         case IRNativeTag._gtInt: return "gtInt";