@harmoniclabs/pebble 0.1.2 → 0.1.3-dev1

package/dist/IR/IRNodes/IRConst.js

@@ -1,4 +1,3 @@
-import { Pair } from "@harmoniclabs/pair";
 import { isData, dataToCbor } from "@harmoniclabs/plutus-data";
 import { fromUtf8, toHex } from "@harmoniclabs/uint8array-utils";
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
@@ -11,7 +10,7 @@ import { TirAliasType } from "../../compiler/tir/types/TirAliasType.js";
 import { TirDataStructType, TirSoPStructType } from "../../compiler/tir/types/TirStructType.js";
 import { getListTypeArg } from "../../compiler/tir/types/utils/getListTypeArg.js";
 import { TirTypeParam } from "../../compiler/tir/types/TirTypeParam.js";
-import { constT, UPLCConst } from "@harmoniclabs/uplc";
+import { constT, isPair, UPLCConst } from "@harmoniclabs/uplc";
 import { TirPairDataT, TirUnConstrDataResultT } from "../../compiler/tir/types/TirNativeType/index.js";
 import { TirBoolT } from "../../compiler/tir/types/TirNativeType/native/bool.js";
 import { TirBytesT } from "../../compiler/tir/types/TirNativeType/native/bytes.js";
@@ -25,10 +24,9 @@ import { TirSopOptT } from "../../compiler/tir/types/TirNativeType/native/Option
 import { TirStringT } from "../../compiler/tir/types/TirNativeType/native/string.js";
 import { TirVoidT } from "../../compiler/tir/types/TirNativeType/native/void.js";
 import { hashIrData, isIRHash } from "../IRHash.js";
-import { ByteString } from "@harmoniclabs/bytestring";
 import { UPLCFlatUtils } from "../../utils/UPLCFlatUtils/index.js";
 export function isIRConstPair(value) {
-    return (value instanceof Pair &&
+    return (isPair(value) &&
         isIRConstValue(value.fst) &&
         isIRConstValue(value.snd));
 }
@@ -65,7 +63,7 @@ export class IRConst {
         const type = getUnaliased(this.type);
         if (type instanceof TirBytesT && this.value instanceof Uint8Array) {
             // make a copy to prevent external mutation
-            return new UPLCConst(tirTypeToUplcType(type), new ByteString(this.value));
+            return new UPLCConst(tirTypeToUplcType(type), this.value);
         }
         return new UPLCConst(tirTypeToUplcType(type), this.value);
     }
@@ -215,7 +213,7 @@ function serializeIRConstValue(value, type) {
     if (type instanceof TirDataT
         || type instanceof TirDataOptT
         || type instanceof TirDataStructType)
-        return dataToCbor(value).toBuffer();
+        return dataToCbor(value);
     if (type instanceof TirFuncT
         || type instanceof TirSopOptT
         || type instanceof TirSoPStructType

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -20,6 +20,7 @@ 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";
+import { ensureProperlyForcedBuiltinsAndReturnRoot } from "./subRoutines/performUplcOptimizationsAndReturnRoot/ensureProperlyForcedBuiltinsAndReturnRoot.js";
 export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // most of the time we are just compiling small
     // pre-execuded terms (hence constants)
@@ -144,6 +145,7 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // }
     term = removeUnusedVarsAndReturnRoot(term);
     term = performUplcOptimizationsAndReturnRoot(term, options);
+    term = ensureProperlyForcedBuiltinsAndReturnRoot(term);
     if (options.addMarker &&
         options.targetUplcVersion.major >= 1 &&
         options.targetUplcVersion.minor >= 1 &&

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

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

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

@@ -0,0 +1,163 @@
+import { IRConstr, IRNative } from "../../../IRNodes/index.js";
+import { IRApp } from "../../../IRNodes/IRApp.js";
+import { IRCase } from "../../../IRNodes/IRCase.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 { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { getApplicationTerms } from "../../utils/getApplicationTerms.js";
+import { getUnboundedVars } from "../handleLetted/groupByScope.js";
+import { getNRequiredForces } from "@harmoniclabs/uplc";
+export function ensureProperlyForcedBuiltinsAndReturnRoot(root) {
+    // const opts = options.uplcOptimizations;
+    // if( isDebugUplcOptimizations( opts ) ) return root;
+    // const {
+    //     groupApplications,
+    //     inlineSingleUse: shouldInlineSingleUse,
+    //     simplifyWrappedPartialFuncApps,
+    //     removeForceDelay
+    // } = opts;
+    const stack = [root];
+    let t = root;
+    while (t = stack.pop()) {
+        if (t instanceof IRNative) {
+            const expectedForces = getNRequiredForces(t.tag);
+            if (expectedForces <= 0)
+                continue;
+            let newNode = t;
+            let nDirectForces = 0;
+            // save the original parent before walking up through existing forces
+            // and before creating new IRForced wrappers (whose constructors
+            // overwrite the child's parent pointer)
+            const originalParent = t.parent;
+            while (t.parent instanceof IRForced) {
+                nDirectForces++;
+                t = t.parent;
+            }
+            if (nDirectForces === expectedForces)
+                continue;
+            // when nDirectForces > 0, t has walked up to the topmost IRForced;
+            // save its parent before wrapping overwrites parent pointers
+            const replaceInParent = nDirectForces > 0 ? t.parent : originalParent;
+            for (let i = 0; i < expectedForces - nDirectForces; i++) {
+                newNode = new IRForced(newNode);
+            }
+            if (replaceInParent)
+                _modifyChildFromTo(replaceInParent, t, newNode);
+            else
+                root = newNode;
+            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/performUplcOptimizationsAndReturnRoot/performUplcOptimizationsAndReturnRoot.js

@@ -89,6 +89,10 @@ function groupIndependentApplications(root) {
     if (!(func instanceof IRFunc))
         return undefined;
     const params = func.params.slice();
+    // Separate excess outer args: getApplicationTerms may return more args
+    // than func.params (e.g. `(λp. body)(arg1)(arg2)` → 2 args, 1 param).
+    // Excess args are trailing applications applied after all param bindings.
+    const trailingArgs = args.splice(params.length);
     while (true) {
         applicaitonTerms = getApplicationTerms(func.body);
         if (!applicaitonTerms)
@@ -96,14 +100,20 @@ function groupIndependentApplications(root) {
         if (!(applicaitonTerms.func instanceof IRFunc))
             break;
         func = applicaitonTerms.func;
+        const nNewParams = func.params.length;
+        const innerArgs = applicaitonTerms.args;
         params.push(...func.params);
-        args.push(...applicaitonTerms.args);
+        args.push(...innerArgs.slice(0, nNewParams));
+        // Inner excess args are applied before outer excess args
+        if (innerArgs.length > nNewParams) {
+            trailingArgs.unshift(...innerArgs.slice(nNewParams));
+        }
         if (params.length !== args.length)
             break;
     }
     const len = Math.min(params.length, args.length);
     const finalParams = params.slice(len);
-    const finalArgs = args.slice(len);
+    const finalArgs = [...args.slice(len), ...trailingArgs];
     params.length = len;
     args.length = len;
     const paramToArg = {};

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

@@ -11,6 +11,7 @@ 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_negateInteger: IRHoisted;
 export declare const hoisted_isPositive: IRHoisted;
 export declare const hoisted_isNonNegative: IRHoisted;
 export declare const hoisted_matchList: IRHoisted;

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

@@ -17,6 +17,7 @@ import { _ir_lazyChooseList } from "../../../tree_utils/_ir_lazyChooseList.js";
 import { _ir_lazyIfThenElse } from "../../../tree_utils/_ir_lazyIfThenElse.js";
 import { hoisted_drop4, hoisted_drop2, hoisted_drop3 } from "../_comptimeDropN.js";
 import { IRConstr } from "../../../IRNodes/index.js";
+import { _ir_and, _ir_or } from "../../../../compiler/tir/expressions/binary/TirBinaryExpr.js";
 function _ir_strictAnd(left, right) {
     return _ir_apps(IRNative.strictIfThenElse, left, right, IRConst.bool(false));
 }
@@ -43,6 +44,8 @@ export const hoisted_addOne = new IRHoisted(new IRApp(IRNative.addInteger, IRCon
 hoisted_addOne.hash;
 export const hoisted_subOne = new IRHoisted(new IRApp(IRNative.addInteger, IRConst.int(-1)));
 hoisted_subOne.hash;
+export const hoisted_negateInteger = new IRHoisted(new IRApp(IRNative.subtractInteger, IRConst.int(0)));
+hoisted_negateInteger.hash;
 export const hoisted_isPositive = new IRHoisted(new IRApp(IRNative.lessThanInteger, IRConst.int(0)));
 hoisted_isPositive.hash;
 export const hoisted_isNonNegative = new IRHoisted(new IRApp(IRNative.lessThanEqualInteger, IRConst.int(0)));
@@ -54,6 +57,7 @@ export const hoisted_matchList = new IRHoisted((() => {
     return new IRFunc([delayed_matchNil, matchCons, list], new IRForced(new IRForced(_ir_apps(IRNative.strictChooseList, new IRVar(list), new IRVar(delayed_matchNil), new IRDelayed(_ir_apps(new IRVar(matchCons), new IRApp(IRNative.headList, new IRVar(list)), new IRApp(IRNative.tailList, new IRVar(list))))))));
 })());
 hoisted_matchList.hash;
+//*
 // hoisted_recursiveList (needed by hoisted_foldr)
 const recList_matchNil = Symbol("matchNil");
 const recList_matchCons = Symbol("matchCons");
@@ -61,14 +65,15 @@ const recList_self = Symbol("recursiveList_self");
 const recList_lst = Symbol("lst");
 export const hoisted_recursiveList = new IRHoisted(new IRFunc([recList_matchNil, recList_matchCons], new IRRecursive(recList_self, new IRFunc([recList_lst], _ir_apps(hoisted_matchList.clone(), new IRApp(new IRVar(recList_matchNil), new IRSelfCall(recList_self)), new IRApp(new IRVar(recList_matchCons), new IRSelfCall(recList_self)), new IRVar(recList_lst))))));
 hoisted_recursiveList.hash;
+//*/
 // hoisted_foldr
-const foldr_reduce = Symbol("reduceFunc");
+const foldr_reducer = Symbol("reduceFunc");
 const foldr_acc = Symbol("accumulator");
 const foldr__dummy = Symbol("_self");
 const foldr_self = Symbol("self");
 const foldr_head = Symbol("head");
 const foldr_tail = Symbol("tail");
-export const hoisted_foldr = new IRHoisted(new IRFunc([foldr_reduce, foldr_acc], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([foldr__dummy], new IRDelayed(new IRVar(foldr_acc))), new IRFunc([foldr_self, foldr_head, foldr_tail], _ir_apps(new IRVar(foldr_reduce), new IRVar(foldr_head), new IRApp(new IRVar(foldr_self), new IRVar(foldr_tail)))))));
+export const hoisted_foldr = new IRHoisted(new IRFunc([foldr_reducer, foldr_acc], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([foldr__dummy], new IRDelayed(new IRVar(foldr_acc))), new IRFunc([foldr_self, foldr_head, foldr_tail], _ir_apps(new IRVar(foldr_reducer), new IRVar(foldr_head), new IRApp(new IRVar(foldr_self), new IRVar(foldr_tail)))))));
 hoisted_foldr.hash;
 export const hosited_lazyChooseList = new IRHoisted((() => {
     const list = Symbol("list");
@@ -142,19 +147,25 @@ export const hoisted_strictOr = new IRHoisted(new IRFunc([strictOr_a, strictOr_b
 hoisted_strictOr.hash;
 // hoisted _some
 const some_pred = Symbol("predicate");
-const some_dummy = Symbol("_self");
+const some_lst = Symbol("lst");
 const some_self = Symbol("self");
-const some_head = Symbol("head");
-const some_tail = Symbol("tail");
-export const hoisted_some = new IRHoisted(new IRFunc([some_pred], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([some_dummy], new IRDelayed(IRConst.bool(false))), new IRFunc([some_self, some_head, some_tail], new IRForced(_ir_apps(hoisted_strictOr.clone(), new IRDelayed(new IRApp(new IRVar(some_pred), new IRVar(some_head))), new IRDelayed(new IRApp(new IRVar(some_self), new IRVar(some_tail)))))))));
+export const hoisted_some = new IRHoisted(new IRFunc([some_pred], new IRRecursive(some_self, new IRFunc([some_lst], _ir_lazyChooseList(new IRVar(some_lst), IRConst.bool(false), // case nil => false
+_ir_or(
+// either predicate(head) is true
+_ir_apps(new IRVar(some_pred), new IRApp(IRNative.headList, new IRVar(some_lst))), 
+// or self(tail) is true
+_ir_apps(new IRSelfCall(some_self), new IRApp(IRNative.tailList, new IRVar(some_lst)))))))));
 hoisted_some.hash;
 // hoisted _every
 const every_pred = Symbol("predicate");
-const every_dummy = Symbol("_self");
 const every_self = Symbol("self");
-const every_head = Symbol("head");
-const every_tail = Symbol("tail");
-export const hoisted_every = new IRHoisted(new IRFunc([every_pred], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([every_dummy], new IRDelayed(IRConst.bool(true))), new IRFunc([every_self, every_head, every_tail], new IRForced(_ir_apps(hoisted_strictAnd.clone(), new IRDelayed(new IRApp(new IRVar(every_pred), new IRVar(every_head))), new IRDelayed(new IRApp(new IRVar(every_self), new IRVar(every_tail)))))))));
+const every_lst = Symbol("lst");
+export const hoisted_every = new IRHoisted(new IRFunc([every_pred], new IRRecursive(every_self, new IRFunc([every_lst], _ir_lazyChooseList(new IRVar(every_lst), IRConst.bool(true), // case nil => true
+_ir_and(
+// both predicate(head) is true
+_ir_apps(new IRVar(every_pred), new IRApp(IRNative.headList, new IRVar(every_lst))), 
+// AND self(tail) is true
+_ir_apps(new IRSelfCall(every_self), new IRApp(IRNative.tailList, new IRVar(every_lst)))))))));
 hoisted_every.hash;
 // hoisted _filter
 const filt_pred = Symbol("predicate");
@@ -249,6 +260,11 @@ export function nativeToIR(native) {
         case IRNativeTag._mkMapList: return hoisted_mkMapList.clone();
         case IRNativeTag._increment: return hoisted_addOne.clone();
         case IRNativeTag._decrement: return hoisted_subOne.clone();
+        // case IRNativeTag._bytesToIntBE: ;
+        // case IRNativeTag._equalBoolean: ;
+        // case IRNativeTag._equalPairData: ;
+        case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
+        case IRNativeTag._negateInt: return hoisted_negateInteger.clone();
         // case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         default:
             throw new Error("unknown (negative) native calling 'nativeToIR'; " +

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -333,9 +333,15 @@ export class AstCompiler extends DiagnosticEmitter {
         if (!funcExpr)
             return undefined;
         this.program.functions.set(tirFuncName, funcExpr);
+        this.program.functions.set(astFuncName, funcExpr);
         if (topLevelScope.functions.has(astFuncName))
             return this.error(DiagnosticCode._0_is_already_defined, astFuncExpr.name.range, astFuncName);
         topLevelScope.functions.set(astFuncName, tirFuncName);
+        topLevelScope.defineValue({
+            isConstant: true,
+            name: astFuncName,
+            type: funcExpr.type,
+        });
         if (exportRange && srcExports) {
             if (srcExports.functions.has(astFuncName)
                 || srcExports.variables.has(astFuncName))

package/dist/compiler/AstCompiler/internal/_deriveContractBody/_deriveContractBody.js

@@ -32,6 +32,7 @@ import { StructConstrDecl, StructDecl, StructDeclAstFlags } from "../../../../as
 import { NamedDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js";
 import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
 import { SingleDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SingleDeconstructVarDecl.js";
+import { isVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/VarDecl.js";
 import { EmptyStmt } from "../../../../ast/nodes/statements/EmptyStmt.js";
 import { FailStmt } from "../../../../ast/nodes/statements/FailStmt.js";
 import { ForOfStmt } from "../../../../ast/nodes/statements/ForOfStmt.js";
@@ -379,7 +380,9 @@ renamedVariables = {}) {
 function _getMatchedRedeemerBlockStatements(compiler, stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables) {
     const result = stmts.slice();
     for (let i = 0; i < result.length; i++) {
-        const stmt = result[i];
+        let stmt = result[i];
+        if (isVarDecl(stmt))
+            stmt = new VarStmt([stmt], stmt.range);
         if (stmt instanceof VarStmt) {
             if (stmt.declarations.length !== 1) {
                 for (const varDecl of stmt.declarations) {
@@ -587,6 +590,7 @@ function _getMatchedRedeemerBlockStatements(compiler, stmts, paramsInternalNames
             continue;
         }
         const tsEnsureExhaustiveCheck = stmt;
+        console.error(stmt);
         throw new Error("unreachable::_getMatchedRedeemerBlockStatements::stmt::");
     }
     return result;

package/dist/compiler/Compiler.d.ts

@@ -8,6 +8,7 @@ export declare class Compiler extends DiagnosticEmitter {
     constructor(io?: CompilerIoApi, cfg?: CompilerOptions, diagnostics?: DiagnosticMessage[]);
     compile(config?: Partial<CompilerOptions>): Promise<Uint8Array>;
     export(config: Partial<ExportOptions> & HasFuncitonName): Promise<Uint8Array>;
+    private _compileBackend;
 }
 interface HasFuncitonName {
     functionName: string;

package/dist/compiler/Compiler.js

@@ -34,16 +34,7 @@ export class Compiler extends DiagnosticEmitter {
             }
             throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
         }
-        // backend starts here
-        const ir = compileTypedProgram(cfg, program);
-        const uplc = compileIRToUPLC(ir);
-        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc)).toBuffer().buffer;
-        const outDir = cfg.outDir;
-        const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
-        this.io.writeFile(outPath, serialized, cfg.root);
-        this.io.stdout.write(`compiled program written to ${outPath}\n`);
-        __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
-        return serialized;
+        return this._compileBackend(cfg, program);
     }
     async export(config) {
         const cfg = {
@@ -67,10 +58,13 @@ export class Compiler extends DiagnosticEmitter {
             }
             throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
         }
+        return this._compileBackend(cfg, program);
+    }
+    _compileBackend(cfg, program) {
         // backend starts here
         const ir = compileTypedProgram(cfg, program);
         const uplc = compileIRToUPLC(ir, cfg);
-        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc)).toBuffer().buffer;
+        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc));
         const outDir = cfg.outDir;
         const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
         this.io.writeFile(outPath, serialized, cfg.root);

package/dist/compiler/TirCompiler/expressify/ExpressifyCtx.js

@@ -51,12 +51,16 @@ export class ExpressifyCtx {
         this.properties = properties;
         this.hoisted = (hoisted
             ?? this.parent?.hoisted
-            ?? new Map([...program.constants.entries()].map(([name, decl]) => {
+            ?? new Map([...program.constants.entries()]
+                .map(([name, decl]) => {
                 if (!decl.initExpr)
                     throw new Error(`expected init expr in hoisted constant '${name}'`);
                 const expr = decl.initExpr instanceof TirHoistedExpr ? decl.initExpr : new TirHoistedExpr(name, decl.initExpr);
                 return [name, expr];
-            })));
+            })
+                .concat([...program.functions.entries()].map(([name, func]) => {
+                return [name, new TirHoistedExpr(name, func)];
+            }))));
     }
     allVariablesNoLetted() {
         return (this.parent?.allVariablesNoLetted() ?? []).concat(...this.variables.keys());
@@ -119,7 +123,7 @@ export class ExpressifyCtx {
         const result = (this._getNonHoistedVariable(name)
             ?? this.hoisted.get(name));
         if (!result) {
-            console.log("[error log]: allVariables", this.allVariables());
+            console.log("[error log]: allVariables", this.allVariables(), "; get:", name);
             throw new Error(`variable '${name}' not found in the context`);
         }
         return result;

package/dist/compiler/tir/expressions/TirNativeFunc.js

@@ -117,7 +117,7 @@ export class TirNativeFunc {
             int_t
         ], bool_t));
     }
-    // ByteString operations
+    // bytes operations
     static get appendByteString() {
         return new TirNativeFunc(IRNativeTag.appendByteString, new TirFuncT([
             // left
@@ -512,7 +512,7 @@ export class TirNativeFunc {
             bytes_t
         ], bytes_t));
     }
-    // ByteString manipulation
+    // bytes manipulation
     static get integerToByteString() {
         return new TirNativeFunc(IRNativeTag.integerToByteString, new TirFuncT([
             // flag
@@ -585,7 +585,7 @@ export class TirNativeFunc {
             bool_t
         ], bytes_t));
     }
-    // Additional ByteString operations
+    // Additional bytes operations
     static get replicateByte() {
         return new TirNativeFunc(IRNativeTag.replicateByte, new TirFuncT([
             // count

package/dist/index.d.ts

@@ -1,7 +1,5 @@
-export * from "@harmoniclabs/bytestring";
 export * from "@harmoniclabs/cbor";
 export * from "@harmoniclabs/obj-utils";
-export * from "@harmoniclabs/pair";
 export * from "@harmoniclabs/plutus-data";
 export * from "@harmoniclabs/plutus-machine";
 export * from "@harmoniclabs/uint8array-utils";

package/dist/index.js

@@ -1,7 +1,5 @@
-export * from "@harmoniclabs/bytestring";
 export * from "@harmoniclabs/cbor";
 export * from "@harmoniclabs/obj-utils";
-export * from "@harmoniclabs/pair";
 export * from "@harmoniclabs/plutus-data";
 export * from "@harmoniclabs/plutus-machine";
 export * from "@harmoniclabs/uint8array-utils";

package/dist/parser/Parser.js

@@ -72,6 +72,7 @@ import { Precedence, determinePrecedence } from "./Precedence.js";
 import { LitFailExpr } from "../ast/nodes/expr/litteral/LitFailExpr.js";
 import { ContractDecl } from "../ast/nodes/statements/declarations/ContractDecl.js";
 import { LitContextExpr } from "../ast/nodes/expr/litteral/LitContextExpr.js";
+import { tokenIsAlsoIdentifier } from "../tokenizer/utils/tokenIsAlsoIdentifier.js";
 export class Parser extends DiagnosticEmitter {
     tn;
     constructor(tokenizer, diagnostics = undefined) {
@@ -833,6 +834,12 @@ export class Parser extends DiagnosticEmitter {
     _parseVarDecl(flags, skipTypeAndInitializer = false) {
         const tn = this.tn;
         // ConstrName{ ... } || renamed
+        const identifierToken = tn.peek();
+        if (identifierToken !== Token.Identifier
+            && identifierToken !== Token.OpenBrace // valid var destructuring (single constr obj)
+            && identifierToken !== Token.OpenBracket // valid var destructuring (array-like)
+            && !tokenIsAlsoIdentifier(identifierToken))
+            return this.error(DiagnosticCode._0_keyword_cannot_be_used_here, tn.range(tn.nextTokenPos, tn.nextToken), Token[identifierToken]);
         const renamedField = this.parseIdentifier();
         if (tn.skip(Token.OpenBrace)) // ConstrName{ ... } || { ... }
          {

package/dist/parser/parseFile.d.ts

@@ -1,3 +1,5 @@
 import type { Source } from "../ast/Source/Source.js";
-export declare function parseFile(path: string, src: string, getUid?: () => string, isEntry?: boolean): [Source, import("../diagnostics/DiagnosticMessage.js").DiagnosticMessage[]];
-export declare function parseSource(src: Source): import("../diagnostics/DiagnosticMessage.js").DiagnosticMessage[];
+import { DiagnosticMessage } from "../diagnostics/DiagnosticMessage.js";
+export declare function parseFilePure(path: string, src: string, getUid?: () => string, isEntry?: boolean): [Source, DiagnosticMessage[]];
+export declare function parseFile(path: string, src: string, getUid?: () => string, isEntry?: boolean): Source;
+export declare function parseSource(src: Source): DiagnosticMessage[];

package/dist/parser/parseFile.js

@@ -1,8 +1,15 @@
 import { defaultSymbolForge } from "../compiler/internalVar.js";
 import { Parser } from "./Parser.js";
-export function parseFile(path, src, getUid = defaultSymbolForge.getUid.bind(defaultSymbolForge), isEntry = false) {
+export function parseFilePure(path, src, getUid = defaultSymbolForge.getUid.bind(defaultSymbolForge), isEntry = false) {
     return Parser.parseFile(path, src, getUid, isEntry);
 }
+export function parseFile(path, src, getUid = defaultSymbolForge.getUid.bind(defaultSymbolForge), isEntry = false) {
+    const [source, diagnostics] = Parser.parseFile(path, src, getUid, isEntry);
+    if (diagnostics.length > 0) {
+        throw new Error(`Parsing errors:\n${diagnostics.map(d => d.toString()).join("\n")}`);
+    }
+    return source;
+}
 export function parseSource(src) {
     return Parser.parseSource(src);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.2",
+  "version": "0.1.3-dev1",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -51,25 +51,22 @@
   "homepage": "https://github.com/HarmonicLabs/pebble#readme",
   "dependencies": {
     "@harmoniclabs/bigint-utils": "^1.0.0",
-    "@harmoniclabs/bytestring": "^1.0.0",
-    "@harmoniclabs/cbor": "^1.6.6",
+    "@harmoniclabs/cardano-costmodels-ts": "^1.4.0",
+    "@harmoniclabs/cbor": "^2.0.1",
     "@harmoniclabs/crypto": "^0.3.0",
     "@harmoniclabs/obj-utils": "^1.0.0",
-    "@harmoniclabs/pair": "^1.0.0",
-    "@harmoniclabs/plutus-data": "^1.2.6",
-    "@harmoniclabs/plutus-machine": "^2.1.1",
+    "@harmoniclabs/plutus-data": "^2.0.1",
+    "@harmoniclabs/plutus-machine": "^3.0.0",
     "@harmoniclabs/uint8array-utils": "^1.0.4",
-    "@harmoniclabs/uplc": "^1.4.1"
+    "@harmoniclabs/uplc": "^2.0.5"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.18.6",
     "@babel/preset-typescript": "^7.18.6",
-    "@harmoniclabs/cardano-costmodels-ts": "^1.3.0",
-    "@harmoniclabs/cardano-ledger-ts": "^0.3.2",
     "@types/jest": "^28.1.4",
     "@types/node": "^18.14.6",
     "jest": "^29.4.3",
-    "jest-environment-jsdom": "^29.4.3",
+    "jest-environment-jsdom": "^30.3.0",
     "tsc-alias": "^1.7.1",
     "typescript": "^4.6.3"
   },