@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

package/dist/IR/IRNodes/IRVar.js

@@ -1,49 +1,43 @@
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
 import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
 import { hashIrData, isIRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { hashVarSym } from "./utils/hashVarSym.js";
+import { UPLCVar } from "@harmoniclabs/uplc";
 export class IRVar {
+    _creationStack;
+    meta;
+    name;
+    constructor(name, _unsafeHash) {
+        if (!(typeof name === "symbol"
+            && typeof name.description === "string"
+            && name.description.length > 0))
+            throw new BasePlutsError("invalid name for IRVar");
+        this.name = name;
+        this._parent = undefined;
+        this.meta = {};
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+        this._creationStack = (new Error()).stack ?? "unknown";
+    }
+    toUPLC(ctx) {
+        return new UPLCVar(ctx.getVarAccessDbn(this.name));
+    }
     _hash;
     get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = getVarHashAtDbn(this.dbn);
-        }
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRVar.tag, hashVarSym(this.name)));
         return this._hash;
     }
-    /**
-     * called inside the dbn setter
-     */
+    isHashPresent() { return isIRHash(this._hash); }
     markHashAsInvalid() {
         this._hash = undefined;
         this.parent?.markHashAsInvalid();
     }
-    isHashPresent() { return true; }
-    _dbn;
-    /**
-     * the IR DeBruijn index is not necessarly the same of the UPLC
-     * ( more ofthen than not it won't be the same )
-     *
-     * this is because in the IR things like `IRLetted` and `IRHoisted`
-     * are skipping some DeBruijin levels that are instead present
-     * in the final UPLC
-    **/
-    get dbn() { return this._dbn; }
-    set dbn(newDbn) {
-        if (!(Number.isSafeInteger(newDbn) && newDbn >= 0)) {
-            // console.log( e.stack );
-            throw new BasePlutsError("invalid index for an `IRVar` instance; new DeBruijn was: " + newDbn);
-        }
-        if (newDbn === this._dbn)
-            return; // everything ok
-        this.markHashAsInvalid();
-        this._dbn = newDbn;
-    }
     static get kind() { return IRNodeKind.Var; }
     get kind() { return IRVar.kind; }
     static get tag() { return new Uint8Array([IRVar.kind]); }
-    meta;
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {
@@ -57,37 +51,15 @@ export class IRVar {
         // change parent
         this._parent = newParent;
     }
-    constructor(DeBruijn) {
-        Object.defineProperty(this, "meta", {
-            value: {},
-            writable: false,
-            enumerable: true,
-            configurable: false
-        });
-        this._hash = undefined;
-        DeBruijn = typeof DeBruijn === "number" ? DeBruijn : Number(DeBruijn);
-        this._dbn = DeBruijn;
-        // call setter to check for validity
-        this.dbn = DeBruijn;
-        this._parent = undefined;
-    }
+    children() { return []; }
     clone() {
-        return new IRVar(this.dbn);
+        return new IRVar(this.name, this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {
         return {
             type: "IRVar",
-            dbn: this.dbn
+            name: this.name
         };
     }
 }
-const _bdnVarHashCache = new Map();
-function getVarHashAtDbn(dbn) {
-    const cached = _bdnVarHashCache.get(dbn)?.deref();
-    if (isIRHash(cached))
-        return cached;
-    const hash = hashIrData(concatUint8Arr(IRVar.tag, positiveIntAsBytes(dbn)));
-    _bdnVarHashCache.set(dbn, new WeakRef(hash));
-    return hash;
-}

package/dist/IR/IRNodes/utils/dependsByDbns.d.ts

@@ -2,4 +2,4 @@ import { IRTerm } from "../../IRTerm.js";
 /**
  * returns true if the term depends on *ANY* of the deBrujin indices specified
  */
-export declare function dependsByDbns(term: IRTerm, depsDbns: readonly number[]): boolean;
+export declare function dependsByVars(term: IRTerm, depsVars: readonly symbol[]): boolean;

package/dist/IR/IRNodes/utils/dependsByDbns.js

@@ -4,20 +4,14 @@ import { IRVar } from "../IRVar.js";
 /**
  * returns true if the term depends on *ANY* of the deBrujin indices specified
  */
-export function dependsByDbns(term, depsDbns) {
-    if (depsDbns.length === 0)
+export function dependsByVars(term, depsVars) {
+    if (depsVars.length === 0)
         return false;
     let doesDepend = false;
     iterTree(term, (node, diff) => {
-        if (node instanceof IRVar ||
-            node instanceof IRSelfCall) {
-            doesDepend = doesDepend || depsDbns.some(dbn => {
-                const realDbn = dbn + diff;
-                // realDbn === 0 implies no variables are in scope
-                // so if node.dbn === 0 and realDbn === 1 then the 
-                // variable is pointing to that definition
-                return node.dbn === realDbn;
-            });
+        if (node instanceof IRVar
+            || node instanceof IRSelfCall) {
+            doesDepend = doesDepend || depsVars.some(sym => node.name === sym);
         }
     }, 
     // shouldSkipNode

package/dist/IR/IRNodes/utils/hashVarSym.d.ts

@@ -0,0 +1 @@
+export declare function hashVarSym(s: symbol): Uint8Array;

package/dist/IR/IRNodes/utils/hashVarSym.js

@@ -0,0 +1,37 @@
+// HASH GENERATOR
+import { fromHex } from "@harmoniclabs/uint8array-utils";
+const MAX_SAFE_INTEGER = Number(globalThis.Number?.MAX_SAFE_INTEGER ?? ((2 ** 53) - 1));
+const MIN_SAFE_INTEGER = Number(globalThis.Number?.MIN_SAFE_INTEGER ?? -MAX_SAFE_INTEGER);
+/// @ts-ignore Type 'symbol' does not satisfy the constraint 'object'.
+const _sym_to_hash = new WeakMap();
+// we cannot store the symbol itself as it would prevent garbage collection
+/// @ts-ignore Type 'symbol' does not satisfy the constraint 'object'.
+const _hash_to_sym = new Map();
+let _next_hash = MIN_SAFE_INTEGER;
+const unusedHashes = [];
+function _collectUnusedHashes() {
+    for (const [h, s] of _hash_to_sym) {
+        const newSymbol = s.deref();
+        if (!newSymbol
+            || !_sym_to_hash.has(newSymbol)) {
+            _hash_to_sym.delete(h);
+            unusedHashes.push(h);
+        }
+    }
+}
+export function hashVarSym(s) {
+    const limitReached = _next_hash >= MAX_SAFE_INTEGER;
+    if (_next_hash % 0xffff === 0
+        || limitReached)
+        _collectUnusedHashes();
+    if (limitReached
+        && unusedHashes.length <= 0)
+        throw new Error("ran out of IR hashes");
+    const result_hash = unusedHashes.shift() ?? _next_hash++;
+    _sym_to_hash.set(s, result_hash);
+    /// @ts-ignore Argument of type 'WeakRef<object>' is not assignable to parameter of type 'WeakRef<symbol>'
+    _hash_to_sym.set(result_hash, new WeakRef(s));
+    return fromHex((BigInt(result_hash) + BigInt(MAX_SAFE_INTEGER))
+        .toString(16)
+        .padStart(16, "0"));
+}

package/dist/IR/IRNodes/utils/makeArrayLikeProxy.d.ts

@@ -1 +1,2 @@
-export declare function makeArrayLikeProxy<T>(arr: ArrayLike<T>, isValidElem: (elem: T) => boolean, initModifyElem: (elem: T) => T, modifyElem: (elem: T, oldElem: T) => T): ArrayLike<T>;
+import { MutArrayLike } from "../../utils/MutArrayLike.js";
+export declare function makeArrayLikeProxy<T>(arr: ArrayLike<T>, isValidElem: (elem: T) => boolean, initModifyElem: (elem: T) => T, modifyElem: (elem: T, oldElem: T) => T): MutArrayLike<T>;

package/dist/IR/IRTerm.d.ts

@@ -12,4 +12,11 @@ import { IRConstr } from "./IRNodes/IRConstr.js";
 import { IRCase } from "./IRNodes/IRCase.js";
 import { IRRecursive } from "./IRNodes/IRRecursive.js";
 import { IRSelfCall } from "./IRNodes/IRSelfCall.js";
+import { IHash } from "./interfaces/index.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
+import { ToUplcCtx } from "./toUPLC/ctx/ToUplcCtx.js";
 export type IRTerm = IRVar | IRFunc | IRApp | IRConst | IRNative | IRLetted | IRHoisted | IRError | IRForced | IRDelayed | IRConstr | IRCase | IRRecursive | IRSelfCall;
+export interface IIRTerm extends IHash {
+    children(): IRTerm[];
+    toUPLC(ctx: ToUplcCtx): UPLCTerm;
+}

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

@@ -33,6 +33,10 @@ export interface CompilerOptions {
      * path to the output directory
      */
     readonly outDir: string;
+    /**
+     * if `true` silences all compiler output
+     */
+    readonly silent: boolean;
     /**
      * uplc version (encoded in the script)
      */
@@ -76,5 +80,6 @@ export declare const extremeOptions: CompilerOptions;
 export declare const productionOptions: CompilerOptions;
 export declare const debugOptions: CompilerOptions;
 export declare const defaultOptions: CompilerOptions;
+export declare const testOptions: CompilerOptions;
 export declare const defulatCompilerOptions: CompilerOptions;
 export declare function completeCompilerOptions(options: Partial<CompilerOptions>, complete?: CompilerOptions): CompilerOptions;

package/dist/IR/toUPLC/CompilerOptions.js

@@ -36,6 +36,7 @@ export const extremeOptions = Object.freeze({
     entry: "./src/index.pebble",
     root: ".",
     outDir: "./out",
+    silent: false,
     targetUplcVersion: defaultUplcVersion,
     removeTraces: true,
     delayHoists: true,
@@ -46,6 +47,7 @@ export const productionOptions = Object.freeze({
     entry: "./src/index.pebble",
     root: ".",
     outDir: "./out",
+    silent: false,
     targetUplcVersion: defaultUplcVersion,
     removeTraces: true,
     delayHoists: true,
@@ -56,13 +58,20 @@ export const debugOptions = Object.freeze({
     entry: "./src/index.pebble",
     root: ".",
     outDir: "./out",
+    silent: false,
     targetUplcVersion: defaultUplcVersion,
     removeTraces: false,
     delayHoists: false,
     uplcOptimizations: debugUplcOptimizations,
     addMarker: false
 });
-export const defaultOptions = productionOptions;
+export const defaultOptions = Object.freeze({
+    ...productionOptions,
+});
+export const testOptions = Object.freeze({
+    ...debugOptions,
+    silent: true
+});
 export const defulatCompilerOptions = defaultOptions;
 export function completeCompilerOptions(options, complete = defaultOptions) {
     let targetUplcVersion = options.targetUplcVersion instanceof UPLCVersion ? complete.targetUplcVersion : defaultUplcVersion;

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

@@ -138,4 +138,7 @@ export function _modifyChildFromTo(parent, currentChild, newChild) {
         parent.value = newChild;
         return;
     }
+    const tsEnsureExhaustiveCheck = parent;
+    throw new Error("unknown parent type in '_modifyChildFromTo': " +
+        parent.constructor?.name);
 }

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

@@ -1,11 +1,4 @@
-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";
 export function findAll(term, predicate) {
     const stack = [term];
     const result = [];
@@ -13,37 +6,7 @@ export function findAll(term, predicate) {
         const t = stack.pop();
         if (predicate(t))
             result.push(t);
-        if (t instanceof IRApp) {
-            stack.push(t.fn, t.arg);
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(t.delayed);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(t.forced);
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRHoisted) {
-            stack.push(t.hoisted);
-            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(t.value);
-            continue;
-        }
+        stack.push(...t.children());
     }
     return result;
 }
@@ -54,46 +17,12 @@ export function findAllNoHoisted(term, predicate) {
         const t = stack.pop();
         if (predicate(t))
             result.push(t);
-        if (t instanceof IRApp) {
-            stack.push(t.fn, t.arg);
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push(t.constrTerm, ...t.continuations);
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...t.fields);
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(t.delayed);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(t.forced);
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push(t.body);
-            continue;
-        }
         if (t instanceof IRHoisted) {
             // this is `findAllNoHoisted` remember?
             // stack.push( t.hoisted );
             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(t.value);
-            continue;
-        }
+        stack.push(...t.children());
     }
     return result;
 }

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

@@ -1,12 +1,7 @@
 import { equalIrHash } from "../../IRHash.js";
-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 { IRHoisted } from "../../IRNodes/index.js";
 import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
 import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-import { mapArrayLike } from "../../IRNodes/utils/mapArrayLike.js";
 export function getDebruijnInTerm(root, termToFind) {
     const termTofindHash = termToFind.hash;
     const stack = [{ term: root, dbn: 0 }];
@@ -14,38 +9,16 @@ export function getDebruijnInTerm(root, termToFind) {
         const { term, dbn } = stack.pop();
         if (term === termToFind || equalIrHash(term.hash, termTofindHash))
             return dbn;
-        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) {
+        if (term instanceof IRFunc
+            || term instanceof IRRecursive) {
+            // new variable in scope
             stack.push({ term: term.body, dbn: dbn + term.arity });
             continue;
         }
-        if (term instanceof IRRecursive) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
+        if (term instanceof IRHoisted) {
             continue;
-        }
-        if (term instanceof IRLetted) {
-            stack.push({ term: term.value, dbn });
-            continue;
-        }
+        } // skip hoisted since closed
+        stack.push(...term.children().map(t => ({ term: t, dbn })));
     }
     return -1;
 }

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

@@ -7,6 +7,7 @@ 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 { sanifyTree } from "../subRoutines/sanifyTree.js";
 export function iterTree(_term, fn, 
 // necessary for letted hash calculation (exclude hoisted)
 shouldSkipNode, shouldExit) {
@@ -32,31 +33,14 @@ shouldSkipNode, shouldExit) {
             continue;
         }
         if (t instanceof IRApp) {
-            // sanifyTree as we go
-            if (t.fn.parent !== t)
-                t.fn = t.fn.clone();
-            if (t.arg.parent !== t)
-                t.arg = t.arg.clone();
             stack.push({ term: t.fn, dbn }, { term: t.arg, dbn, shouldPopIfParentIsModified: true });
             continue;
         }
         if (t instanceof IRCase) {
-            // sanifyTree as we go
-            if (t.constrTerm.parent !== t)
-                t.constrTerm = t.constrTerm.clone();
-            for (let i = 0; i < t.continuations.length; i++) {
-                if (t.continuations[i].parent !== t)
-                    t.continuations[i] = t.continuations[i].clone();
-            }
             stack.push({ term: t.constrTerm, dbn }, ...Array.from(t.continuations).map(cont => ({ term: cont, dbn, shouldPopIfParentIsModified: true })));
             continue;
         }
         if (t instanceof IRConstr) {
-            // sanifyTree as we go
-            for (let i = 0; i < t.fields.length; i++) {
-                if (t.fields[i].parent !== t)
-                    t.fields[i] = t.fields[i].clone();
-            }
             stack.push(...Array.from(t.fields).map((f, i) => ({ term: f, dbn, shouldPopIfParentIsModified: i !== 0 })));
             continue;
         }
@@ -89,5 +73,7 @@ shouldSkipNode, shouldExit) {
             stack.push({ term: t.value, dbn });
             continue;
         }
+        stack.push(...t.children().map(c => ({ term: c, dbn })));
     }
+    sanifyTree(_term);
 }

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

@@ -0,0 +1,2 @@
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+export declare const hoisted_constr1_empty: IRHoisted;

package/dist/IR/toUPLC/common_hoisted.js

@@ -0,0 +1,4 @@
+import { DataConstr } from "@harmoniclabs/plutus-data";
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+import { IRConst } from "../IRNodes/IRConst.js";
+export const hoisted_constr1_empty = new IRHoisted(IRConst.data(new DataConstr(1, [])));

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

@@ -1,4 +1,4 @@
-import type { UPLCTerm } from "@harmoniclabs/uplc";
+import { type UPLCTerm } from "@harmoniclabs/uplc";
 import type { IRTerm } from "../IRTerm.js";
 import { CompilerOptions } from "./CompilerOptions.js";
 export declare function compileIRToUPLC(term: IRTerm, paritalOptions?: Partial<CompilerOptions>): UPLCTerm;