@harmoniclabs/pebble 0.1.0-dev0

package/dist/IR/toUPLC/CompilerOptions.d.ts

@@ -0,0 +1,80 @@
+import { UPLCVersion } from "@harmoniclabs/uplc";
+export interface CompilerUplcOptimizations {
+    /**
+     *
+     **/
+    groupApplications: boolean;
+    /**
+     **/
+    inlineSingleUse: boolean;
+    /**
+     **/
+    simplifyWrappedPartialFuncApps: boolean;
+    /**
+     *
+     **/
+    removeForceDelay: boolean;
+}
+export declare const productionUplcOptimizations: CompilerUplcOptimizations;
+export declare const debugUplcOptimizations: CompilerUplcOptimizations;
+export declare const defaultUplcOptimizations: CompilerUplcOptimizations;
+export declare function isDebugUplcOptimizations(options?: Partial<CompilerUplcOptimizations>): boolean;
+export declare function completeUplcOptimizations(options: Partial<CompilerUplcOptimizations>, complete?: CompilerUplcOptimizations): CompilerUplcOptimizations;
+export interface CompilerOptions {
+    /**
+     * path to the entry file
+     */
+    readonly entry: string;
+    /**
+     * path of the root of the project
+     */
+    readonly root: string;
+    /**
+     * path to the output directory
+     */
+    readonly outDir: string;
+    /**
+     * uplc version (encoded in the script)
+     */
+    targetUplcVersion: UPLCVersion;
+    /**
+     * @todo TODO
+     *
+     * @default true
+     *
+     * set to `false` only for debugging purposes
+     **/
+    removeTraces: boolean;
+    /**
+     * @todo TODO
+     *
+     * if `true` replaces all `IRHoisted` with `IRLetted`
+     *
+     * handling letted terms is more expansive than hoisted terms
+     * because hoisted (since closed terms) are blindly added as roots of the script
+     *
+     * however this approach impacts the "script startup cost" considerably
+     * esxpecially for scripts with different branches (eg. multi purpose scripts)
+     * where some hoisted may never be used in some branches,
+     * but still are added to the "initialization cost"
+     *
+     * on the other hand, handling letted instead of hoisted may impact compliation time
+     *
+     * for this reason it is best to set this option to `true` only for production
+     **/
+    delayHoists: boolean;
+    /**
+     *
+     **/
+    uplcOptimizations: Partial<CompilerUplcOptimizations>;
+    /**
+     *
+     **/
+    addMarker: boolean;
+}
+export declare const extremeOptions: CompilerOptions;
+export declare const productionOptions: CompilerOptions;
+export declare const debugOptions: CompilerOptions;
+export declare const defaultOptions: CompilerOptions;
+export declare const defulatCompilerOptions: CompilerOptions;
+export declare function completeCompilerOptions(options: Partial<CompilerOptions>, complete?: CompilerOptions): CompilerOptions;

package/dist/IR/toUPLC/CompilerOptions.js

@@ -0,0 +1,98 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { defaultUplcVersion, UPLCVersion } from "@harmoniclabs/uplc";
+export const productionUplcOptimizations = Object.freeze({
+    groupApplications: true,
+    inlineSingleUse: true,
+    simplifyWrappedPartialFuncApps: true,
+    removeForceDelay: true
+});
+export const debugUplcOptimizations = Object.freeze({
+    groupApplications: false,
+    inlineSingleUse: false,
+    simplifyWrappedPartialFuncApps: false,
+    removeForceDelay: true
+});
+export const defaultUplcOptimizations = productionUplcOptimizations;
+export function isDebugUplcOptimizations(options = {}) {
+    return Object.keys(debugUplcOptimizations)
+        .every((key) => {
+        // keys to ignore
+        if (key === "removeForceDelay")
+            return true;
+        return options[key] === debugUplcOptimizations[key];
+    });
+}
+export function completeUplcOptimizations(options, complete = defaultUplcOptimizations) {
+    if (!isObject(options))
+        return { ...defaultUplcOptimizations };
+    return {
+        groupApplications: options.groupApplications ?? complete.groupApplications,
+        inlineSingleUse: options.inlineSingleUse ?? complete.inlineSingleUse,
+        simplifyWrappedPartialFuncApps: options.simplifyWrappedPartialFuncApps ?? complete.simplifyWrappedPartialFuncApps,
+        removeForceDelay: options.removeForceDelay ?? complete.removeForceDelay
+    };
+}
+export const extremeOptions = Object.freeze({
+    entry: "./src/index.pebble",
+    root: ".",
+    outDir: "./out",
+    targetUplcVersion: defaultUplcVersion,
+    removeTraces: true,
+    delayHoists: true,
+    uplcOptimizations: productionUplcOptimizations,
+    addMarker: true
+});
+export const productionOptions = Object.freeze({
+    entry: "./src/index.pebble",
+    root: ".",
+    outDir: "./out",
+    targetUplcVersion: defaultUplcVersion,
+    removeTraces: true,
+    delayHoists: true,
+    uplcOptimizations: productionUplcOptimizations,
+    addMarker: true
+});
+export const debugOptions = Object.freeze({
+    entry: "./src/index.pebble",
+    root: ".",
+    outDir: "./out",
+    targetUplcVersion: defaultUplcVersion,
+    removeTraces: false,
+    delayHoists: false,
+    uplcOptimizations: debugUplcOptimizations,
+    addMarker: false
+});
+export const defaultOptions = productionOptions;
+export const defulatCompilerOptions = defaultOptions;
+export function completeCompilerOptions(options, complete = defaultOptions) {
+    let targetUplcVersion = options.targetUplcVersion instanceof UPLCVersion ? complete.targetUplcVersion : defaultUplcVersion;
+    complete = {
+        ...defaultOptions,
+        ...complete
+    };
+    let uplcOptimizations = options.uplcOptimizations;
+    if (typeof options.uplcOptimizations === "boolean") {
+        if (options.uplcOptimizations) {
+            uplcOptimizations = {
+                ...productionUplcOptimizations,
+                ...uplcOptimizations
+            };
+        }
+        else {
+            uplcOptimizations = {
+                ...debugUplcOptimizations,
+                ...uplcOptimizations,
+            };
+        }
+    }
+    // console.log( "uplcOptimizations", uplcOptimizations );
+    // console.log( "completeUplcOptimizations( uplcOptimizations )",completeUplcOptimizations( uplcOptimizations ))
+    return {
+        ...complete,
+        targetUplcVersion,
+        removeTraces: options.removeTraces ?? complete.removeTraces,
+        delayHoists: options.delayHoists ?? complete.delayHoists,
+        uplcOptimizations: completeUplcOptimizations(uplcOptimizations),
+        addMarker: options.addMarker ?? complete.addMarker
+    };
+}

package/dist/IR/toUPLC/_internal/_addDepth.d.ts

@@ -0,0 +1,2 @@
+import { IRTerm } from "../../IRTerm.js";
+export declare function _addDepths(_term: IRTerm, initialDepth?: number): void;

package/dist/IR/toUPLC/_internal/_addDepth.js

@@ -0,0 +1,58 @@
+import { IRCase, IRConstr } from "../../IRNodes/index.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 { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../IRNodes/IRLetted.js";
+import { IRRecursive } from "../../IRNodes/IRRecursive.js";
+import { mapArrayLike } from "../../IRNodes/utils/mapArrayLike.js";
+import { defineDepth } from "./depth.js";
+export function _addDepths(_term, initialDepth = 0) {
+    const stack = [defineDepth(_term, initialDepth)];
+    while (stack.length > 0) {
+        const t = stack.pop();
+        if (t instanceof IRApp) {
+            stack.push(defineDepth(t.fn, t.depth + 1), defineDepth(t.arg, t.depth + 1));
+            continue;
+        }
+        if (t instanceof IRCase) {
+            const nextDepth = t.depth + 1;
+            stack.push(defineDepth(t.constrTerm, nextDepth), ...mapArrayLike(t.continuations, (continuation) => defineDepth(continuation, nextDepth)));
+            continue;
+        }
+        if (t instanceof IRConstr) {
+            stack.push(...mapArrayLike(t.fields, (field) => defineDepth(field, t.depth + 1)));
+            continue;
+        }
+        if (t instanceof IRDelayed) {
+            stack.push(defineDepth(t.delayed, t.depth + 1));
+            continue;
+        }
+        if (t instanceof IRForced) {
+            stack.push(defineDepth(t.forced, t.depth + 1));
+            continue;
+        }
+        if (t instanceof IRFunc) {
+            stack.push(defineDepth(t.body, t.depth + 1));
+            continue;
+        }
+        if (t instanceof IRRecursive) {
+            stack.push(defineDepth(t.body, t.depth + 1));
+            continue;
+        }
+        if (t instanceof IRHoisted) {
+            // 0 because hoisted are closed
+            // for hoisted we keep track of the depth inside the term
+            stack.push(defineDepth(t.hoisted, 0));
+            continue;
+        }
+        if (t instanceof IRLetted) {
+            // same stuff as the hoisted terms
+            // the only difference is that depth is then incremented
+            // once the letted term reaches its final position
+            stack.push(defineDepth(t.value, 0));
+            continue;
+        }
+    }
+}

package/dist/IR/toUPLC/_internal/_irToUplc.d.ts

@@ -0,0 +1,9 @@
+import { IRTerm } from "../../IRTerm.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
+export type RawSrcMap = {
+    [node_index: number]: string;
+};
+export declare function _irToUplc(ir: IRTerm, srcmap?: RawSrcMap | undefined, node_index?: number): {
+    term: UPLCTerm;
+    max_idx: number;
+};

package/dist/IR/toUPLC/_internal/_irToUplc.js

@@ -0,0 +1,156 @@
+import { IRApp } from "../../IRNodes/IRApp.js";
+import { IRConst } from "../../IRNodes/IRConst.js";
+import { IRFunc } from "../../IRNodes/IRFunc.js";
+import { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../IRNodes/IRLetted.js";
+import { IRNative } from "../../IRNodes/IRNative/index.js";
+import { nativeTagToString } from "../../IRNodes/IRNative/IRNativeTag.js";
+import { IRVar } from "../../IRNodes/IRVar.js";
+import { showIR } from "../../utils/showIR.js";
+import { IRError } from "../../IRNodes/IRError.js";
+import { IRForced } from "../../IRNodes/IRForced.js";
+import { IRDelayed } from "../../IRNodes/IRDelayed.js";
+import { UPLCVar, Lambda, Application, Builtin, ErrorUPLC, Force, Delay, Constr, Case } from "@harmoniclabs/uplc";
+import { IRConstr } from "../../IRNodes/IRConstr.js";
+import { IRCase } from "../../IRNodes/IRCase.js";
+import { irHashToHex } from "../../IRHash.js";
+import { IRRecursive } from "../../IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../../IRNodes/IRSelfCall.js";
+export function _irToUplc(ir, srcmap = undefined, node_index = 0) {
+    if (!(ir instanceof IRConst)) {
+        // console.log("_irToUplc", ir, node_index, Date.now());
+    }
+    else {
+        // if( ir.parent )
+        // {
+        //     console.log(ir.parent ? Object.getPrototypeOf( ir.parent ).constructor.name : undefined, Date.now() );
+        // }
+        // else
+        // {
+        //     console.log( Error().stack );
+        // }
+    }
+    if (ir instanceof IRConst) {
+        return {
+            term: ir.toUPLC(),
+            max_idx: node_index
+        };
+    }
+    if (ir instanceof IRVar)
+        return {
+            term: new UPLCVar(ir.dbn),
+            max_idx: node_index
+        };
+    if (ir instanceof IRFunc) {
+        const { term: body, max_idx } = _irToUplc(ir.body, srcmap, node_index);
+        let lam = new Lambda(body);
+        for (let i = 1; i < ir.arity; i++) {
+            lam = new Lambda(lam);
+        }
+        return {
+            term: lam,
+            max_idx
+        };
+    }
+    if (ir instanceof IRRecursive) {
+        throw new Error("Can't convert 'IRRecursive' to valid UPLC;" +
+            "IRRecursive are expected to be converted before calling '_irToUplc'");
+    }
+    if (ir instanceof IRSelfCall) {
+        throw new Error("Can't convert 'IRSelfCall' to valid UPLC;" +
+            "IRSelfCall are expected to be converted before calling '_irToUplc'");
+    }
+    if (ir instanceof IRApp) {
+        const { term: fn, max_idx: fn_max_idx } = _irToUplc(ir.fn, srcmap, node_index + 1);
+        const { term: arg, max_idx: arg_max_idx } = _irToUplc(ir.arg, srcmap, fn_max_idx + 1);
+        let src = ir.meta.__src__;
+        if (srcmap && typeof src === "string") {
+            srcmap[node_index] = adaptSrcString(src);
+        }
+        return {
+            term: new Application(fn, arg),
+            max_idx: arg_max_idx
+        };
+    }
+    if (ir instanceof IRNative) {
+        if (ir.tag < 0)
+            throw new Error("Can't translate '" + nativeTagToString(ir.tag) + "' 'IRNative' to 'UPLCBuiltin'");
+        return {
+            term: new Builtin(ir.tag),
+            max_idx: node_index
+        };
+    }
+    if (ir instanceof IRLetted) {
+        throw new Error("Can't convert 'IRLetted' to valid UPLC");
+    }
+    if (ir instanceof IRHoisted) {
+        // return this.hoisted.toUPLC();
+        throw new Error("Can't convert 'IRHoisted' to valid UPLC;" +
+            "\nhoisted hash was: " + irHashToHex(ir.hash) +
+            "\nhoisted term was: " + showIR(ir.hoisted).text);
+    }
+    if (ir instanceof IRError) {
+        if (typeof ir.addInfos.__src__ === "string" && srcmap) {
+            srcmap[node_index] = adaptSrcString(ir.addInfos.__src__);
+        }
+        return {
+            term: new ErrorUPLC(ir.msg, ir.addInfos),
+            max_idx: node_index
+        };
+    }
+    if (ir instanceof IRForced) {
+        const { term: toForce, max_idx } = _irToUplc(ir.forced, srcmap, node_index);
+        return {
+            term: new Force(toForce),
+            max_idx
+        };
+    }
+    if (ir instanceof IRDelayed) {
+        const { term: toDelay, max_idx } = _irToUplc(ir.delayed, srcmap, node_index);
+        return {
+            term: new Delay(toDelay),
+            max_idx
+        };
+    }
+    if (ir instanceof IRConstr) {
+        if (ir.fields.length === 0) {
+            return {
+                term: new Constr(ir.index, []),
+                max_idx: node_index + 1
+            };
+        }
+        const fields = Array.from(ir.fields)
+            .slice(1)
+            .reduce((accum, field, i) => {
+            accum.push(_irToUplc(field, srcmap, accum[i].max_idx + 1));
+            return accum;
+        }, [_irToUplc(ir.fields[0], srcmap, node_index)]);
+        return {
+            term: new Constr(ir.index, fields.map(({ term }) => term)),
+            max_idx: fields[fields.length - 1].max_idx
+        };
+    }
+    if (ir instanceof IRCase) {
+        const { term: constrTerm, max_idx } = _irToUplc(ir.constrTerm, srcmap, node_index);
+        const conts = Array.from(ir.continuations)
+            .slice(1)
+            .reduce((accum, cont, i) => {
+            accum.push(_irToUplc(cont, srcmap, accum[i].max_idx + 1));
+            return accum;
+        }, [_irToUplc(ir.continuations[0], srcmap, max_idx + 1)]);
+        return {
+            term: new Case(constrTerm, conts.map(({ term }) => term)),
+            max_idx: conts[conts.length - 1].max_idx
+        };
+    }
+    throw new Error("unknown IR term calling '_irToUplc'");
+}
+function adaptSrcString(src) {
+    // "   at $ (some/path/to/src.ts:line:column)" -> "some/path/to/src.ts:line:column"
+    let idx = src.indexOf("(");
+    src = idx >= 0 ? src.slice(idx + 1, src.length - 1) : src;
+    // "   at some/path/to/src.ts:line:column" -> "some/path/to/src.ts:line:column"
+    idx = src.indexOf("at ");
+    src = idx >= 0 ? src.slice(idx + 3) : src;
+    return src;
+}

package/dist/IR/toUPLC/_internal/_makeAllNegativeNativesHoisted.d.ts

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

package/dist/IR/toUPLC/_internal/_makeAllNegativeNativesHoisted.js

@@ -0,0 +1,12 @@
+import { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRNative } from "../../IRNodes/IRNative/index.js";
+import { _modifyChildFromTo } from "./_modifyChildFromTo.js";
+import { iterTree } from "./iterTree.js";
+export function _makeAllNegativeNativesHoisted(term) {
+    iterTree(term, elem => {
+        if (elem instanceof IRNative && !(elem.parent instanceof IRHoisted)) {
+            _modifyChildFromTo(elem.parent, elem, new IRHoisted(elem));
+            return true;
+        }
+    });
+}

package/dist/IR/toUPLC/_internal/_modifyChildFromTo.d.ts

@@ -0,0 +1,10 @@
+import { IRTerm } from "../../IRTerm.js";
+import { IRParentTerm } from "../../utils/isIRParentTerm.js";
+import { IRHash } from "../../IRHash.js";
+/**
+ *
+ * @param parent node to modify the child of
+ * @param currentChild mainly passed to distinguish in case of `IRApp`
+ * @param newChild new node's child
+ */
+export declare function _modifyChildFromTo(parent: IRParentTerm | undefined, currentChild: IRTerm | IRHash, newChild: IRTerm): void;

package/dist/IR/toUPLC/_internal/_modifyChildFromTo.js

@@ -0,0 +1,141 @@
+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 { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../IRNodes/IRLetted.js";
+import { IRConstr } from "../../IRNodes/IRConstr.js";
+import { IRCase } from "../../IRNodes/IRCase.js";
+import { equalIrHash, irHashToHex, isIRHash } from "../../IRHash.js";
+import { IRRecursive } from "../../IRNodes/IRRecursive.js";
+import { isIRTerm } from "../../utils/isIRTerm.js";
+/**
+ *
+ * @param parent node to modify the child of
+ * @param currentChild mainly passed to distinguish in case of `IRApp`
+ * @param newChild new node's child
+ */
+export function _modifyChildFromTo(parent, currentChild, newChild) {
+    if (parent === undefined) {
+        throw new Error("'_modifyChildFromTo' received an undefined parent, possibly root");
+    }
+    if (
+    // currentChild has parent property
+    isIRTerm(currentChild) &&
+        // and is not (already) undefined
+        currentChild.parent !== undefined &&
+        // and the `parent` passed to the function is the parent of the `currentChild`
+        currentChild.parent === parent &&
+        // and child to be modified is not the same object
+        currentChild !== newChild) {
+        // we are modifying the child
+        // so we remove parent the reference
+        currentChild.parent = undefined;
+    }
+    // DO NOT USE **ONLY** SHALLOW EQUALITY
+    // child might be cloned
+    // however delay hash computation until needed
+    let _childHash;
+    const currChildHash = () => {
+        if (isIRHash(_childHash))
+            return _childHash;
+        _childHash = isIRHash(currentChild) ? currentChild : currentChild.hash;
+        return _childHash;
+    };
+    if (parent instanceof IRApp) {
+        // check the argument first as it is more likely to have a smaller tree
+        if (currentChild === parent.arg) {
+            parent.arg = newChild;
+        }
+        else if (currentChild === parent.fn) {
+            parent.fn = newChild;
+        }
+        else if (equalIrHash(parent.arg.hash, currChildHash())) {
+            parent.arg = newChild;
+        }
+        else if (equalIrHash(parent.fn.hash, currChildHash())) {
+            parent.fn = newChild;
+        }
+        else {
+            throw new Error("unknown 'IRApp' child to modify; given child to modify hash: " +
+                irHashToHex(currChildHash()) +
+                "; function child hash: " + irHashToHex(parent.fn.hash) +
+                "; argument child hash: " + irHashToHex(parent.arg.hash));
+        }
+        return;
+    }
+    else if (parent instanceof IRConstr) {
+        let foundChild = false;
+        for (let i = 0; i < parent.fields.length; i++) {
+            const field = parent.fields[i];
+            if (field === currentChild) {
+                parent.fields[i] = newChild;
+                foundChild = true;
+                break;
+            }
+        }
+        if (foundChild)
+            return;
+        for (let i = 0; i < parent.fields.length; i++) {
+            const field = parent.fields[i];
+            if (equalIrHash(field.hash, currChildHash())) {
+                parent.fields[i] = newChild;
+                break;
+            }
+        }
+        return;
+    }
+    else if (parent instanceof IRCase) {
+        if (parent.constrTerm === currentChild) {
+            parent.constrTerm = newChild;
+            return;
+        }
+        let foundChild = false;
+        for (let i = 0; i < parent.continuations.length; i++) {
+            const field = parent.continuations[i];
+            if (field === currentChild) {
+                parent.continuations[i] = newChild;
+                foundChild = true;
+                break;
+            }
+        }
+        if (foundChild)
+            return;
+        if (equalIrHash(currChildHash(), parent.constrTerm.hash)) {
+            parent.constrTerm = newChild;
+            return;
+        }
+        for (let i = 0; i < parent.continuations.length; i++) {
+            const field = parent.continuations[i];
+            if (equalIrHash(field.hash, currChildHash())) {
+                parent.continuations[i] = newChild;
+                break;
+            }
+        }
+        return;
+    }
+    if (parent instanceof IRDelayed) {
+        parent.delayed = newChild;
+        return;
+    }
+    if (parent instanceof IRForced) {
+        parent.forced = newChild;
+        return;
+    }
+    if (parent instanceof IRFunc) {
+        parent.body = newChild;
+        return;
+    }
+    if (parent instanceof IRRecursive) {
+        parent.body = newChild;
+        return;
+    }
+    if (parent instanceof IRHoisted) {
+        parent.hoisted = newChild;
+        return;
+    }
+    if (parent instanceof IRLetted) {
+        parent.value = newChild;
+        return;
+    }
+}

package/dist/IR/toUPLC/_internal/depth.d.ts

@@ -0,0 +1,5 @@
+import { IRTerm } from "../../IRTerm.js";
+export type IRTermWithDepth = IRTerm & {
+    depth: number;
+};
+export declare function defineDepth(term: IRTerm, depth: number): IRTermWithDepth;

package/dist/IR/toUPLC/_internal/depth.js

@@ -0,0 +1,8 @@
+export function defineDepth(term, depth) {
+    return Object.defineProperty(term, "depth", {
+        value: depth,
+        writable: true,
+        enumerable: true,
+        configurable: false
+    });
+}

package/dist/IR/toUPLC/_internal/findAll.d.ts

@@ -0,0 +1,3 @@
+import { IRTerm } from "../../IRTerm.js";
+export declare function findAll(term: IRTerm, predicate: (elem: IRTerm) => boolean): IRTerm[];
+export declare function findAllNoHoisted(term: IRTerm, predicate: (elem: IRTerm) => boolean): IRTerm[];