@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

package/dist/IR/toUPLC/subRoutines/handleLetted/groupByScope.js

@@ -1,14 +1,8 @@
-import { IRApp } from "../../../IRNodes/IRApp.js";
-import { IRCase } from "../../../IRNodes/IRCase.js";
-import { IRConstr } from "../../../IRNodes/IRConstr.js";
 import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../../IRNodes/IRForced.js";
 import { IRFunc } from "../../../IRNodes/IRFunc.js";
-import { IRLetted } from "../../../IRNodes/IRLetted.js";
 import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
 import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
 import { IRVar } from "../../../IRNodes/IRVar.js";
-import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
 export function groupByScope(letteds) {
     const scopes = [];
     function pushScope(scope, letted) {
@@ -23,85 +17,85 @@ export function groupByScope(letteds) {
         scopeEntry.group.push(letted);
     }
     for (const { letted, nReferences } of letteds) {
-        let minUnboundDbn = _getMinUnboundDbn(letted.value);
-        if (minUnboundDbn === undefined) {
-            pushScope(undefined, { letted, nReferences });
-            continue;
-        }
-        let maxScope = letted.parent;
-        if (maxScope instanceof IRFunc ||
-            maxScope instanceof IRRecursive) {
-            minUnboundDbn -= maxScope.arity;
-        }
-        while (minUnboundDbn >= 0) {
-            maxScope = maxScope?.parent;
-            if (maxScope instanceof IRFunc ||
-                maxScope instanceof IRRecursive) {
-                minUnboundDbn -= maxScope.arity;
-            }
-        }
+        const maxScope = getMaxScope(letted.value);
         pushScope(maxScope, { letted, nReferences });
     }
     return scopes;
 }
-/**
- *
- * @param _term
- * @returns {number | undefined}
- *  a `number` if the `_term` param is open;
- *  represents the debuijn index an `IRVar` would have
- *  in order to point to the smallest scope that fulfills the term;
- *
- *  `undefined` if the term is closed
- */
-export function _getMinUnboundDbn(_term) {
-    let minDbn = undefined;
-    const stack = [{ term: _term, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term, dbn } = stack.pop();
-        if (term instanceof IRVar ||
-            term instanceof IRSelfCall) {
-            if (term.dbn >= dbn) // some val outside
-             {
-                const outsideDbn = term.dbn - dbn;
-                minDbn = minDbn === undefined ? outsideDbn : Math.min(outsideDbn, minDbn);
+export function getMaxScope(term) {
+    const unbounded = getUnboundedVars(term);
+    if (unbounded.size === 0)
+        return undefined;
+    while (term.parent) {
+        term = term.parent;
+        if (term instanceof IRDelayed)
+            return term;
+        if (term instanceof IRFunc
+            || term instanceof IRRecursive) {
+            for (const param of term.params) {
+                if (unbounded.has(param))
+                    return term;
             }
         }
-        if (term instanceof IRApp) {
-            stack.push({ term: term.fn, dbn }, { term: term.arg, dbn });
-            continue;
-        }
-        if (term instanceof IRCase) {
-            stack.push({ term: term.constrTerm, dbn }, ...mapArrayLike(term.continuations, continuation => ({ term: continuation, dbn })));
-            continue;
-        }
-        if (term instanceof IRConstr) {
-            stack.push(...mapArrayLike(term.fields, field => ({ term: field, dbn })));
-            continue;
-        }
-        if (term instanceof IRDelayed) {
-            stack.push({ term: term.delayed, dbn });
+    }
+    throw new Error("Unbounded var not found in any parent term");
+}
+export function getUnboundedIRVars(term) {
+    const accessedVars = new Map();
+    const boundedVars = new Set();
+    const stack = [term];
+    while (stack.length > 0) {
+        const t = stack.pop();
+        if (t instanceof IRVar
+            || t instanceof IRSelfCall) {
+            let vars = accessedVars.get(t.name);
+            if (!Array.isArray(vars)) {
+                vars = [];
+                accessedVars.set(t.name, vars);
+            }
+            vars.push(t);
             continue;
         }
-        if (term instanceof IRForced) {
-            stack.push({ term: term.forced, dbn });
+        if (t instanceof IRFunc
+            || t instanceof IRRecursive) {
+            for (const param of t.params)
+                boundedVars.add(param);
+            stack.push(t.body);
             continue;
         }
-        if (term instanceof IRFunc) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
-            continue;
+        stack.push(...t.children());
+    }
+    for (const v of boundedVars)
+        accessedVars.delete(v);
+    return [...accessedVars.values()].flat();
+}
+export function getUnboundedVars(term, knownVars) {
+    const accessedVars = new Set();
+    const boundedVars = new Set();
+    if (knownVars instanceof Set) {
+        for (const v of knownVars) {
+            if (typeof v === "symbol")
+                boundedVars.add(v);
         }
-        if (term instanceof IRRecursive) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
+    }
+    const stack = [term];
+    while (stack.length > 0) {
+        const t = stack.pop();
+        if (t instanceof IRVar
+            || t instanceof IRSelfCall) {
+            accessedVars.add(t.name);
             continue;
         }
-        // letted terms do count too
-        if (term instanceof IRLetted) {
-            stack.push({ term: term.value, dbn });
+        if (t instanceof IRFunc
+            || t instanceof IRRecursive) {
+            for (const param of t.params)
+                boundedVars.add(param);
+            stack.push(t.body);
             continue;
         }
-        // closed
-        // if( term instanceof IRHoisted )
+        stack.push(...t.children());
     }
-    return minDbn;
+    for (const v of boundedVars)
+        accessedVars.delete(v);
+    return accessedVars;
 }

package/dist/IR/toUPLC/subRoutines/handleLetted/index.js

@@ -4,23 +4,19 @@ import { getSortedLettedSet, getLettedTerms, IRLetted } from "../../../IRNodes/I
 import { IRVar } from "../../../IRNodes/IRVar.js";
 import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
 import { findAllNoHoisted } from "../../_internal/findAll.js";
-import { getDebruijnInTerm } from "../../_internal/getDebruijnInTerm.js";
-import { _getMinUnboundDbn } from "./groupByScope.js";
+import { getMaxScope } from "./groupByScope.js";
 import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../../IRNodes/IRForced.js";
 import { lowestCommonAncestor } from "../../_internal/lowestCommonAncestor.js";
 import { isIRTerm } from "../../../utils/isIRTerm.js";
 import { markRecursiveHoistsAsForced } from "../markRecursiveHoistsAsForced.js";
 import { IRConst } from "../../../IRNodes/IRConst.js";
-import { incrementUnboundDbns } from "./incrementUnboundDbns.js";
 import { equalIrHash, irHashToHex } from "../../../IRHash.js";
 import { sanifyTree } from "../sanifyTree.js";
-import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
-import { IRCase } from "../../../IRNodes/IRCase.js";
-import { IRConstr } from "../../../IRNodes/IRConstr.js";
 import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
 import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
 import { findHighestRecursiveParent } from "./findHighestRecursiveParent.js";
+import { IRNative } from "../../../IRNodes/IRNative/index.js";
+import { isForcedNativeTag } from "../../../IRNodes/IRNative/isForcedNative.js";
 export function handleLettedAndReturnRoot(term) {
     // console.log(" ------------------------------------------- handleLetted ------------------------------------------- ");
     // console.log( prettyIRText( term ))
@@ -28,52 +24,60 @@ export function handleLettedAndReturnRoot(term) {
     // pre-execuded terms (hence constants)
     if (term instanceof IRConst)
         return term;
+    sanifyTree(term);
     // TODO: should probably merge `markRecursiveHoistsAsForced` inside `getLettedTerms` to iter once
     markRecursiveHoistsAsForced(term);
     // in case there are no letted terms there is no work to do
     while (true) {
+        // console.log(` ------------------ letted loop ------------------ `);
         const allDirectLetted = getLettedTerms(term, { all: false, includeHoisted: false });
         if (allDirectLetted.length === 0)
             return term;
+        // // console.log("allDirectLetted", allDirectLetted.map( expandedJsonLettedSetEntry ) );
         const sortedLettedSet = getSortedLettedSet(allDirectLetted);
+        // console.log("sortedLettedSet", sortedLettedSet.map( expandedJsonLettedSetEntry ) );
+        // `sortedLettedSet` is sorted from least to most dependencies
+        // so we'll have "0 dependencies" letted terms at the start of the array
+        // and "n dependencies" letted terms at the end of the array
+        // 
+        // we process the "most dependent" terms first
+        // so their values are inlined
+        // and later, its dependencies will be replaced with `IRVar`
+        // whereever these dependent are inlined
+        //
+        // hence why `pop` (and not `shift`)
         const { letted, nReferences } = sortedLettedSet.pop();
-        /*
-        const _lettedValue_ = letted.value;
-        const shouldLog = (
-            _lettedValue_ instanceof IRApp &&
-            _lettedValue_.fn instanceof IRFunc &&
-            _lettedValue_.fn.arity === 1 &&
-            _lettedValue_.fn.body instanceof IRLetted &&
-            equalIrHash( _lettedValue_.fn.body.hash, new Uint32Array( fromHex("71030a2d7560e563fe25fd782edd847f").buffer ) as IRHash ) &&
-            _lettedValue_.arg instanceof IRLetted &&
-            equalIrHash( _lettedValue_.arg.hash, new Uint32Array( fromHex("82dfb8a2f2703fe59fb25f8372e5e958").buffer ) as IRHash )
-        );
-        //*/
-        // shouldLog && console.log("nReferences", nReferences);
+        // shouldLog && // console.log("nReferences", nReferences);
         // console.log(` ------------------ working with ${lettedToStr(letted)} ------------------ `);
         if (nReferences === 1) {
             // console.log("inlining letted (single reference) with value", prettyIRText( letted.value ) )
             _modifyChildFromTo(letted.parent, letted, letted.value);
             continue;
         }
-        const maxScope = findLettedMaxScope(letted) ?? (() => {
-            if (letted.meta.isClosed || letted.isClosedAtDbn(0)) {
-                // value is closed (hoisted),
-                // so the max scope is the entire script
-                return term;
-            }
-            else
-                throw new Error(`could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}`);
-        })();
+        // console.log("--------- not inilning ("+ nReferences +" references)");
+        const maxScope = getMaxScope(letted) ?? term;
+        // const maxScope = getMaxScope( letted ) ?? ((): IRTerm => {
+        //     if( letted.meta.isClosed || isClosedTerm( letted.value ) )
+        //     {
+        //         // value is closed (hoisted),
+        //         // so the max scope is the entire script
+        //         return term;
+        //     }
+        //     else throw new Error(
+        //         `could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}`
+        //     );
+        // })();
         const lettedTermCanBeHoisted = maxScope === term;
         const minScope = findHighestRecursiveParent(letted, maxScope);
         sanifyTree(maxScope);
         const lettedHash = letted.hash;
         const sameLettedRefs = findAllNoHoisted(maxScope, node => node instanceof IRLetted &&
             equalIrHash(node.hash, lettedHash));
+        // console.log("sameLettedRefs", sameLettedRefs.length );
         if (sameLettedRefs.length <= 0) {
-            console.warn("how did you get here? 0 references found for letted term;\n\n" +
-                "!!! PLEASE OPEN AN ISSUE ON GITHUB (https://github.com/HarmonicLabs/plu-ts/issues) !!!\n\n");
+            console.warn("how did you get here? 0 references found for letted term;\n" +
+                "the compiler can easly recover this edge case, but something funny is going on with this contract.\n\n" +
+                "!!! PLEASE OPEN AN ISSUE ON GITHUB (https://github.com/HarmonicLabs/plu-ts/issues) !!!\n");
             continue;
         }
         // just in case
@@ -83,8 +87,10 @@ export function handleLettedAndReturnRoot(term) {
             continue;
         }
         // always inline letted vars
-        if (letted.value instanceof IRVar ||
-            letted.value instanceof IRSelfCall) {
+        if (letted.value instanceof IRVar
+            || letted.value instanceof IRSelfCall
+            || (letted.value instanceof IRNative
+                && !isForcedNativeTag(letted.value.tag))) {
             // console.log("inlining letted (value is var) with value", prettyIRText( letted.value ) )
             for (const elem of sameLettedRefs) {
                 // inline
@@ -126,25 +132,16 @@ export function handleLettedAndReturnRoot(term) {
         const parentNode = lca;
         const parentNodeDirectChild = (parentNode instanceof IRFunc ||
             parentNode instanceof IRRecursive) ? parentNode.body : parentNode.delayed;
-        // add 1 to every var's DeBruijn that accesses stuff outside the parent node
-        // not including the `parentNode` node
-        // since the new function introdcued substituting the letted term
-        // is added inside the `parentNode` node
-        incrementUnboundDbns(parentNodeDirectChild, 
-        // `shouldNotModifyLetted` arg (given the hash returns `true` if it should NOT modify the term)
-        // this callback is ONLY called on LETTED terms
-        ({ hash }) => equalIrHash(hash, lettedHash));
         // now we replace
         const lettedValue = letted.value.clone();
-        modifyValueToLetDbns(lettedValue, getDiffDbn(letted, parentNode));
-        const newNode = new IRApp(new IRFunc(1, parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
+        const newNode = new IRApp(new IRFunc([letted.name], parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
         // replace child with new node
         if (parentNode instanceof IRFunc || parentNode instanceof IRRecursive)
             parentNode.body = newNode;
         else
             parentNode.delayed = newNode;
         for (const ref of sameLettedRefs) {
-            _modifyChildFromTo(ref.parent, ref, new IRVar(getDebruijnInTerm(parentNodeDirectChild, ref)));
+            _modifyChildFromTo(ref.parent, ref, new IRVar(ref.name));
         }
         // const delayed = parentNode instanceof IRDelayed;
         // let finalMaxScope: IRFunc | IRDelayed = parentNode;
@@ -155,141 +152,18 @@ export function handleLettedAndReturnRoot(term) {
         // {
         //     finalMaxScope = (finalMaxScope as any).parent as any
         // }
-        // console.log("final max scope (delayed: " + delayed + ")" , prettyIRText( finalMaxScope ) )
-    }
-}
-/**
- *
- * @param letted
- * @returns {IRFunc} the lowest `IRFunc` in the tree that defines all the variables needed for the
- */
-function findLettedMaxScope(letted) {
-    let minUnboundDbn = _getMinUnboundDbn(letted.value);
-    if (minUnboundDbn === undefined) {
-        let tmp = letted;
-        let maxScope = undefined;
-        while (tmp.parent) {
-            tmp = tmp.parent;
-            if (tmp instanceof IRFunc || tmp instanceof IRDelayed)
-                maxScope = tmp;
-        }
-        ;
-        return maxScope;
-    }
-    let tmp = letted;
-    let maxScope = undefined;
-    while (minUnboundDbn >= 0) {
-        if (!tmp.parent) {
-            throw new Error(`could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}; ` +
-                `the max parent found leaves the term open (reached root)`);
-        }
-        tmp = tmp.parent;
-        if (tmp instanceof IRRecursive) {
-            minUnboundDbn -= tmp.arity;
-            // maxScope = tmp; // recursive cannot be a max scope
-        }
-        else if (tmp instanceof IRFunc) {
-            minUnboundDbn -= tmp.arity;
-            maxScope = tmp;
-        }
-    }
-    // just ts sillyness here
-    if (!maxScope) {
-        throw new Error(`could not find a max scope for letted value with hash ${irHashToHex(letted.hash)}; ` +
-            `no IRFunc found`);
-    }
-    return maxScope;
-}
-function modifyValueToLetDbns(lettedValue, diffDbn) {
-    if (diffDbn <= 0)
-        return;
-    // if there is any actual difference between the letted term
-    // and the position where it will be finally placed
-    // the value needs to be modified accoridingly
-    const stack = [{ term: lettedValue, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term: t, dbn } = stack.pop();
-        if ((t instanceof IRVar ||
-            t instanceof IRSelfCall) &&
-            t.dbn > dbn) {
-            t.dbn -= diffDbn;
-        }
-        if (t instanceof IRLetted) {
-            t.dbn -= diffDbn;
-            // reduce dbn in letted value too
-            stack.push({ term: t.value, dbn });
-            continue;
-        }
-        if (t instanceof IRApp) {
-            stack.push({ term: t.arg, dbn }, { term: t.fn, dbn });
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push({ term: t.constrTerm, dbn }, ...mapArrayLike(t.continuations, continuation => ({ term: continuation, dbn })));
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...mapArrayLike(t.fields, field => ({ term: field, dbn })));
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push({ term: t.delayed, dbn });
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push({ term: t.forced, dbn });
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        // no hoisted
-    }
-}
-/**
- * @returns the difference in DeBruijn
- * between the maxScope and the letted term
- */
-function getDiffDbn(letted, parentNode) {
-    // get the difference in DeBruijn
-    // between the maxScope and the letted term
-    let diffDbn = 0;
-    //*
-    let tmpNode = letted;
-    while (tmpNode !== parentNode) {
-        tmpNode = tmpNode.parent;
-        if ( // is an intermediate `IRFunc`
-        (tmpNode instanceof IRFunc ||
-            tmpNode instanceof IRRecursive) &&
-            tmpNode !== parentNode // avoid counting parent node arity if IRFunc 
-        ) {
-            // increment differential in DeBruijn by n vars indroduced here
-            diffDbn += tmpNode.arity;
-        }
+        // // // console.log("final max scope (delayed: " + delayed + ")" , prettyIRText( finalMaxScope ) )
     }
-    return diffDbn;
 }
 function handleLettedAsHoistedAndReturnRoot(letted, lca, sameLettedRefs, currentRoot) {
     const lettedHash = letted.hash;
     let parentNode = lca.parent;
     const parentNodeDirectChild = lca;
-    // add 1 to every var's DeBruijn that accesses stuff outside the parent node
-    // not including the `parentNode` node
-    // since the new function introdcued substituting the letted term
-    // is added inside the `parentNode` node
-    incrementUnboundDbns(parentNodeDirectChild, 
-    // `shouldNotModifyLetted` arg (given the hash returns `true` if it should NOT modify the term)
-    ({ hash }) => equalIrHash(hash, lettedHash));
     // now we replace
     const lettedValue = letted.value; //.clone();
     // no need to modify letted value dbns, since closed
     // modifyValueToLetDbns( lettedValue, getDiffDbn( letted, parentNode ) );
-    const newNode = new IRApp(new IRFunc(1, parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
+    const newNode = new IRApp(new IRFunc([letted.name], parentNodeDirectChild), lettedValue, { __src__: letted.meta.__src__ });
     // replace child with new node
     if (parentNode) {
         _modifyChildFromTo(parentNode, parentNodeDirectChild, newNode);
@@ -298,7 +172,7 @@ function handleLettedAsHoistedAndReturnRoot(letted, lca, sameLettedRefs, current
         currentRoot = newNode;
     }
     for (const ref of sameLettedRefs) {
-        _modifyChildFromTo(ref.parent, ref, new IRVar(getDebruijnInTerm(parentNodeDirectChild, ref)));
+        _modifyChildFromTo(ref.parent, ref, new IRVar(ref.name));
     }
     return currentRoot;
 }

package/dist/IR/toUPLC/subRoutines/handleRecursiveTerms.js

@@ -9,12 +9,14 @@ import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
 export function handleRecursiveTerms(term) {
     if (term instanceof IRRecursive) {
         const bodyPtr = term.body;
-        _modifyChildFromTo(term.parent, term, new IRApp(new IRHoisted(new IRFunc(1, new IRApp(new IRVar(0), new IRVar(0)))), new IRFunc(1, bodyPtr)));
+        const recBody = Symbol("recBody");
+        const self = term.name;
+        _modifyChildFromTo(term.parent, term, new IRApp(new IRHoisted(new IRFunc([recBody], new IRApp(new IRVar(recBody), new IRVar(recBody)))), new IRFunc([self], bodyPtr)));
         handleRecursiveTerms(bodyPtr);
         return;
     }
     if (term instanceof IRSelfCall) {
-        _modifyChildFromTo(term.parent, term, new IRApp(new IRVar(term.dbn), new IRVar(term.dbn)));
+        _modifyChildFromTo(term.parent, term, new IRApp(new IRVar(term.name), new IRVar(term.name)));
         return;
     }
     getChildren(term).forEach(handleRecursiveTerms);
@@ -22,7 +24,9 @@ export function handleRecursiveTerms(term) {
 export function handleRootRecursiveTerm(term) {
     if (term instanceof IRRecursive) {
         const bodyPtr = term.body;
-        const newRoot = new IRApp(new IRHoisted(new IRFunc(1, new IRApp(new IRVar(0), new IRVar(0)))), new IRFunc(1, bodyPtr));
+        const recBody = Symbol("recBody");
+        const self = term.name;
+        const newRoot = new IRApp(new IRHoisted(new IRFunc([recBody], new IRApp(new IRVar(recBody), new IRVar(recBody)))), new IRFunc([self], bodyPtr));
         handleRecursiveTerms(bodyPtr);
         return newRoot;
     }

package/dist/IR/toUPLC/subRoutines/hoistForcedNatives.js

@@ -38,10 +38,11 @@ export function hoistForcedNatives(term) {
         const nodes = toHoist[tag];
         if (nodes.length <= 0)
             continue; // also single use (might be inside loop)
+        const varSym = Symbol(tagStr);
         for (const node of nodes) {
-            _modifyChildFromTo(node.parent, node, new IRVar(getDbnToRoot(node)));
+            _modifyChildFromTo(node.parent, node, new IRVar(varSym));
         }
-        term = new IRApp(new IRFunc(1, term), new IRNative(tag));
+        term = new IRApp(new IRFunc([varSym], term), new IRNative(tag));
     }
     return term;
 }

package/dist/IR/toUPLC/subRoutines/inlineSingleUseAndReturnRoot/InlineSingleUseCtx.d.ts

@@ -0,0 +1,22 @@
+export declare enum InlineSingleUseVarsFlags {
+    none = 0,
+    isRecursiveFunction = 1
+}
+interface InlineSingleUseCtxMeta {
+    readonly isRecursiveContext: boolean;
+}
+export declare class InlineSingleUseCtx {
+    readonly params: symbol[];
+    readonly parent: InlineSingleUseCtx | undefined;
+    readonly localVarsUses: Record<symbol, number>;
+    readonly localVarsFlags: Record<symbol, InlineSingleUseVarsFlags>;
+    readonly meta: InlineSingleUseCtxMeta;
+    constructor(params: symbol[], parent: InlineSingleUseCtx | undefined, meta: InlineSingleUseCtxMeta);
+    static root(params?: symbol[]): InlineSingleUseCtx;
+    newChild(params: symbol[], meta?: InlineSingleUseCtxMeta): InlineSingleUseCtx;
+    private keys;
+    private getIncrement;
+    incrementVarUse(sym: symbol): void;
+    getSingleUseVars(): symbol[];
+}
+export {};

package/dist/IR/toUPLC/subRoutines/inlineSingleUseAndReturnRoot/InlineSingleUseCtx.js

@@ -0,0 +1,59 @@
+export var InlineSingleUseVarsFlags;
+(function (InlineSingleUseVarsFlags) {
+    InlineSingleUseVarsFlags[InlineSingleUseVarsFlags["none"] = 0] = "none";
+    InlineSingleUseVarsFlags[InlineSingleUseVarsFlags["isRecursiveFunction"] = 1] = "isRecursiveFunction";
+})(InlineSingleUseVarsFlags || (InlineSingleUseVarsFlags = {}));
+const defaultInlineMeta = Object.freeze({
+    isRecursiveContext: false
+});
+export class InlineSingleUseCtx {
+    params;
+    parent;
+    localVarsUses;
+    localVarsFlags;
+    meta;
+    constructor(params, parent, meta) {
+        this.params = params;
+        this.parent = parent;
+        params = params.slice();
+        this.localVarsUses = {};
+        this.localVarsFlags = {};
+        for (const p of params) {
+            this.localVarsUses[p] = 0;
+            this.localVarsFlags[p] = InlineSingleUseVarsFlags.none;
+        }
+        meta = {
+            ...meta,
+            isRecursiveContext: parent?.meta.isRecursiveContext ?? defaultInlineMeta.isRecursiveContext
+        };
+        this.meta = meta;
+    }
+    static root(params = []) {
+        return new InlineSingleUseCtx(params, undefined, defaultInlineMeta);
+    }
+    newChild(params, meta = defaultInlineMeta) {
+        return new InlineSingleUseCtx(params, this, meta);
+    }
+    keys() {
+        return Object.getOwnPropertySymbols(this.localVarsUses);
+    }
+    getIncrement() {
+        return this.meta.isRecursiveContext ? 10 : 1;
+    }
+    incrementVarUse(sym) {
+        if (typeof this.localVarsUses[sym] !== "number") {
+            if (this.parent)
+                this.parent.incrementVarUse(sym);
+            else {
+                console.error(sym);
+                throw new Error("trying to increment use of variable not in context");
+            }
+        }
+        else
+            this.localVarsUses[sym] += this.getIncrement();
+    }
+    getSingleUseVars() {
+        const keys = this.keys();
+        return keys.filter(k => this.localVarsUses[k] === 1);
+    }
+}