@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

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

@@ -1,15 +0,0 @@
-import { TirTernaryExpr } from "../../tir/expressions/TirTernaryExpr.js";
-import { TirBlockStmt } from "../../tir/statements/TirBlockStmt.js";
-import { expressifyFuncBody } from "./expressify.js";
-import { expressifyVars } from "./expressifyVars.js";
-export function expressifyTerminatingIfStmt(parentCtx, stmt, loopReplacements) {
-    if (!stmt.elseBranch)
-        throw new Error("Terminating if statement must have an else branch.");
-    const thenBranch = stmt.thenBranch instanceof TirBlockStmt ?
-        stmt.thenBranch.stmts.slice() :
-        [stmt.thenBranch];
-    const elseBranch = stmt.elseBranch instanceof TirBlockStmt ?
-        stmt.elseBranch.stmts.slice() :
-        [stmt.elseBranch];
-    return new TirTernaryExpr(expressifyVars(parentCtx, stmt.condition), expressifyFuncBody(parentCtx.newChild(), thenBranch, loopReplacements), expressifyFuncBody(parentCtx.newChild(), elseBranch, loopReplacements), parentCtx.returnType, stmt.range);
-}

package/dist/compiler/TirCompiler/expressify/expressifyVarAssignmentStmt.d.ts

@@ -1,4 +0,0 @@
-import { TirAssignmentStmt } from "../../tir/statements/TirAssignmentStmt.js";
-import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
-import { ExpressifyCtx } from "./ExpressifyCtx.js";
-export declare function expressifyVarAssignmentStmt(ctx: ExpressifyCtx, stmt: TirAssignmentStmt): TirSimpleVarDecl;

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

@@ -1,20 +0,0 @@
-import { getUniqueInternalName } from "../../internalVar.js";
-import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.js";
-import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
-import { expressifyVars } from "./expressifyVars.js";
-export function expressifyVarAssignmentStmt(ctx, stmt) {
-    const assignedExpr = expressifyVars(ctx, stmt.assignedExpr);
-    const originalName = stmt.varIdentifier.resolvedValue.variableInfos.name;
-    const latestVarNameSSA = ctx.variables.get(originalName);
-    if (!latestVarNameSSA) {
-        throw new Error("re-assigning constant variable");
-    }
-    const newUniqueName = getUniqueInternalName(originalName);
-    latestVarNameSSA.latestName = newUniqueName;
-    // point to the same object
-    ctx.variables.set(newUniqueName, latestVarNameSSA);
-    ctx.lettedConstants.set(newUniqueName, new TirLettedExpr(newUniqueName, assignedExpr, stmt.range));
-    // will replace re-assignment in body
-    return new TirSimpleVarDecl(newUniqueName, stmt.varIdentifier.resolvedValue.variableInfos.type, assignedExpr, true, // isConst
-    stmt.range);
-}

package/dist/compiler/TirCompiler/expressify/expressifyVarDecl.d.ts

@@ -1,3 +0,0 @@
-import { TirVarDecl } from "../../tir/statements/TirVarDecl/TirVarDecl.js";
-import { ExpressifyCtx } from "./ExpressifyCtx.js";
-export declare function expressifyVarDecl(ctx: ExpressifyCtx, stmt: TirVarDecl): void;

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

@@ -1,34 +0,0 @@
-import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.js";
-import { TirArrayLikeDeconstr } from "../../tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
-import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
-import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
-import { TirSingleDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js";
-import { expressifyVars } from "./expressifyVars.js";
-export function expressifyVarDecl(ctx, stmt) {
-    const isConst = stmt.isConst;
-    if (stmt.initExpr)
-        expressifyVars(ctx, stmt.initExpr);
-    if (stmt instanceof TirSimpleVarDecl) {
-        if (stmt.isConst) {
-            void ctx.variables.set(stmt.name, { latestName: stmt.name });
-            /// @ts-ignore Cannot assign to 'isConst' because it is a read-only property.
-            stmt.isConst = true;
-        }
-        ctx.lettedConstants.set(stmt.name, new TirLettedExpr(stmt.name, stmt.initExpr, stmt.range));
-    }
-    if (stmt instanceof TirNamedDeconstructVarDecl
-        || stmt instanceof TirSingleDeconstructVarDecl) {
-        for (const [_field, varDecl] of stmt.fields)
-            expressifyVarDecl(ctx, varDecl);
-        if (stmt.rest)
-            ctx.variables.set(stmt.rest, { latestName: stmt.rest });
-        return;
-    }
-    if (stmt instanceof TirArrayLikeDeconstr) {
-        for (const varDecl of stmt.elements)
-            expressifyVarDecl(ctx, varDecl);
-        if (stmt.rest)
-            ctx.variables.set(stmt.rest, { latestName: stmt.rest });
-        return;
-    }
-}

package/dist/compiler/TirCompiler/expressify/expressifyVars.d.ts

@@ -1,10 +0,0 @@
-import { TirExpr } from "../../tir/expressions/TirExpr.js";
-import { ExpressifyCtx } from "./ExpressifyCtx.js";
-/**
- * Side effect: modifies the expression in place if possible.
- *
- * **ASSUME THE INPUT EXPRESSION IS INVALID AFTER THIS FUNCTION CALL.**
- *
- * @returns a the modified expression
-**/
-export declare function expressifyVars(ctx: ExpressifyCtx, expr: TirExpr): TirExpr;

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

@@ -1,320 +0,0 @@
-import { isUnaryPrefixExpr } from "../../../ast/nodes/expr/unary/UnaryPrefixExpr.js";
-import { isTirBinaryExpr } from "../../tir/expressions/binary/TirBinaryExpr.js";
-import { TirLitArrExpr } from "../../tir/expressions/litteral/TirLitArrExpr.js";
-import { TirLitFalseExpr } from "../../tir/expressions/litteral/TirLitFalseExpr.js";
-import { TirLitHexBytesExpr } from "../../tir/expressions/litteral/TirLitHexBytesExpr.js";
-import { TirLitIntExpr } from "../../tir/expressions/litteral/TirLitIntExpr.js";
-import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
-import { TirLitObjExpr } from "../../tir/expressions/litteral/TirLitObjExpr.js";
-import { TirLitStrExpr } from "../../tir/expressions/litteral/TirLitStrExpr.js";
-import { TirLitThisExpr } from "../../tir/expressions/litteral/TirLitThisExpr.js";
-import { TirLitTrueExpr } from "../../tir/expressions/litteral/TirLitTrueExpr.js";
-import { TirLitUndefExpr } from "../../tir/expressions/litteral/TirLitUndefExpr.js";
-import { TirLitVoidExpr } from "../../tir/expressions/litteral/TirLitVoidExpr.js";
-import { TirAssertAndContinueExpr } from "../../tir/expressions/TirAssertAndContinueExpr.js";
-import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
-import { TirCaseExpr, TirCaseMatcher } from "../../tir/expressions/TirCaseExpr.js";
-import { TirElemAccessExpr } from "../../tir/expressions/TirElemAccessExpr.js";
-import { TirFailExpr } from "../../tir/expressions/TirFailExpr.js";
-import { TirFromDataExpr } from "../../tir/expressions/TirFromDataExpr.js";
-import { TirFuncExpr } from "../../tir/expressions/TirFuncExpr.js";
-import { TirHoistedExpr } from "../../tir/expressions/TirHoistedExpr.js";
-import { TirInlineClosedIR } from "../../tir/expressions/TirInlineClosedIR.js";
-import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.js";
-import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
-import { TirParentesizedExpr } from "../../tir/expressions/TirParentesizedExpr.js";
-import { TirPropAccessExpr } from "../../tir/expressions/TirPropAccessExpr.js";
-import { TirTernaryExpr } from "../../tir/expressions/TirTernaryExpr.js";
-import { TirToDataExpr } from "../../tir/expressions/TirToDataExpr.js";
-import { TirTraceIfFalseExpr } from "../../tir/expressions/TirTraceIfFalseExpr.js";
-import { TirTypeConversionExpr } from "../../tir/expressions/TirTypeConversionExpr.js";
-import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
-import { TirUnaryExclamation } from "../../tir/expressions/unary/TirUnaryExclamation.js";
-import { TirUnaryMinus } from "../../tir/expressions/unary/TirUnaryMinus.js";
-import { TirUnaryPlus } from "../../tir/expressions/unary/TirUnaryPlus.js";
-import { TirUnaryTilde } from "../../tir/expressions/unary/TirUnaryTilde.js";
-import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.js";
-import { TirArrayLikeDeconstr } from "../../tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
-import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
-import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
-import { getUnaliased } from "../../tir/types/utils/getUnaliased.js";
-import { expressify, expressifyFuncBody } from "./expressify.js";
-import { isExpressifyFuncParam } from "./ExpressifyCtx.js";
-import { flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct } from "./flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct.js";
-import { isSingleConstrStruct } from "./isSingleConstrStruct.js";
-import { toNamedDeconstructVarDecl } from "./toNamedDeconstructVarDecl.js";
-/**
- * Side effect: modifies the expression in place if possible.
- *
- * **ASSUME THE INPUT EXPRESSION IS INVALID AFTER THIS FUNCTION CALL.**
- *
- * @returns a the modified expression
-**/
-export function expressifyVars(ctx, expr) {
-    if (
-    // isTirLitteralExpr( expr )
-    expr instanceof TirLitVoidExpr
-        || expr instanceof TirLitUndefExpr
-        || expr instanceof TirLitTrueExpr
-        || expr instanceof TirLitFalseExpr
-        || expr instanceof TirLitThisExpr
-        || expr instanceof TirLitArrExpr
-        || expr instanceof TirLitObjExpr
-        || expr instanceof TirLitNamedObjExpr
-        || expr instanceof TirLitStrExpr
-        || expr instanceof TirLitIntExpr
-        || expr instanceof TirLitHexBytesExpr
-        || expr instanceof TirNativeFunc
-        // hoisted expressions are necessarily closed, so no external variables
-        || expr instanceof TirHoistedExpr)
-        return expr;
-    // every property access must be replaced with a variable access (or similar)
-    // that is either letted/hoisted/nativeFunc/varAccess expression
-    //
-    // we don't have property access in TermIR (or UPLC)
-    if (expr instanceof TirPropAccessExpr) {
-        const objectExpr = expressifyVars(ctx, expr.object);
-        expr.object = objectExpr;
-        return getVarAccessFromPropAccess(ctx, expr);
-    }
-    if (expr instanceof TirVariableAccessExpr) {
-        const originalVarName = expr.resolvedValue.variableInfos.name;
-        const resolvedVariable = ctx.getVariable(originalVarName);
-        if (!resolvedVariable)
-            return expr; // variable not found, keep the original expression
-        if (isExpressifyFuncParam(resolvedVariable)) {
-            // variable was shadowed
-            expr.resolvedValue.variableInfos.name = resolvedVariable.name;
-            return expr;
-        }
-        // resovledVariable instanceof TirVariableAccessExpr
-        return resolvedVariable;
-    }
-    if (isUnaryPrefixExpr(expr)) {
-        const modifiedExpr = expressifyVars(ctx, expr.operand);
-        expr.operand = modifiedExpr;
-        return expr;
-    }
-    if (expr instanceof TirParentesizedExpr
-        || expr instanceof TirTypeConversionExpr) {
-        const modifiedExpr = expressifyVars(ctx, expr.expr);
-        expr.expr = modifiedExpr;
-        return expr;
-    }
-    if (expr instanceof TirFuncExpr) {
-        expressify(expr, undefined, ctx);
-        return expr;
-    }
-    if (expr instanceof TirCallExpr) {
-        const func = expressifyVars(ctx, expr.func);
-        expr.func = func;
-        for (let i = 0; i < expr.args.length; i++) {
-            const arg = expressifyVars(ctx, expr.args[i]);
-            expr.args[i] = arg;
-        }
-        return expr;
-    }
-    if (expr instanceof TirCaseExpr) {
-        const matchExpr = expressifyVars(ctx, expr.matchExpr);
-        expr.matchExpr = matchExpr;
-        for (let i = 0; i < expr.cases.length; i++) {
-            const c = expr.cases[i];
-            const branchCtx = ctx.newChild();
-            if (c.pattern instanceof TirArrayLikeDeconstr)
-                throw new Error("case expression not yet supported for array-like deconstruction");
-            const pattern = toNamedDeconstructVarDecl(c.pattern);
-            const branchBodyStmts = flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(pattern, branchCtx);
-            branchBodyStmts.push(new TirReturnStmt(c.body, c.body.range));
-            c.body = expressifyFuncBody(branchCtx, branchBodyStmts, undefined);
-        }
-        return expr;
-    }
-    if (expr instanceof TirElemAccessExpr) {
-        const arrExpr = expressifyVars(ctx, expr.arrLikeExpr);
-        const indexExpr = expressifyVars(ctx, expr.indexExpr);
-        expr.arrLikeExpr = arrExpr;
-        expr.indexExpr = indexExpr;
-        return expr;
-    }
-    if (expr instanceof TirTernaryExpr) {
-        const condition = expressifyVars(ctx, expr.condition);
-        const ifTrue = expressifyVars(ctx, expr.ifTrue);
-        const ifFalse = expressifyVars(ctx, expr.ifFalse);
-        expr.condition = condition;
-        expr.ifTrue = ifTrue;
-        expr.ifFalse = ifFalse;
-        return expr;
-    }
-    if (isTirBinaryExpr(expr)) {
-        const left = expressifyVars(ctx, expr.left);
-        const right = expressifyVars(ctx, expr.right);
-        expr.left = left;
-        expr.right = right;
-        return expr;
-    }
-    if (expr instanceof TirLettedExpr) {
-        const modifiedExpr = expressifyVars(ctx, expr.expr);
-        expr.expr = modifiedExpr;
-        return expr;
-    }
-    if (expr instanceof TirFromDataExpr) {
-        const modifiedExpr = expressifyVars(ctx, expr.dataExpr);
-        expr.dataExpr = modifiedExpr;
-        return expr;
-    }
-    if (expr instanceof TirFailExpr) {
-        if (expr.failMsgExpr) {
-            const modifiedExpr = expressifyVars(ctx, expr.failMsgExpr);
-            expr.failMsgExpr = modifiedExpr;
-        }
-        return expr;
-    }
-    //  TirInlineClosedIR
-    if (expr instanceof TirToDataExpr) {
-        const modifiedExpr = expressifyVars(ctx, expr.expr);
-        expr.expr = modifiedExpr;
-        return expr;
-    }
-    if (expr instanceof TirAssertAndContinueExpr) {
-        expr.conditions;
-        expr.continuation;
-        const modifiedConditions = expr.conditions.map(c => expressifyVars(ctx, c));
-        const modifiedContinuation = expressifyVars(ctx, expr.continuation);
-        expr.conditions = modifiedConditions;
-        expr.continuation = modifiedContinuation;
-        return expr;
-    }
-    if (expr instanceof TirTraceIfFalseExpr) {
-        const modifiedCondition = expressifyVars(ctx, expr.condition);
-        const modifiedTraceStrExpr = expressifyVars(ctx, expr.traceStrExpr);
-        expr.condition = modifiedCondition;
-        expr.traceStrExpr = modifiedTraceStrExpr;
-        return expr;
-    }
-    if (expr instanceof TirInlineClosedIR)
-        return expr;
-    const tsEnsureExsautstiveCheck = expr;
-    console.error(expr);
-    throw new Error("unreachable::expressifyVars");
-}
-function getVarAccessFromPropAccess(ctx, propAccessExpr) {
-    let expr = propAccessExpr.object;
-    const prop = propAccessExpr.prop.text;
-    while (expr instanceof TirParentesizedExpr)
-        expr = expr.expr;
-    if (expr instanceof TirLitVoidExpr
-        || expr instanceof TirLitUndefExpr
-        || expr instanceof TirLitTrueExpr
-        || expr instanceof TirLitFalseExpr
-        // methods on these should have already been converted to functions
-        || expr instanceof TirLitArrExpr
-        || expr instanceof TirLitStrExpr
-        || expr instanceof TirLitIntExpr
-        || expr instanceof TirLitHexBytesExpr
-        || expr instanceof TirNativeFunc
-        || expr instanceof TirPropAccessExpr // `expressifyVars` is called recursively on the object before this check
-        // these result to native types
-        || expr instanceof TirUnaryExclamation // boolean
-        || expr instanceof TirUnaryPlus // int
-        || expr instanceof TirUnaryMinus // int
-        || expr instanceof TirUnaryTilde // bytes
-        || expr instanceof TirFuncExpr // functions have no properties
-        || expr instanceof TirParentesizedExpr // typescript being stupid
-        || isTirBinaryExpr(expr) // all of these return either int, bytes or boolean
-        // TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirInlineClosedIR
-        || expr instanceof TirAssertAndContinueExpr
-        || expr instanceof TirTraceIfFalseExpr
-        || expr instanceof TirInlineClosedIR)
-        throw new Error("Invalid property access expression");
-    if (expr instanceof TirLitThisExpr) {
-        let varName = ctx.properties.get("this")?.get(prop);
-        if (!varName)
-            throw new Error(`Property '${prop}' does not exist on 'this'`);
-        varName = ctx.variables.get(varName)?.latestName ?? varName;
-        const expr = ctx.getVariable(varName);
-        if (isExpressifyFuncParam(expr)) {
-            return new TirVariableAccessExpr({
-                variableInfos: {
-                    name: expr.name,
-                    type: expr.type,
-                    isConstant: true,
-                },
-                isDefinedOutsideFuncScope: false,
-            }, propAccessExpr.range);
-        }
-        return expr;
-    }
-    if (expr instanceof TirLitObjExpr
-        || expr instanceof TirLitNamedObjExpr) {
-        const valIdx = expr.fieldNames.findIndex(f => f.text === prop);
-        if (valIdx < 0)
-            throw new Error(`Property '${prop}' does not exist on object literal`);
-        return expr.values[valIdx];
-    }
-    if (expr instanceof TirHoistedExpr
-        || expr instanceof TirLettedExpr
-        || expr instanceof TirVariableAccessExpr
-        // all of these are valid property access expressions
-        // and we need to inspect the return type to check if the property exists
-        || expr instanceof TirCallExpr
-        || expr instanceof TirCaseExpr
-        || expr instanceof TirTypeConversionExpr
-        || expr instanceof TirElemAccessExpr
-        || expr instanceof TirTernaryExpr
-        || expr instanceof TirFromDataExpr
-        || expr instanceof TirFailExpr
-        || expr instanceof TirToDataExpr) {
-        if (expr instanceof TirHoistedExpr
-            || expr instanceof TirLettedExpr
-            || expr instanceof TirVariableAccessExpr) {
-            let varName = ctx.properties.get(expr.varName)?.get(prop);
-            if (varName) {
-                varName = ctx.variables.get(varName)?.latestName ?? varName;
-                const result = ctx.getVariable(varName);
-                if (isExpressifyFuncParam(result)) {
-                    return new TirVariableAccessExpr({
-                        variableInfos: {
-                            name: result.name,
-                            type: result.type,
-                            isConstant: true,
-                        },
-                        isDefinedOutsideFuncScope: false,
-                    }, propAccessExpr.range);
-                }
-                return result;
-            }
-            // if there is no property in the context
-            // we extract the property inplace below (outside this block)
-        }
-        const objType = getUnaliased(expr.type);
-        if (!isSingleConstrStruct(objType)) {
-            console.log(objType);
-            throw new Error("cannot access property on non-struct type");
-        }
-        const ctor = objType.constructors[0];
-        const fIdx = ctor.fields.findIndex(f => f.name === prop);
-        if (fIdx < 0)
-            throw new Error(`Property '${prop}' does not exist on type '${objType.toString()}'`);
-        const fName = ctor.fields[fIdx].name;
-        const fType = ctor.fields[fIdx].type;
-        return new TirCaseExpr(expr, [
-            new TirCaseMatcher(new TirNamedDeconstructVarDecl(ctor.name, new Map([
-                [fName, new TirSimpleVarDecl(fName, fType, undefined, true, propAccessExpr.range)]
-            ]), undefined, // rest
-            expr.type, undefined, // init expr
-            true, // isConst
-            propAccessExpr.range), new TirVariableAccessExpr({
-                variableInfos: {
-                    name: fName,
-                    type: fType,
-                    isConstant: true,
-                },
-                isDefinedOutsideFuncScope: false,
-            }, propAccessExpr.range), propAccessExpr.range)
-        ], undefined, // wildcard case
-        fType, propAccessExpr.range);
-    }
-    ;
-    const tsEnsureExsautstiveCheck = expr;
-    throw new Error("Invalid property access expression");
-}

package/dist/compiler/TirCompiler/expressify/flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct.d.ts

@@ -1,9 +0,0 @@
-import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
-import { TirSingleDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js";
-import { TirVarDecl } from "../../tir/statements/TirVarDecl/TirVarDecl.js";
-import { ExpressifyCtx } from "./ExpressifyCtx.js";
-/**
- *
- * @returns the extracted nested deconstructions
- */
-export declare function flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(decl: TirNamedDeconstructVarDecl | TirSingleDeconstructVarDecl, ctx: ExpressifyCtx): TirVarDecl[];

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

@@ -1,59 +0,0 @@
-import { getUniqueInternalName } from "../../internalVar.js";
-import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
-import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
-import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
-import { getUnaliased } from "../../tir/types/utils/getUnaliased.js";
-import { isSingleConstrStruct } from "./isSingleConstrStruct.js";
-/**
- *
- * @returns the extracted nested deconstructions
- */
-export function flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(decl, ctx) {
-    const extracted = [];
-    const restFields = new Map();
-    for (const [fName, varDecl] of decl.fields) {
-        if (varDecl instanceof TirSimpleVarDecl) {
-            restFields.set(fName, varDecl.name);
-            ctx.introduceFuncParams([varDecl]);
-            if (isSingleConstrStruct(varDecl.type)) {
-                const structType = getUnaliased(varDecl.type);
-                const constr = structType.constructors[0];
-                extracted.push(new TirNamedDeconstructVarDecl(constr.name, new Map(constr.fields.map(f => [
-                    f.name,
-                    new TirSimpleVarDecl(getUniqueInternalName(f.name), f.type, undefined, // no init expr
-                    varDecl.isConst, varDecl.range)
-                ])), undefined, // no rest field
-                varDecl.type, 
-                // init expr
-                new TirVariableAccessExpr({
-                    variableInfos: {
-                        name: varDecl.name,
-                        type: varDecl.type,
-                        isConstant: varDecl.isConst,
-                    },
-                    isDefinedOutsideFuncScope: false,
-                }, varDecl.range), varDecl.isConst, varDecl.range));
-            }
-            continue;
-        }
-        const newFieldUniqueName = getUniqueInternalName(fName);
-        const fieldAsSimpleVarDecl = new TirSimpleVarDecl(newFieldUniqueName, varDecl.type, varDecl.initExpr, varDecl.isConst, varDecl.range);
-        decl.fields.set(fName, fieldAsSimpleVarDecl);
-        ctx.introduceFuncParams([fieldAsSimpleVarDecl]);
-        restFields.set(fName, newFieldUniqueName);
-        varDecl.initExpr = new TirVariableAccessExpr({
-            variableInfos: {
-                name: newFieldUniqueName,
-                type: varDecl.type,
-                isConstant: varDecl.isConst,
-            },
-            isDefinedOutsideFuncScope: false,
-        }, varDecl.range);
-        extracted.push(varDecl);
-    }
-    if (decl.rest) {
-        ctx.properties.set(decl.rest, restFields);
-        // ctx.introduceFuncParams([ decl.rest ]);
-    }
-    return extracted;
-}

package/dist/compiler/TirCompiler/expressify/isSingleConstrStruct.d.ts

@@ -1,3 +0,0 @@
-import { TirSoPStructType, TirDataStructType } from "../../tir/types/TirStructType.js";
-import { TirType } from "../../tir/types/TirType.js";
-export declare function isSingleConstrStruct(type: TirType): type is (TirSoPStructType | TirDataStructType);

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

@@ -1,9 +0,0 @@
-import { TirSoPStructType, TirDataStructType } from "../../tir/types/TirStructType.js";
-import { getUnaliased } from "../../tir/types/utils/getUnaliased.js";
-export function isSingleConstrStruct(type) {
-    type = getUnaliased(type);
-    if (!(type instanceof TirSoPStructType
-        || type instanceof TirDataStructType))
-        return false;
-    return type.constructors.length === 1;
-}

package/dist/compiler/TirCompiler/expressify/toNamedDeconstructVarDecl.d.ts

@@ -1,3 +0,0 @@
-import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
-import { TirSingleDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js";
-export declare function toNamedDeconstructVarDecl(varDecl: TirSingleDeconstructVarDecl | TirNamedDeconstructVarDecl): TirNamedDeconstructVarDecl;

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

@@ -1,15 +0,0 @@
-import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
-import { TirSingleDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js";
-import { isSingleConstrStruct } from "./isSingleConstrStruct.js";
-export function toNamedDeconstructVarDecl(varDecl) {
-    if (varDecl instanceof TirNamedDeconstructVarDecl)
-        return varDecl;
-    if (varDecl instanceof TirSingleDeconstructVarDecl) {
-        const declType = varDecl.type;
-        if (!isSingleConstrStruct(declType))
-            throw new Error("expected single constr struct type in single deconstruct var decl");
-        const singleConstrName = declType.constructors[0].name;
-        return new TirNamedDeconstructVarDecl(singleConstrName, varDecl.fields, varDecl.rest, varDecl.type, varDecl.initExpr, varDecl.isConst, varDecl.range);
-    }
-    throw new Error("unreachable::toNamedDeconstructVarDecl");
-}

package/dist/compiler/TirCompiler/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./compileTirProgram.js";
-export * from "./TirCompilerCtx.js";

package/dist/compiler/TirCompiler/index.js

@@ -1,2 +0,0 @@
-export * from "./compileTirProgram.js";
-export * from "./TirCompilerCtx.js";

package/dist/compiler/TirCompiler/internal/_compileHoistedDeps.d.ts

@@ -1,5 +0,0 @@
-import { TirHoistedExpr } from "../../tir/expressions/TirHoistedExpr.js";
-import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
-import { TypedProgram } from "../../tir/program/TypedProgram.js";
-import { DepsNode } from "./deps/DepsNode.js";
-export declare function _compileHoistedDeps(program: TypedProgram, hoistedMap: Map<string, TirHoistedExpr | TirNativeFunc>, deps: string[], depsStack: DepsNode): void;

package/dist/compiler/TirCompiler/internal/_compileHoistedDeps.js

@@ -1,37 +0,0 @@
-import { TirHoistedExpr } from "../../tir/expressions/TirHoistedExpr.js";
-import { ExpressifyCtx } from "../expressify/ExpressifyCtx.js";
-import { expressifyVars } from "../expressify/expressifyVars.js";
-export function _compileHoistedDeps(program, hoistedMap, deps, depsStack) {
-    let depName;
-    if (deps.some(dep => depsStack.includes(dep)))
-        throw new Error("Circular dependency in hoisted expressions NOT YET IMPLEMENTED");
-    while (depName = deps.pop()) {
-        const funcDecl = program.functions.get(depName);
-        if (funcDecl) {
-            _compileHoistedDeps(program, hoistedMap, funcDecl.deps(), depsStack.getNext(depName));
-            /*
-            const funcExpr = funcDecl instanceof TirInlineClosedIR ? funcDecl : expressify(
-                funcDecl,
-                undefined, // loopReplacements
-                new ExpressifyCtx(
-                    undefined,
-                    funcDecl.returnType,
-                    hoistedMap
-                )
-            );
-            //*/
-            const hoistedExpr = new TirHoistedExpr(depName, funcDecl);
-            hoistedMap.set(depName, hoistedExpr);
-            continue;
-        }
-        const constDecl = program.constants.get(depName);
-        if (constDecl) {
-            _compileHoistedDeps(program, hoistedMap, constDecl.deps(), depsStack.getNext(depName));
-            const expr = expressifyVars(new ExpressifyCtx(undefined, constDecl.type, hoistedMap), constDecl);
-            const hoistedExpr = new TirHoistedExpr(depName, expr);
-            hoistedMap.set(depName, hoistedExpr);
-            continue;
-        }
-        throw new Error(`Hoisted dependency "${depName}" not found in program`);
-    }
-}

package/dist/compiler/TirCompiler/internal/deps/DepsNode.d.ts

@@ -1,13 +0,0 @@
-export declare class DepsNode {
-    readonly parent: DepsNode | undefined;
-    readonly dependent: string;
-    constructor(parent: DepsNode | undefined, dependent: string);
-    static entry(dependent: string): DepsNode;
-    getNext(dependent: string): DepsNode;
-    includes(elem: string): boolean;
-    /**
-     *
-     * @returns an array of hoisted names from the last to the first.
-     */
-    toArray(): string[];
-}

package/dist/compiler/TirCompiler/internal/deps/DepsNode.js

@@ -1,36 +0,0 @@
-export class DepsNode {
-    parent;
-    dependent;
-    constructor(parent, dependent) {
-        this.parent = parent;
-        this.dependent = dependent;
-    }
-    static entry(dependent) {
-        return new DepsNode(undefined, dependent);
-    }
-    getNext(dependent) {
-        return new DepsNode(this, dependent);
-    }
-    includes(elem) {
-        let req = this;
-        while (req) {
-            if (req.dependent === elem)
-                return true;
-            req = req.parent;
-        }
-        return false;
-    }
-    /**
-     *
-     * @returns an array of hoisted names from the last to the first.
-     */
-    toArray() {
-        const arr = [];
-        let req = this;
-        while (req) {
-            arr.push(req.dependent);
-            req = req.parent;
-        }
-        return arr;
-    }
-}

package/dist/compiler/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./Compiler.js";
-export * from "./AstCompiler/index.js";
-export * from "./TirCompiler/index.js";
-export * from "./io/index.js";

package/dist/compiler/index.js

@@ -1,4 +0,0 @@
-export * from "./Compiler.js";
-export * from "./AstCompiler/index.js";
-export * from "./TirCompiler/index.js";
-export * from "./io/index.js";