@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -1,7 +1,8 @@
+import { isClosedTerm, prettyUPLC } from "@harmoniclabs/uplc";
 import { IRLetted } from "../IRNodes/IRLetted.js";
 import { IRHoisted } from "../IRNodes/IRHoisted.js";
 import { IRConst } from "../IRNodes/IRConst.js";
-import { _irToUplc } from "./_internal/_irToUplc.js";
+import { _makeAllNegativeNativesHoisted } from "./_internal/_makeAllNegativeNativesHoisted.js";
 import { includesNode } from "./_internal/includesNode.js";
 import { handleLettedAndReturnRoot } from "./subRoutines/handleLetted/index.js";
 import { handleHoistedAndReturnRoot } from "./subRoutines/handleHoistedAndReturnRoot/index.js";
@@ -11,20 +12,26 @@ import { hoistForcedNatives } from "./subRoutines/hoistForcedNatives.js";
 import { handleRootRecursiveTerm } from "./subRoutines/handleRecursiveTerms.js";
 import { completeCompilerOptions, defaultOptions } from "./CompilerOptions.js";
 import { replaceHoistedWithLetted } from "./subRoutines/replaceHoistedWithLetted.js";
-import { IRCase, IRConstr, IRNative } from "../IRNodes/index.js";
+import { IRCase, IRConstr, IRFunc, IRNative } from "../IRNodes/index.js";
 import { replaceForcedNativesWithHoisted } from "./subRoutines/replaceForcedNativesWithHoisted.js";
-import { performUplcOptimizationsAndReturnRoot } from "./subRoutines/performUplcOptimizationsAndReturnRoot/index.js";
+import { performUplcOptimizationsAndReturnRoot } from "./subRoutines/performUplcOptimizationsAndReturnRoot/performUplcOptimizationsAndReturnRoot.js";
+import { rewriteNativesAppliedToConstantsAndReturnRoot } from "./subRoutines/rewriteNativesAppliedToConstantsAndReturnRoot.js";
+import { _debug_assertClosedIR } from "../utils/index.js";
+import { ToUplcCtx } from "./ctx/ToUplcCtx.js";
+import { removeUnusedVarsAndReturnRoot } from "./subRoutines/removeUnusuedVarsAndReturnRoot/removeUnusuedVarsAndReturnRoot.js";
+import { IRRecursive } from "../IRNodes/IRRecursive.js";
 export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // most of the time we are just compiling small
     // pre-execuded terms (hence constants)
     if (term instanceof IRConst)
-        return _irToUplc(term).term;
+        return term.toUPLC();
     ///////////////////////////////////////////////////////////////////////////////
     // ------------------------------------------------------------------------- //
     // --------------------------------- init  --------------------------------- //
     // ------------------------------------------------------------------------- //
     ///////////////////////////////////////////////////////////////////////////////
     const options = completeCompilerOptions(paritalOptions);
+    const debugAsserts = options.debugAsserts ?? false;
     // unwrap top level letted and hoisted;
     while (term instanceof IRLetted || term instanceof IRHoisted) {
         // replace with value
@@ -32,14 +39,20 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
         // forget the parent; this is the new root
         term.parent = undefined;
     }
-    // _makeAllNegativeNativesHoisted( term );
+    debugAsserts && _debug_assertions(term);
+    // term = preEvaluateDefinedTermsAndReturnRoot( term );
+    term = rewriteNativesAppliedToConstantsAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
+    // removing unused variables BEFORE going into the rest of the compilation
+    // helps letted terms to find a better spot (and possibly be inlined instead of hoisted)
+    term = removeUnusedVarsAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
+    _makeAllNegativeNativesHoisted(term);
     ///////////////////////////////////////////////////////////////////////////////
     // ------------------------------------------------------------------------- //
     // ----------------------------- optimizations ----------------------------- //
     // ------------------------------------------------------------------------- //
     ///////////////////////////////////////////////////////////////////////////////
-    // --------------------------- optimize natives  --------------------------- //
-    // at constant -> head and tails
     // --------------------- optimize recursive functions  --------------------- //
     // avoid passing whole structs
     // take letted terms outside
@@ -52,6 +65,7 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // ------------------------------------------------------------------------- //
     ///////////////////////////////////////////////////////////////////////////////
     term = replaceNativesAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
     // unwrap top level letted and hoisted;
     // some natives may be converted to hoisted;
     // this is really just an edge case
@@ -64,23 +78,32 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     if (term instanceof IRNative ||
         term instanceof IRConst // while we are at it
     )
-        return _irToUplc(term).term;
-    if (options.delayHoists)
-        replaceForcedNativesWithHoisted(term);
+        return term.toUPLC();
+    replaceForcedNativesWithHoisted(term);
+    debugAsserts && _debug_assertions(term);
     if (options.delayHoists)
         replaceHoistedWithLetted(term);
     else
         replaceClosedLettedWithHoisted(term);
+    debugAsserts && _debug_assertions(term);
+    if (debugAsserts
+        && options.delayHoists
+        && includesNode(term, node => node instanceof IRHoisted)) {
+        throw new Error("debug assertion failed: hoisted nodes found while delayHoists is true");
+    }
     // handle letted before hoisted because the tree is smaller
     // and we also have less letted dependecies to handle
     term = handleLettedAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
     term = handleHoistedAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
     // replaced hoisted terms might include new letted terms
-    while (includesNode(term, node => node instanceof IRLetted ||
-        node instanceof IRHoisted)) {
+    while (includesNode(term, node => node instanceof IRLetted
+        || node instanceof IRHoisted)) {
         term = handleLettedAndReturnRoot(term);
         term = handleHoistedAndReturnRoot(term);
     }
+    debugAsserts && _debug_assertions(term);
     ///////////////////////////////////////////////////////////////////////////////
     // ------------------------------------------------------------------------- //
     // --------------------------- translate to UPLC --------------------------- //
@@ -94,12 +117,33 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // if( options.delayHoists ) replaceHoistedWithLetted( term );
     // handle new hoisted terms
     term = handleHoistedAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
     // strictly necessary to check the options
     // otherwise forced natives where already hoisted
     // will be re-hosited; causeing uselsess evaluations
     if (!options.delayHoists)
         term = hoistForcedNatives(term);
+    debugAsserts && _debug_assertions(term);
     // at this point we expect the IR to be translable 1:1 to UPLC
+    // The loop is needed because after inlining some params, 
+    // new params in outer (or sibling) functions can become 
+    // single‑use; a single bottom‑up pass doesn’t 
+    // “see” those future states.
+    //
+    // ALWAYS AT LEAST 1 ITERATION
+    // const maxInlineIterations = Math.max( 3, 1 );
+    // for(
+    //     let somethingWasInlined = true,
+    //         inlineIterations = 0;
+    //     somethingWasInlined
+    //     && inlineIterations < maxInlineIterations;
+    //     inlineIterations++
+    // ) {
+    //     const inlineResult = inlineSingleUseAndReturnRoot( term );
+    //     term = inlineResult.term;
+    //     somethingWasInlined = inlineResult.somethingWasInlined;
+    // }
+    term = removeUnusedVarsAndReturnRoot(term);
     term = performUplcOptimizationsAndReturnRoot(term, options);
     if (options.addMarker &&
         options.targetUplcVersion.major >= 1 &&
@@ -111,8 +155,41 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
             IRConst.int(42)
         ]);
     }
-    const srcmap = {};
-    const uplc = _irToUplc(term, srcmap).term;
+    // let irJson = prettyIR( term );
+    // console.log(
+    //     "final IR before UPLC translation:\n",
+    //     irJson.text,
+    //     JSON.stringify( onlyHoistedAndLetted( irJson ) )
+    // );
+    debugAsserts && _debug_assertions(term);
+    // const srcmap = {};
+    const uplc = term.toUPLC(ToUplcCtx.root());
+    if (!isClosedTerm(uplc)) {
+        console.error(prettyUPLC(uplc));
+        throw new Error("compileIRToUPLC: final UPLC term is not closed:\n" +
+            "This is a compiler internal error; please open an issue on github so we can fix this.");
+    }
     // console.log( "srcmap", srcmap );
     return uplc;
 }
+function _debug_assertions(term) {
+    _debug_assertClosedIR(term);
+    _debug_assertNoDoubleVars(term);
+}
+function _debug_assertNoDoubleVars(term) {
+    const seen = new Set();
+    const stack = [term];
+    let current = term;
+    while (current = stack.pop()) {
+        if (current instanceof IRFunc
+            || current instanceof IRRecursive) {
+            for (const p of current.params) {
+                if (seen.has(p)) {
+                    throw new Error("debug assertion failed: double variable detected");
+                }
+                seen.add(p);
+            }
+        }
+        stack.push(...current.children());
+    }
+}

package/dist/IR/toUPLC/ctx/ToUplcCtx.d.ts

@@ -0,0 +1,16 @@
+export declare class ToUplcCtx {
+    readonly parent: ToUplcCtx | undefined;
+    readonly ctxMap: Map<symbol, ToUplcCtx>;
+    private readonly _variables;
+    private get _parentDbn();
+    get dbn(): number;
+    private _frozen;
+    constructor(parent: ToUplcCtx | undefined, variables: symbol[]);
+    static root(): ToUplcCtx;
+    newChild(variables: symbol[]): ToUplcCtx;
+    getVarDeclDbn(sym: symbol): number;
+    getVarAccessDbn(sym: symbol): number;
+    toJson(): any;
+    allVars(): symbol[];
+    expectedDbn(sym: symbol): number;
+}

package/dist/IR/toUPLC/ctx/ToUplcCtx.js

@@ -0,0 +1,67 @@
+export class ToUplcCtx {
+    parent;
+    ctxMap;
+    _variables;
+    get _parentDbn() {
+        return this.parent?.dbn ?? 0;
+    }
+    get dbn() {
+        return this._variables.length + this._parentDbn;
+    }
+    _frozen;
+    constructor(parent, variables) {
+        this.parent = parent;
+        this.ctxMap = this.parent?.ctxMap ?? new Map();
+        this._variables = variables;
+        for (const v of variables)
+            this.ctxMap.set(v, this);
+    }
+    static root() {
+        return new ToUplcCtx(undefined, []);
+    }
+    newChild(variables) {
+        return new ToUplcCtx(this, variables);
+    }
+    getVarDeclDbn(sym) {
+        const ctx = this.ctxMap.get(sym);
+        const idx = ctx?._variables.indexOf(sym) ?? -1;
+        if (idx <= -1) {
+            console.error(sym, ctx?.allVars());
+            throw new Error("Variable not found in its defining context");
+        }
+        return ctx._parentDbn + idx + 1;
+    }
+    getVarAccessDbn(sym) {
+        const declDbn = this.getVarDeclDbn(sym);
+        return this.dbn - declDbn;
+    }
+    toJson() {
+        let obj = {};
+        let prevCtx = null;
+        let ctx = this;
+        do {
+            obj["parentDbn"] = ctx._parentDbn;
+            obj["dbn"] = ctx.dbn;
+            obj["vars"] = ctx._variables.slice();
+            obj["next"] = prevCtx;
+            prevCtx = obj;
+            obj = {};
+            ctx = ctx.parent;
+        } while (ctx);
+        return prevCtx;
+    }
+    allVars() {
+        let vars = [];
+        let ctx = this;
+        while (ctx = ctx.parent) {
+            vars = ctx._variables.concat(vars);
+        }
+        return vars;
+    }
+    // for debugging purposes
+    // "inefficient" but correct way to get expected de bruijn index
+    expectedDbn(sym) {
+        const vars = this.allVars();
+        return vars.length - 1 - vars.lastIndexOf(sym);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { IRHoisted, IRNative } from "../../IRNodes/index.js";
+export declare const hoisted_drop2: IRHoisted;
+export declare const hoisted_drop3: IRHoisted;
+export declare const hoisted_drop4: IRHoisted;
+export declare const hoisted_drop8: IRHoisted;
+export declare const hoisted_drop16: IRHoisted;
+export declare const hoisted_drop32: IRHoisted;
+export declare function _compTimeDropN(bigN: bigint): IRHoisted | IRNative;

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

@@ -0,0 +1,95 @@
+import { IRHoisted, IRFunc, IRNative, IRVar, _ir_apps } from "../../IRNodes/index.js";
+const tailList = new IRHoisted(IRNative.tailList);
+tailList.hash;
+const drop2_lst = Symbol("lst");
+export const hoisted_drop2 = new IRHoisted(new IRFunc([drop2_lst], // lst
+_ir_apps(tailList.clone(), _ir_apps(tailList.clone(), new IRVar(drop2_lst) // lst
+))));
+hoisted_drop2.hash;
+const drop3_lst = Symbol("lst");
+export const hoisted_drop3 = new IRHoisted(new IRFunc([drop3_lst], // lst
+_ir_apps(tailList.clone(), _ir_apps(tailList.clone(), _ir_apps(tailList.clone(), new IRVar(drop3_lst) // lst
+)))));
+hoisted_drop3.hash;
+const drop4_lst = Symbol("lst");
+export const hoisted_drop4 = new IRHoisted(new IRFunc([drop4_lst], // lst
+_ir_apps(tailList.clone(), _ir_apps(tailList.clone(), _ir_apps(tailList.clone(), _ir_apps(tailList.clone(), new IRVar(drop4_lst) // lst
+))))));
+hoisted_drop4.hash;
+const drop8_lst = Symbol("lst");
+export const hoisted_drop8 = new IRHoisted(new IRFunc([drop8_lst], // lst
+_ir_apps(hoisted_drop4.clone(), _ir_apps(hoisted_drop4.clone(), new IRVar(drop8_lst) // lst
+))));
+hoisted_drop8.hash;
+// replace numeric arity version of drop16 with symbol param
+const drop16_lst = Symbol("lst");
+export const hoisted_drop16 = new IRHoisted(new IRFunc([drop16_lst], _ir_apps(hoisted_drop8.clone(), _ir_apps(hoisted_drop8.clone(), new IRVar(drop16_lst)))));
+hoisted_drop16.hash;
+// replace numeric arity version of drop32 with symbol param
+const drop32_lst = Symbol("lst");
+export const hoisted_drop32 = new IRHoisted(new IRFunc([drop32_lst], _ir_apps(hoisted_drop16.clone(), _ir_apps(hoisted_drop16.clone(), new IRVar(drop32_lst)))));
+hoisted_drop32.hash;
+export function _compTimeDropN(bigN) {
+    const n = Number(bigN);
+    if (n < 0)
+        throw new Error(`Cannot drop a negative number of elements from a list`);
+    if (n === 0)
+        return IRNative._id;
+    if (n === 1)
+        return tailList.clone();
+    if (n === 2)
+        return hoisted_drop2;
+    if (n === 3)
+        return hoisted_drop3;
+    if (n === 4)
+        return hoisted_drop4;
+    if (n === 8)
+        return hoisted_drop8;
+    if (n === 16)
+        return hoisted_drop16;
+    if (n === 32)
+        return hoisted_drop32;
+    // Greedy decomposition into available drop sizes (largest first)
+    let remaining = n;
+    const parts = [];
+    const sizes = [32, 16, 8, 4, 3, 2, 1];
+    for (const s of sizes) {
+        while (remaining >= s) {
+            parts.push(s);
+            remaining -= s;
+        }
+        if (remaining === 0)
+            break;
+    }
+    // Build the composed drop function body by sequential application
+    const lst = Symbol("lst"); // symbol param for composed function
+    let body = new IRVar(lst);
+    for (const p of parts) {
+        switch (p) {
+            case 32:
+                body = _ir_apps(hoisted_drop32.clone(), body);
+                break;
+            case 16:
+                body = _ir_apps(hoisted_drop16.clone(), body);
+                break;
+            case 8:
+                body = _ir_apps(hoisted_drop8.clone(), body);
+                break;
+            case 4:
+                body = _ir_apps(hoisted_drop4.clone(), body);
+                break;
+            case 3:
+                body = _ir_apps(hoisted_drop3.clone(), body);
+                break;
+            case 2:
+                body = _ir_apps(hoisted_drop2.clone(), body);
+                break;
+            case 1:
+                body = _ir_apps(tailList.clone(), body);
+                break;
+        }
+    }
+    const hoisted = new IRHoisted(new IRFunc([lst], body));
+    hoisted.hash;
+    return hoisted;
+}

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

@@ -1,17 +1,11 @@
 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) {
@@ -68,19 +62,11 @@ export function handleHoistedAndReturnRoot(term) {
     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());
+        root = new IRApp(new IRFunc([thisHoisted.name], root), thisHoisted.hoisted.clone());
     }
     // replace hoisted references with variables
     const stack = [{ irTerm: root, dbn: 0 }];
@@ -93,22 +79,14 @@ export function handleHoistedAndReturnRoot(term) {
         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}`);
-            }
+            const irvar = new IRVar(irTerm.name); // getIRVarForHoistedAtLevel( irTermHash, 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
-            });
+            irTerm.meta.handled = true;
             // don't push anything
             // because we just replaced with a variable
             // so we know there's not a tree to explore
@@ -124,38 +102,13 @@ export function handleHoistedAndReturnRoot(term) {
             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) {
+        if (irTerm instanceof IRFunc
+            || irTerm instanceof IRRecursive) {
             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;
-        }
+        stack.push(...irTerm.children()
+            .map(child => ({ irTerm: child, dbn })));
     }
     return root;
 }

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

@@ -1,20 +1,13 @@
-import { IRFunc } from "../../../IRNodes/IRFunc.js";
 import { LettedSetEntry } from "../../../IRNodes/IRLetted.js";
+import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
+import { IRVar } from "../../../IRNodes/IRVar.js";
 import { IRTerm } from "../../../IRTerm.js";
 type ScopedLettedTerms = {
-    maxScope: IRFunc | undefined;
+    maxScope: IRTerm | 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 declare function getMaxScope(term: IRTerm): IRTerm | undefined;
+export declare function getUnboundedIRVars(term: IRTerm): (IRVar | IRSelfCall)[];
+export declare function getUnboundedVars(term: IRTerm, knownVars?: Set<symbol> | undefined): Set<symbol>;
 export {};