@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

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

@@ -0,0 +1,227 @@
+import { IRConstr, IRNative } from "../../../IRNodes/index.js";
+import { IRApp } from "../../../IRNodes/IRApp.js";
+import { IRCase } from "../../../IRNodes/IRCase.js";
+import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
+import { IRForced } from "../../../IRNodes/IRForced.js";
+import { IRFunc } from "../../../IRNodes/IRFunc.js";
+import { IRHoisted } from "../../../IRNodes/IRHoisted.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 { dependsByDbns } from "../../../IRNodes/utils/dependsByDbns.js";
+import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
+import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { isDebugUplcOptimizations } from "../../CompilerOptions.js";
+import { expandFuncsAndReturnRoot, getExpandedIRFunc } from "./expandFuncsAndReturnRoot.js";
+export function performUplcOptimizationsAndReturnRoot(root, options) {
+    const opts = options.uplcOptimizations;
+    if (isDebugUplcOptimizations(opts))
+        return root;
+    const { groupApplications, inlineSingleUse, simplifyWrappedPartialFuncApps, removeForceDelay } = opts;
+    root = expandFuncsAndReturnRoot(root);
+    const stack = [[root, 0]];
+    while (stack.length > 0) {
+        let [t, dbn] = stack.pop();
+        if (t instanceof IRApp) {
+            if (isIdLike(t.fn)) {
+                if (t.parent)
+                    _modifyChildFromTo(t.parent, t, t.arg);
+                else
+                    root = t.arg;
+                stack.push([t.arg, dbn]);
+                continue;
+            }
+            if (!groupApplications) {
+                stack.push([t.fn, dbn], [t.arg, dbn]);
+                continue;
+            }
+            let args;
+            let body;
+            /*
+            // can't figure how to make it work
+            [ args, body ] = groupIndipendentLets( t, dbn );
+
+            if( args.length >= 2 )
+            {
+                let newNode = body;
+                for( let i = args.length - 1; i >= 0; i-- )
+                {
+                    // apply as normal apps, not case/constr
+                    // so we can further group if the body is directly applications
+                    newNode = new IRApp( newNode, args[i] );
+                }
+
+                // overwrite original
+                if( t.parent ) _modifyChildFromTo( t.parent, t, newNode );
+                else root = newNode;
+
+                // reanalyze this new node to group using case/constr
+                stack.push([ newNode, dbn ]);
+                continue;
+            }
+            //*/
+            [args, body] = getMultiAppArgsAndBody(t);
+            if (args.length <= 2) {
+                stack.push([t.fn, dbn], [t.arg, dbn]);
+                continue;
+            }
+            const newNode = new IRCase(new IRConstr(0, args), [body]);
+            stack.push([body, dbn]);
+            if (t.parent)
+                _modifyChildFromTo(t.parent, t, newNode);
+            else
+                root = newNode;
+            continue;
+        }
+        if (t instanceof IRCase) {
+            stack.push([t.constrTerm, dbn], ...mapArrayLike(t.continuations, (c) => [c, dbn]));
+            continue;
+        }
+        if (t instanceof IRConstr) {
+            // stack.push( ...t.fields );
+            stack.push(...mapArrayLike(t.fields, (f) => [f, dbn]));
+            continue;
+        }
+        if (t instanceof IRDelayed) {
+            stack.push([t.delayed, dbn]);
+            continue;
+        }
+        if (t instanceof IRForced) {
+            stack.push([t.forced, dbn]);
+            continue;
+        }
+        if (t instanceof IRFunc) {
+            stack.push([t.body, dbn + t.arity]);
+            continue;
+        }
+        if (t instanceof IRRecursive ||
+            t instanceof IRHoisted ||
+            t instanceof IRLetted ||
+            t instanceof IRSelfCall) {
+            throw new Error("Unexpected term while performing uplc optimizations");
+        }
+    }
+    return root;
+}
+function isAppLike(term) {
+    return (term instanceof IRApp ||
+        isCaseConstrApp(term));
+}
+/** @experimental still can't figure how to make it work */
+export function groupIndipendentLets(term, dbn) {
+    let args = [];
+    let body = term;
+    //*
+    const lettedDbns = [];
+    while (term instanceof IRApp &&
+        term.fn instanceof IRFunc &&
+        term.fn.arity === 1) {
+        // letted terms
+        // [(lam a [(lam b [(lam c ... ))) c] b] a] :: []
+        // [(lam b [(lam c ... ))) c] b] :: [a]
+        // [(lam c ... ) c] :: [a, b]
+        // ... :: [a, b, c]
+        // finally expand:
+        // (lam a (lam b (lam c ... ))) :: [a, b, c]
+        // console.log({
+        //     arg: prettyIRInline( term.arg ),
+        //     lettedDbns,
+        //     depends: dependsByDbns( term.arg, lettedDbns ),
+        //     currArgsLen: args.length
+        // });
+        if (!dependsByDbns(term.arg, lettedDbns)) {
+            args.push(term.arg);
+            term = term.fn.body;
+            // push current dbn
+            // and increment later
+            lettedDbns.push(dbn++);
+            body = term;
+            continue;
+        }
+        else {
+            term = term.fn.body;
+            break;
+        }
+        continue;
+    }
+    return [
+        args,
+        getExpandedIRFunc(body, args.length)
+    ];
+    //*/
+}
+function getMultiAppArgsAndBody(term) {
+    let args = [];
+    let body = term;
+    // else we look for consecutive applications or cases
+    while (term instanceof IRApp) {
+        /*
+        consecutive applications look like:
+        [
+            [
+                [
+                    (lam a (lam b (lam c ... )))
+                a]
+            b]
+        c]
+        but the equivalent IRCase looks like:
+        (case
+            (constr 0 a b c)
+            (lam a (lam b (lam c ... )))
+        )
+        so we need to reverse the order of the args
+        since we start from the outermost application
+        (in order, we encounter from the top: c => b => a)
+        */
+        args.unshift(term.arg);
+        term = term.fn;
+        // arity++;
+        body = term;
+    }
+    ;
+    return [args, body];
+    // if( args.length === 0 ) return [ args, body ];
+    // const [ nextArgs, nextBody ] = getMultiAppArgsAndBody( body, dbn );
+    // return [ args.concat( nextArgs ), nextBody ];
+}
+function isCaseConstrApp(term) {
+    return (term instanceof IRCase &&
+        term.continuations.length === 1 &&
+        term.constrTerm instanceof IRCase);
+}
+function isIdLike(term) {
+    return (term instanceof IRFunc &&
+        term.arity === 1 &&
+        term.body instanceof IRVar &&
+        Number(term.body.dbn) === 0);
+}
+function getArityOfTerm(term) {
+    let arity = 0;
+    while (term instanceof IRApp ||
+        term instanceof IRFunc ||
+        term instanceof IRNative ||
+        term instanceof IRVar ||
+        term instanceof IRForced ||
+        term instanceof IRDelayed) {
+        if (term instanceof IRForced) {
+            term = term.forced;
+            continue;
+        }
+        if (term instanceof IRDelayed) {
+            term = term.delayed;
+            continue;
+        }
+        if (term instanceof IRApp) {
+            arity--;
+            term = term.fn;
+            continue;
+        }
+        if (term instanceof IRFunc) {
+            arity += term.arity;
+            term = term.body;
+            continue;
+        }
+    }
+    return arity;
+}

package/dist/IR/toUPLC/subRoutines/replaceClosedLettedWithHoisted.d.ts

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

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

@@ -0,0 +1,13 @@
+import { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../IRNodes/IRLetted.js";
+import { isClosedIRTerm } from "../../utils/isClosedIRTerm.js";
+import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
+import { iterTree } from "../_internal/iterTree.js";
+export function replaceClosedLettedWithHoisted(root) {
+    iterTree(root, (node) => {
+        if (node instanceof IRLetted && isClosedIRTerm(node.value)) {
+            _modifyChildFromTo(node.parent, node, new IRHoisted(node.value, node.meta));
+            return true;
+        }
+    });
+}

package/dist/IR/toUPLC/subRoutines/replaceForcedNativesWithHoisted.d.ts

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

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

@@ -0,0 +1,11 @@
+import { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { isForcedNative } from "../../IRNodes/IRNative/isForcedNative.js";
+import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
+import { iterTree } from "../_internal/iterTree.js";
+export function replaceForcedNativesWithHoisted(term) {
+    iterTree(term, (node, _dbn) => {
+        if (isForcedNative(node)) {
+            _modifyChildFromTo(node.parent, node, new IRHoisted(node));
+        }
+    });
+}

package/dist/IR/toUPLC/subRoutines/replaceHoistedWithLetted.d.ts

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

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

@@ -0,0 +1,16 @@
+import { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../IRNodes/IRLetted.js";
+import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
+import { findAll } from "../_internal/findAll.js";
+export function replaceHoistedWithLetted(term) {
+    const allHoisted = findAll(term, node => node instanceof IRHoisted);
+    for (const hoisted of allHoisted) {
+        const parent = hoisted.parent;
+        const letted = new IRLetted(0x0fffffff, // doesn't matter since closed term
+        hoisted.hoisted, { isClosed: true });
+        letted.hash; // precompute
+        // replace hoisted with letted
+        _modifyChildFromTo(parent, hoisted, letted);
+    }
+    // sanifyTree( term );
+}

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

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

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

@@ -0,0 +1,16 @@
+import { IRNative } from "../../../IRNodes/IRNative/index.js";
+import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { iterTree } from "../../_internal/iterTree.js";
+import { nativeToIR } from "./nativeToIR.js";
+export function replaceNativesAndReturnRoot(tree) {
+    if (tree instanceof IRNative) {
+        return nativeToIR(tree);
+    }
+    iterTree(tree, elem => {
+        if (elem instanceof IRNative && elem.tag < 0) {
+            _modifyChildFromTo(elem.parent, elem, nativeToIR(elem));
+            return true;
+        }
+    });
+    return tree;
+}

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.d.ts

@@ -0,0 +1,3 @@
+import { IRNative } from "../../../IRNodes/IRNative/index.js";
+import { IRTerm } from "../../../IRTerm.js";
+export declare function nativeToIR(native: IRNative): IRTerm;