@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev4

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,320 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,15 @@
+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

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

package/dist/compiler/TirCompiler/index.js

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

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,36 @@
+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

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

package/dist/compiler/index.js

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