@harmoniclabs/pebble 0.1.0-dev0

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

@@ -0,0 +1,161 @@
+import { IRApp } from "../../../IRNodes/IRApp.js";
+import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
+import { IRForced } from "../../../IRNodes/IRForced.js";
+import { IRFunc } from "../../../IRNodes/IRFunc.js";
+import { getSortedHoistedSet, getHoistedTerms, IRHoisted } from "../../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../../IRNodes/IRLetted.js";
+import { IRVar } from "../../../IRNodes/IRVar.js";
+import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { showIR } from "../../../utils/showIR.js";
+import { markRecursiveHoistsAsForced } from "../markRecursiveHoistsAsForced.js";
+import { equalIrHash, irHashToHex } from "../../../IRHash.js";
+import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
+import { IRCase } from "../../../IRNodes/IRCase.js";
+import { IRConstr } from "../../../IRNodes/IRConstr.js";
+import { stringify } from "../../../../utils/stringify.js";
+import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
+export function handleHoistedAndReturnRoot(term) {
+    // unwrap;
+    // if( term instanceof IRHoisted )
+    while (term instanceof IRHoisted) {
+        // we know `handleHoistedAndReturnRoot` modifies the term
+        // so we are probably ok not cloning here
+        // top level hoisted terms should be handled in `compileIRToUPLC` anyway
+        term = term.hoisted;
+        // we still need to remove this parent otherhwise there will be an unknown hoisted to handle
+        term.parent = undefined;
+        // return handleHoistedAndReturnRoot(
+        //     theTerm
+        // );
+    }
+    // TODO: should probably merge `markRecursiveHoistsAsForced` inside `getHoistedTerms` to iter once
+    markRecursiveHoistsAsForced(term);
+    const directHoisteds = getHoistedTerms(term);
+    const allHoisteds = getSortedHoistedSet(directHoisteds);
+    let n = allHoisteds.length;
+    // evaluating constants
+    if (n === 0) {
+        return term;
+    }
+    // nothing to do; shortcut.
+    if (n === 0)
+        return term;
+    let a = 0;
+    let b = 0;
+    const toHoist = new Array(n);
+    const toInline = new Array(n);
+    // filter out hoisted terms with single reference
+    for (let i = 0; i < n; i++) {
+        const thisHoistedEntry = allHoisteds[i];
+        if (thisHoistedEntry.hoisted.meta.forceHoist === true) {
+            toHoist[a++] = thisHoistedEntry.hoisted;
+            continue;
+        }
+        if (thisHoistedEntry.nReferences === 1 &&
+            thisHoistedEntry.hoisted.parent) {
+            // inline hoisted with single reference
+            toInline[b++] = thisHoistedEntry.hoisted;
+        }
+        else
+            toHoist[a++] = thisHoistedEntry.hoisted;
+    }
+    // drop unused space
+    toHoist.length = a;
+    toInline.length = b;
+    const hoistedsToInlineHashes = toInline.map(h => h.hash);
+    // console.log( "toHoist", toHoist.map( h => ({ ...showIR( h.hoisted ), hash: toHex( h.hash ) }) ) );
+    // console.log( "toInline", toInline.map( h => ({ ...showIR( h.hoisted ), hash: toHex( h.hash ) }) ) );
+    let root = term;
+    while (root.parent !== undefined)
+        root = root.parent;
+    function getIRVarForHoistedAtLevel(_hoistedHash, level) {
+        let levelOfTerm = toHoist.findIndex(sortedH => equalIrHash(sortedH.hash, _hoistedHash));
+        if (levelOfTerm < 0) {
+            throw new Error(`missing hoisted with hash ${irHashToHex(_hoistedHash)} between toHoist [\n\t${toHoist.map(h => irHashToHex(h.hash))
+                .join(",\n\t")}\n]; can't replace with IRVar`);
+        }
+        return new IRVar(level - (levelOfTerm + 1));
+    }
+    // adds the actual terms
+    // from last to first
+    for (let i = toHoist.length - 1; i >= 0; i--) {
+        const thisHoisted = toHoist[i];
+        root = new IRApp(new IRFunc(1, root), thisHoisted.hoisted.clone());
+    }
+    // replace hoisted references with variables
+    const stack = [{ irTerm: root, dbn: 0 }];
+    while (stack.length > 0) {
+        const { irTerm, dbn } = stack.pop();
+        const irTermHash = irTerm.hash;
+        const isHoistedToinline = hoistedsToInlineHashes.some(h => equalIrHash(h, irTermHash));
+        if (
+        // is hoiseted
+        irTerm instanceof IRHoisted &&
+            // is not one to be inlined
+            !isHoistedToinline) {
+            const irvar = getIRVarForHoistedAtLevel(irTermHash, dbn);
+            if (irvar.dbn >= dbn) {
+                throw new Error(`out of bound hoisted term; hash: ${irHashToHex(irTerm.hash)}; var's DeBruijn: ${irvar.dbn} (starts from 0); tot hoisted in scope: ${dbn}`);
+            }
+            // console.log(
+            //     showIRText( irTerm.parent as IRTerm ),
+            //     "\n\n",
+            //     showIRText( irTerm ),
+            // )
+            _modifyChildFromTo(irTerm.parent, irTerm, irvar);
+            Object.defineProperty(irTerm.meta, "handled", {
+                value: true,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            // don't push anything
+            // because we just replaced with a variable
+            // so we know there's not a tree to explore
+            continue;
+        }
+        else if (irTerm instanceof IRHoisted) {
+            if (!isHoistedToinline) {
+                throw new Error("unexpected hoisted term found with hash: " + irHashToHex(irTermHash) +
+                    "\n showIR of the term: " + stringify(showIR(irTerm), undefined, 2));
+            }
+            const toInline = irTerm.hoisted;
+            _modifyChildFromTo(irTerm.parent, irTerm, toInline);
+            stack.push({ irTerm: toInline, dbn });
+            continue;
+        }
+        if (irTerm instanceof IRApp) {
+            stack.push({ irTerm: irTerm.fn, dbn }, { irTerm: irTerm.arg, dbn });
+            continue;
+        }
+        if (irTerm instanceof IRCase) {
+            stack.push({ irTerm: irTerm.constrTerm, dbn }, ...mapArrayLike(irTerm.continuations, (continuation) => ({ irTerm: continuation, dbn })));
+            continue;
+        }
+        if (irTerm instanceof IRConstr) {
+            stack.push(...mapArrayLike(irTerm.fields, (field) => ({ irTerm: field, dbn })));
+            continue;
+        }
+        if (irTerm instanceof IRDelayed) {
+            stack.push({ irTerm: irTerm.delayed, dbn });
+            continue;
+        }
+        if (irTerm instanceof IRForced) {
+            stack.push({ irTerm: irTerm.forced, dbn });
+            continue;
+        }
+        if (irTerm instanceof IRFunc) {
+            stack.push({ irTerm: irTerm.body, dbn: dbn + irTerm.arity });
+            continue;
+        }
+        if (irTerm instanceof IRRecursive) {
+            stack.push({ irTerm: irTerm.body, dbn: dbn + irTerm.arity });
+            continue;
+        }
+        if (irTerm instanceof IRLetted) {
+            stack.push({ irTerm: irTerm.value, dbn });
+            continue;
+        }
+    }
+    return root;
+}

package/dist/IR/toUPLC/subRoutines/handleLetted/findHighestRecursiveParent.d.ts

@@ -0,0 +1,5 @@
+import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
+import { IRTerm } from "../../../IRTerm.js";
+import { IRApp } from "../../../IRNodes/index.js";
+export type RecursiveIRNode = IRRecursive | IRApp;
+export declare function findHighestRecursiveParent(term: IRTerm, maxScope: IRTerm): RecursiveIRNode | undefined;

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

@@ -0,0 +1,14 @@
+import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
+export function findHighestRecursiveParent(term, maxScope) {
+    let highest = undefined;
+    while (term.parent !== maxScope &&
+        term.parent !== undefined) {
+        if (isRecursiveNode(term))
+            highest = term;
+        term = term.parent;
+    }
+    return highest;
+}
+function isRecursiveNode(term) {
+    return (term instanceof IRRecursive);
+}

package/dist/IR/toUPLC/subRoutines/handleLetted/groupByScope.d.ts

@@ -0,0 +1,20 @@
+import { IRFunc } from "../../../IRNodes/IRFunc.js";
+import { LettedSetEntry } from "../../../IRNodes/IRLetted.js";
+import { IRTerm } from "../../../IRTerm.js";
+type ScopedLettedTerms = {
+    maxScope: IRFunc | undefined;
+    group: LettedSetEntry[];
+};
+export declare function groupByScope(letteds: LettedSetEntry[]): ScopedLettedTerms[];
+/**
+ *
+ * @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 declare function _getMinUnboundDbn(_term: IRTerm): number | undefined;
+export {};

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

@@ -0,0 +1,107 @@
+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) {
+        const scopeEntry = scopes.find(entry => entry.maxScope === scope);
+        if (scopeEntry === undefined) {
+            scopes.push({
+                maxScope: scope,
+                group: [letted]
+            });
+            return;
+        }
+        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;
+            }
+        }
+        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);
+            }
+        }
+        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 });
+            continue;
+        }
+        if (term instanceof IRForced) {
+            stack.push({ term: term.forced, dbn });
+            continue;
+        }
+        if (term instanceof IRFunc) {
+            stack.push({ term: term.body, dbn: dbn + term.arity });
+            continue;
+        }
+        if (term instanceof IRRecursive) {
+            stack.push({ term: term.body, dbn: dbn + term.arity });
+            continue;
+        }
+        // letted terms do count too
+        if (term instanceof IRLetted) {
+            stack.push({ term: term.value, dbn });
+            continue;
+        }
+        // closed
+        // if( term instanceof IRHoisted )
+    }
+    return minDbn;
+}

package/dist/IR/toUPLC/subRoutines/handleLetted/incrementUnboundDbns.d.ts

@@ -0,0 +1,9 @@
+import { IRTerm } from "../../../IRTerm.js";
+import { IRLetted } from "../../../IRNodes/IRLetted.js";
+/**
+ *  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
+**/
+export declare function incrementUnboundDbns(theTerm: IRTerm, shouldNotModifyLetted: (letted: IRLetted, dbn: number) => boolean): void;

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

@@ -0,0 +1,73 @@
+import { IRVar } from "../../../IRNodes/IRVar.js";
+import { IRLetted } from "../../../IRNodes/IRLetted.js";
+import { IRApp } from "../../../IRNodes/IRApp.js";
+import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
+import { IRForced } from "../../../IRNodes/IRForced.js";
+import { IRFunc } from "../../../IRNodes/IRFunc.js";
+import { IRCase } from "../../../IRNodes/IRCase.js";
+import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
+import { IRConstr } from "../../../IRNodes/IRConstr.js";
+import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
+/**
+ *  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
+**/
+export function incrementUnboundDbns(theTerm, shouldNotModifyLetted) {
+    const stack = [{ term: theTerm, dbn: 0 }];
+    while (stack.length > 0) {
+        const { term: t, dbn } = stack.pop();
+        if ((t instanceof IRVar ||
+            t instanceof IRSelfCall) &&
+            t.dbn >= dbn) {
+            // there's a new variable in scope
+            t.dbn++;
+            continue;
+        }
+        if (t instanceof IRLetted) {
+            if (shouldNotModifyLetted(t, dbn)) {
+                // don't modify letted to be hoisted
+                continue;
+            }
+            else // other letted to be handled in one of the next cycles
+             {
+                // `IRLambdas` DeBruijn are tracking the level of instantiation
+                // we add a new variable so the dbn of instantiation increments
+                t.dbn += 1;
+                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;
+        }
+        // skip hoisted since closed
+    }
+}

package/dist/IR/toUPLC/subRoutines/handleLetted/index.d.ts

@@ -0,0 +1,2 @@
+import { IRTerm } from "../../../IRTerm.js";
+export declare function handleLettedAndReturnRoot(term: IRTerm): IRTerm;