@harmoniclabs/pebble 0.1.0-dev4 → 0.1.0-dev6

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

@@ -1,36 +1,33 @@
 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 { IRHoisted } from "../../IRNodes/IRHoisted.js";
 import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
 export function markRecursiveHoistsAsForced(_term) {
     const stack = [{ term: _term, isInRecursiveTerm: false }];
     while (stack.length > 0) {
         const { term: t, isInRecursiveTerm, isIRAppArg } = stack.pop();
+        if (isInRecursiveTerm && (t instanceof IRHoisted
+            || t instanceof IRLetted)) {
+            t.meta.forceHoist = true;
+            // don't push anything to the stack
+            // hoisted values are handled normally
+            continue;
+        }
         if (t instanceof IRApp) {
-            // must push the arg first and then the fucntion
-            // so that we can check if the function is the Z combinator before the arg is processed
-            stack.push({ term: t.arg, isIRAppArg: true, isInRecursiveTerm }, { term: t.fn, isInRecursiveTerm });
+            stack.push({ term: t.fn, isInRecursiveTerm }, { term: t.arg, isIRAppArg: true, isInRecursiveTerm });
             continue;
         }
         if (t instanceof IRConstr) {
-            // must push the arg first and then the fucntion
-            // so that we can check if the function is the Z combinator before the arg is processed
             stack.push(...Array.from(t.fields)
-                .map((f, i) => ({
+                .map(f => ({
                 term: f,
-                isIRAppArg: i > 0,
+                isIRAppArg: true,
                 isInRecursiveTerm
             })));
             continue;
         }
         if (t instanceof IRCase) {
-            // must push the arg first and then the fucntion
-            // so that we can check if the function is the Z combinator before the arg is processed
             stack.push({
                 term: t.constrTerm,
                 isIRAppArg: false,
@@ -38,45 +35,11 @@ export function markRecursiveHoistsAsForced(_term) {
             }, ...Array.from(t.continuations)
                 .map(cont => ({
                 term: cont,
-                isIRAppArg: true,
+                isIRAppArg: false,
                 isInRecursiveTerm
             })));
             continue;
         }
-        if (t instanceof IRHoisted ||
-            t instanceof IRLetted) {
-            if (isInRecursiveTerm) {
-                t.meta.forceHoist = true;
-                // don't push anything to the stack
-                // hoisted values are handled normally
-                continue;
-            }
-            // otherwhise check in values too
-            else if (t instanceof IRLetted) {
-                stack.push({ term: t.value, isInRecursiveTerm });
-                continue;
-            }
-            else if (t instanceof IRHoisted) {
-                stack.push({ term: t.hoisted, isInRecursiveTerm });
-                continue;
-            }
-        }
-        if (t instanceof IRDelayed) {
-            stack.push({ term: t.delayed, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push({ term: t.forced, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push({ term: t.body, isInRecursiveTerm });
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push({ term: t.body, isInRecursiveTerm: true });
-            continue;
-        }
-        const tsEnsureExsaustiveCheck = t;
+        stack.push(...(t.children?.().map(c => ({ term: c, isInRecursiveTerm })) ?? []));
     }
 }

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/expandFuncsAndReturnRoot.d.ts

@@ -1,4 +1,4 @@
 import { IRFunc } from "../../../IRNodes/IRFunc.js";
 import { IRTerm } from "../../../IRTerm.js";
-export declare function getExpandedIRFunc(body: IRTerm, arity: number): IRFunc;
+export declare function getExpandedIRFunc(body: IRTerm, params: symbol[]): IRFunc;
 export declare function expandFuncsAndReturnRoot(root: IRTerm): IRTerm;

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

@@ -9,10 +9,10 @@ import { IRLetted } from "../../../IRNodes/IRLetted.js";
 import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
 import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
 import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
-export function getExpandedIRFunc(body, arity) {
-    body = new IRFunc(1, body);
-    while (--arity > 0) {
-        body = new IRFunc(1, body);
+export function getExpandedIRFunc(body, params) {
+    let introducedParam;
+    while (introducedParam = params.pop()) {
+        body = new IRFunc([introducedParam], body);
     }
     return body;
     // if( arity === 1 ) return new IRFunc( 1, body );
@@ -28,13 +28,11 @@ export function expandFuncsAndReturnRoot(root) {
             // all good
             if (t.arity <= 1)
                 continue;
-            const expanded = getExpandedIRFunc(t.body, t.arity);
-            if (t.parent) {
+            const expanded = getExpandedIRFunc(t.body, t.params);
+            if (t.parent)
                 _modifyChildFromTo(t.parent, t, expanded);
-            }
-            else {
+            else
                 root = expanded;
-            }
             continue;
         }
         if (t instanceof IRApp) {
@@ -57,12 +55,11 @@ export function expandFuncsAndReturnRoot(root) {
             stack.push(t.forced);
             continue;
         }
-        if (t instanceof IRRecursive ||
-            t instanceof IRHoisted ||
-            t instanceof IRLetted ||
-            t instanceof IRSelfCall) {
+        if (t instanceof IRRecursive
+            || t instanceof IRHoisted
+            || t instanceof IRLetted
+            || t instanceof IRSelfCall)
             throw new Error("Unexpected term while performing uplc optimizations");
-        }
     }
     return root;
 }

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/{index.d.ts → performUplcOptimizationsAndReturnRoot.d.ts}

@@ -1,5 +1,3 @@
 import { IRTerm } from "../../../IRTerm.js";
 import { CompilerOptions } from "../../CompilerOptions.js";
 export declare function performUplcOptimizationsAndReturnRoot(root: IRTerm, options: CompilerOptions): IRTerm;
-/** @experimental still can't figure how to make it work */
-export declare function groupIndipendentLets(term: IRTerm, dbn: number): [args: IRTerm[], body: IRTerm];

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

@@ -0,0 +1,151 @@
+import { IRConstr } from "../../../IRNodes/index.js";
+import { IRApp } from "../../../IRNodes/IRApp.js";
+import { IRCase } from "../../../IRNodes/IRCase.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 { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { isDebugUplcOptimizations } from "../../CompilerOptions.js";
+import { expandFuncsAndReturnRoot } from "./expandFuncsAndReturnRoot.js";
+import { getApplicationTerms } from "../../utils/getApplicationTerms.js";
+import { getUnboundedVars } from "../handleLetted/groupByScope.js";
+export function performUplcOptimizationsAndReturnRoot(root, options) {
+    const opts = options.uplcOptimizations;
+    if (isDebugUplcOptimizations(opts))
+        return root;
+    const { groupApplications, inlineSingleUse: shouldInlineSingleUse, simplifyWrappedPartialFuncApps, removeForceDelay } = opts;
+    root = expandFuncsAndReturnRoot(root);
+    const stack = [root];
+    let t = root;
+    while (t = stack.pop()) {
+        if (t instanceof IRApp
+            && isIdLike(t.fn)) {
+            const arg = t.arg;
+            if (t.parent)
+                _modifyChildFromTo(t.parent, t, arg);
+            else
+                root = arg;
+            stack.push(arg);
+            continue;
+        }
+        const indepApps = groupIndependentApplications(t);
+        if (indepApps) {
+            const { newRoot, args, nextBody } = indepApps;
+            if (newRoot)
+                root = newRoot;
+            stack.push(...args);
+            stack.push(nextBody);
+            continue;
+        }
+        if (t instanceof IRRecursive ||
+            t instanceof IRHoisted ||
+            t instanceof IRLetted ||
+            t instanceof IRSelfCall)
+            throw new Error("Unexpected term while performing uplc optimizations");
+        stack.push(...t.children());
+    }
+    return root;
+}
+function isIdLike(term) {
+    return (term instanceof IRFunc &&
+        term.params.length === 1 &&
+        term.body instanceof IRVar &&
+        term.body.name === term.params[0]);
+}
+/**
+ *
+ * @returns either an object containing the new root, sorted args and next body
+ *          or undefined if grouping wasnt possible (root is the same)
+ */
+function groupIndependentApplications(root) {
+    const parent = root.parent;
+    let applicaitonTerms = getApplicationTerms(root);
+    if (!applicaitonTerms)
+        return undefined;
+    let { func, args } = applicaitonTerms;
+    if (!(func instanceof IRFunc))
+        return undefined;
+    const params = func.params.slice();
+    while (true) {
+        applicaitonTerms = getApplicationTerms(func.body);
+        if (!applicaitonTerms)
+            break;
+        if (!(applicaitonTerms.func instanceof IRFunc))
+            break;
+        func = applicaitonTerms.func;
+        params.push(...func.params);
+        args.push(...applicaitonTerms.args);
+        if (params.length !== args.length)
+            break;
+    }
+    const len = Math.min(params.length, args.length);
+    const finalParams = params.slice(len);
+    const finalArgs = args.slice(len);
+    params.length = len;
+    args.length = len;
+    const paramToArg = {};
+    for (let i = 0; i < len; i++) {
+        const p = params[i];
+        paramToArg[p] = args[i];
+    }
+    const globalUnbound = getUnboundedVars(root);
+    const groups = [[]];
+    for (let i = 0; i < len; i++) {
+        const p = params[i];
+        const arg = args[i];
+        const unbound = getUnboundedVars(arg, globalUnbound);
+        let highestIdx = -1;
+        for (let j = groups.length - 1; j >= 0; j--) {
+            const group = groups[j];
+            if (group.some(sym => unbound.has(sym))) {
+                highestIdx = j;
+                break;
+            }
+        }
+        if (highestIdx === groups.length - 1) {
+            groups.push([p]);
+            continue;
+        }
+        groups[highestIdx + 1].push(p);
+    }
+    groups[groups.length - 1].push(...finalParams);
+    const sortedArgs = new Array(len);
+    const soretedParams = groups.flat();
+    for (let i = 0; i < len; i++) {
+        const p = soretedParams[i];
+        sortedArgs[i] = paramToArg[p];
+    }
+    let nextBody = func.body;
+    if (finalArgs.length > 0) {
+        if (finalArgs.length === 1) {
+            nextBody = new IRApp(nextBody, finalArgs[0]);
+        }
+        else {
+            nextBody = new IRCase(new IRConstr(0, finalArgs), [nextBody]);
+        }
+    }
+    let newTerm = nextBody;
+    for (let i = groups.length - 1; i >= 0; i--) {
+        const group = groups[i];
+        if (group.length === 1) {
+            newTerm = new IRApp(new IRFunc(group, newTerm), paramToArg[group[0]]);
+        }
+        else if (group.length <= 0)
+            continue;
+        else {
+            newTerm = new IRCase(new IRConstr(0, group.map(p => paramToArg[p])), [new IRFunc(group, newTerm)]);
+        }
+    }
+    if (parent)
+        _modifyChildFromTo(parent, root, newTerm);
+    else
+        root = newTerm;
+    return {
+        newRoot: !parent ? root : undefined,
+        args: sortedArgs,
+        nextBody
+    };
+}

package/dist/IR/toUPLC/subRoutines/removeUnusuedVarsAndReturnRoot/RemoveUnusedVarsCtx.d.ts

@@ -0,0 +1,11 @@
+export declare class RemoveUnusedVarsCtx {
+    readonly params: symbol[];
+    readonly parent: RemoveUnusedVarsCtx | undefined;
+    readonly localVars: Record<symbol, number>;
+    constructor(params: symbol[], parent: RemoveUnusedVarsCtx | undefined);
+    static root(params?: symbol[]): RemoveUnusedVarsCtx;
+    newChild(params: symbol[]): RemoveUnusedVarsCtx;
+    private keys;
+    incrementVarUse(sym: symbol): void;
+    getUnusedVars(): symbol[];
+}

package/dist/IR/toUPLC/subRoutines/removeUnusuedVarsAndReturnRoot/RemoveUnusedVarsCtx.js

@@ -0,0 +1,46 @@
+export class RemoveUnusedVarsCtx {
+    params;
+    parent;
+    localVars;
+    // MUST BE A GETTER TO REFLECT CHANGES IN PARENT
+    // DO NOT MODIFY
+    // private get _parentDbn(): number {
+    //     return this.parent?.dbn ?? 0;
+    // }
+    // get dbn(): number {
+    //     return this._parentDbn + Object.getOwnPropertySymbols( this.localVars ).length;
+    // }
+    constructor(params, parent) {
+        this.params = params;
+        this.parent = parent;
+        params = params.slice();
+        this.localVars = {};
+        for (const p of params)
+            this.localVars[p] = 0;
+    }
+    static root(params = []) {
+        return new RemoveUnusedVarsCtx(params, undefined);
+    }
+    newChild(params) {
+        return new RemoveUnusedVarsCtx(params, this);
+    }
+    keys() {
+        return Object.getOwnPropertySymbols(this.localVars);
+    }
+    incrementVarUse(sym) {
+        if (typeof this.localVars[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.localVars[sym]++;
+    }
+    getUnusedVars() {
+        const keys = this.keys();
+        return keys.filter(k => this.localVars[k] === 0);
+    }
+}

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

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

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

@@ -0,0 +1,80 @@
+import { _ir_apps, IRFunc } from "../../../IRNodes/index.js";
+import { IRVar } from "../../../IRNodes/IRVar.js";
+import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { getApplicationTerms } from "../../utils/getApplicationTerms.js";
+import { RemoveUnusedVarsCtx } from "./RemoveUnusedVarsCtx.js";
+export function removeUnusedVarsAndReturnRoot(term) {
+    // we need to go bottom up
+    // ONLY REMOVE UNUSED VARS IF NOT UNIT
+    // (in which case we need to keep it for eventual side effects (asserts and traces))
+    return _removeUnusedVars(term, RemoveUnusedVarsCtx.root());
+}
+function _removeUnusedVars(term, ctx) {
+    if (term instanceof IRVar) {
+        // increment used
+        ctx.incrementVarUse(term.name);
+        return term;
+    }
+    const applicationTerms = getApplicationTerms(term);
+    if (!applicationTerms) {
+        const childrens = term.children();
+        const nextCtx = term instanceof IRFunc
+            ? ctx.newChild(term.params)
+            : ctx;
+        for (const c of childrens) {
+            _removeUnusedVars(c, nextCtx);
+        }
+        return term;
+    }
+    const { func, args } = applicationTerms;
+    if (!(func instanceof IRFunc)) {
+        for (const child of term.children()) {
+            // same as parent ctx
+            _removeUnusedVars(child, ctx);
+        }
+        return term;
+    }
+    const funcCtx = ctx.newChild(func.params);
+    func.body = _removeUnusedVars(func.body, funcCtx);
+    const unusedVars = funcCtx.getUnusedVars();
+    // if all variables are used, keep as is
+    if (unusedVars.length <= 0) {
+        for (const funcArg of args) {
+            // arguments passed have the same context of the function called
+            _removeUnusedVars(funcArg, ctx);
+        }
+        return term;
+    }
+    const originalParams = func.params.slice();
+    const filteredArgs = [];
+    for (let i = 0; i < originalParams.length; i++) {
+        const p = originalParams[i];
+        if (!unusedVars.includes(p))
+            filteredArgs.push(args[i]);
+    }
+    // remove vars here
+    filterParamsInplace(func.params, unusedVars);
+    for (const funcArg of filteredArgs) {
+        // arguments passed have the same context of the function called
+        _removeUnusedVars(funcArg, ctx);
+    }
+    const someArgsWereUsed = filteredArgs.length > 0;
+    const newTerm = someArgsWereUsed
+        ? _ir_apps(func, ...filteredArgs)
+        : func.body; // all unused, remove function, just keep the body
+    const parent = term.parent;
+    if (parent)
+        _modifyChildFromTo(parent, term, newTerm);
+    return newTerm;
+}
+function filterParamsInplace(params, unusedVars) {
+    let writeIdx = 0;
+    for (let readIdx = 0; readIdx < params.length; readIdx++) {
+        const p = params[readIdx];
+        if (!unusedVars.includes(p)) {
+            params[writeIdx] = p;
+            writeIdx++;
+        }
+    }
+    params.length = writeIdx;
+}

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

@@ -1,16 +1,23 @@
 import { IRHoisted } from "../../IRNodes/IRHoisted.js";
 import { IRLetted } from "../../IRNodes/IRLetted.js";
 import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
-import { findAll } from "../_internal/findAll.js";
+const _hoisted_cache = new Map();
 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 );
+    // children first
+    const children = term.children();
+    for (const c of children)
+        replaceHoistedWithLetted(c);
+    // then check if hoisted
+    if (!(term instanceof IRHoisted))
+        return;
+    const parent = term.parent;
+    if (!parent)
+        throw new Error("hoisted node has no parent");
+    const cached = _hoisted_cache.get(term.hash)?.deref();
+    const letted = (cached ??
+        new IRLetted(term.name, term.hoisted, { isClosed: true })).clone();
+    if (!cached)
+        _hoisted_cache.set(term.hash, new WeakRef(letted));
+    // replace hoisted with letted
+    _modifyChildFromTo(parent, term, letted);
 }

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

@@ -1,3 +1,46 @@
+import { IRHoisted } from "../../../IRNodes/IRHoisted.js";
 import { IRNative } from "../../../IRNodes/IRNative/index.js";
 import { IRTerm } from "../../../IRTerm.js";
+export declare const hoisted_id: IRHoisted;
+export declare const hoisted_not: IRHoisted;
+export declare const hoisted_incr: IRHoisted;
+export declare const hoisted_decr: IRHoisted;
+export declare const hoisted_isZero: IRHoisted;
+export declare const hoisted_isOne: IRHoisted;
+export declare const hoisted_isTwo: IRHoisted;
+export declare const hoisted_isThree: IRHoisted;
+export declare const hoisted_addOne: IRHoisted;
+export declare const hoisted_subOne: IRHoisted;
+export declare const hoisted_isPositive: IRHoisted;
+export declare const hoisted_isNonNegative: IRHoisted;
+export declare const hoisted_matchList: IRHoisted;
+export declare const hoisted_recursiveList: IRHoisted;
+export declare const hoisted_foldr: IRHoisted;
+export declare const hosited_lazyChooseList: IRHoisted;
+export declare const hoisted_isMoreThanOrEqualTo4: IRHoisted;
+export declare const hoisted_sub4: IRHoisted;
+export declare const hoisted_length: IRHoisted;
+export declare const hoisted_dropList: IRHoisted;
+export declare const hoisted_sizeofPositiveInt: IRHoisted;
+export declare const hoisted_mkFindDataOptional: IRHoisted;
+export declare const hoisted_strictAnd: IRHoisted;
+export declare const hoisted_strictOr: IRHoisted;
+export declare const hoisted_some: IRHoisted;
+export declare const hoisted_every: IRHoisted;
+export declare const hoisted_mkFilter: IRHoisted;
+export declare const hoisted_gtBS: IRHoisted;
+export declare const hoisted_gtEqBS: IRHoisted;
+export declare const hoisted_gtInt: IRHoisted;
+export declare const hoisted_gtEqInt: IRHoisted;
+export declare const hoisted_strToData: IRHoisted;
+export declare const hoisted_pairDataToData: IRHoisted;
+export declare const hoisted_strFromData: IRHoisted;
+export declare const hoisted_pairDataFromData: IRHoisted;
+export declare const hoisted_boolToInt: IRHoisted;
+export declare const hoisted_intToBytesBE: IRHoisted;
+export declare const hoisted_exponentiateInteger: IRHoisted;
 export declare function nativeToIR(native: IRNative): IRTerm;
+export declare const hoisted_mkEqualsList: IRHoisted;
+export declare const hoisted_mkMapList: IRHoisted;
+export declare const hoisted_sortedValueLovelaces: IRHoisted;
+export declare const hoisted_amountOfValue: IRHoisted;