@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

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

@@ -0,0 +1,282 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { getUniqueInternalName } from "../../internalVar.js";
+import { TirEqualExpr } from "../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirLitIntExpr } from "../../tir/expressions/litteral/TirLitIntExpr.js";
+import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
+import { TirElemAccessExpr } from "../../tir/expressions/TirElemAccessExpr.js";
+import { TirFromDataExpr } from "../../tir/expressions/TirFromDataExpr.js";
+import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.js";
+import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
+import { data_t, int_t } from "../../tir/program/stdScope/stdScope.js";
+import { TirAssertStmt } from "../../tir/statements/TirAssertStmt.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 { TirDataStructType } from "../../tir/types/TirStructType.js";
+import { isTirType } from "../../tir/types/TirType.js";
+import { getListTypeArg } from "../../tir/types/utils/getListTypeArg.js";
+import { toNamedDeconstructVarDecl } from "./toNamedDeconstructVarDecl.js";
+import { TirUnConstrDataResultT } from "../../tir/types/TirNativeType/index.js";
+import { TirListT } from "../../tir/types/TirNativeType/native/list.js";
+export function isExpressifyFuncParam(thing) {
+    return isObject(thing) && (typeof thing.name === "string"
+        && isTirType(thing.type));
+}
+export class ExpressifyCtx {
+    parent;
+    returnType;
+    variables;
+    funcParams;
+    lettedConstants;
+    properties;
+    hoisted;
+    constructor(parent, returnType, hoisted, 
+    /** var name -> latest constant name */
+    variables = new Map(), 
+    /** constant name -> func param name (to build var access) */
+    funcParams = new Map(), 
+    /** constant name -> letted expr */
+    lettedConstants = new Map(), 
+    /** var name -> prop name -> constant name (letted field extraction expr or var access for SoP)*/
+    properties = new Map()) {
+        this.parent = parent;
+        this.returnType = returnType;
+        this.variables = variables;
+        this.funcParams = funcParams;
+        this.lettedConstants = lettedConstants;
+        this.properties = properties;
+        this.hoisted = hoisted ?? this.parent?.hoisted ?? new Map();
+    }
+    newChild() {
+        return new ExpressifyCtx(this, this.returnType);
+    }
+    setNewVariableName(oldName, newName) {
+        let latestNameSSA = this.variables.get(oldName);
+        if (!latestNameSSA)
+            this.variables.set(oldName, { latestName: newName });
+        else
+            latestNameSSA.latestName = newName;
+    }
+    setFuncParam(name, type) {
+        this.variables.set(name, { latestName: name });
+        this.funcParams.set(name, { name, type });
+    }
+    /**
+     * `undefined` means the variable is not in the local context.
+     */
+    getLocalVariable(name) {
+        // declared as constant shortcut
+        const constResult = this.lettedConstants.get(name);
+        if (constResult)
+            return constResult;
+        // declared as variable or param
+        const latestConstName = this.variables.get(name)?.latestName;
+        // no such variable
+        if (!latestConstName)
+            return undefined;
+        return (this.lettedConstants.get(latestConstName)
+            ?? this.funcParams.get(latestConstName));
+    }
+    /**
+     *
+     * `undefined` means the variable is not in the function context.
+     *
+     * so it is assumed to be an external (hoisted) variable.
+     */
+    _getNonHoistedVariable(name) {
+        return (this.getLocalVariable(name)
+            ?? this.parent?._getNonHoistedVariable(name));
+    }
+    getVariable(name) {
+        const result = (this._getNonHoistedVariable(name)
+            ?? this.hoisted.get(name));
+        if (!result) {
+            console.log(this);
+            throw new Error(`variable '${name}' not found in the context`);
+        }
+        return result;
+    }
+    introduceFuncParams(params) {
+        for (const param of params) {
+            param.isConst = true;
+            this.setFuncParam(param.name, param.type);
+        }
+    }
+    introduceLettedConstant(name, lettedExpr, declRange) {
+        const result = new TirLettedExpr(name, lettedExpr, declRange);
+        this.lettedConstants.set(name, result);
+        return result.unsafeClone();
+    }
+    introduceSopConstrFieldsAsProperties(sopName, destructuredPattern) {
+        const fieldsMap = new Map();
+        for (const [fName, varDecl] of destructuredPattern.fields) {
+            if (!(varDecl instanceof TirSimpleVarDecl))
+                throw new Error("expected simple var decl in single constr field extraction");
+            this.setFuncParam(varDecl.name, varDecl.type);
+            fieldsMap.set(fName, varDecl.name);
+        }
+        this.properties.set(sopName, fieldsMap);
+    }
+    introduceSopConstrFieldsAsParamsOnly(destructuredPattern) {
+        for (const [fName, varDecl] of destructuredPattern.fields) {
+            if (!(varDecl instanceof TirSimpleVarDecl))
+                throw new Error("expected simple var decl in single constr field extraction");
+            this.setFuncParam(varDecl.name, varDecl.type);
+        }
+    }
+    introduceSingleConstrDataLettedFields(varName, structExpr, structType) {
+        const constr = structType.constructors[0];
+        if (constr.fields.length === 0)
+            return; // no fields to extract
+        const lettedRawFieldsName = getUniqueInternalName(`${varName}_fields`);
+        const lettedFields = this.introduceLettedConstant(lettedRawFieldsName, new TirCallExpr(TirNativeFunc.unConstrDataResultFields, [new TirCallExpr(TirNativeFunc.unConstrData, [structExpr], new TirUnConstrDataResultT(), structExpr.range)], new TirListT(data_t), structExpr.range), structExpr.range);
+        const fieldsMap = new Map();
+        for (let i = 0; i < constr.fields.length; i++) {
+            const field = constr.fields[i];
+            const fieldName = field.name;
+            const fieldVarName = getUniqueInternalName(`${varName}_${fieldName}`);
+            const fieldType = field.type;
+            const lettedField = this.introduceLettedConstant(fieldVarName, 
+            // FieldType.fromData( lettedFields[i] )
+            new TirFromDataExpr(new TirElemAccessExpr(lettedFields, new TirLitIntExpr(BigInt(i), structExpr.range), data_t, structExpr.range), fieldType, structExpr.range), structExpr.range);
+            fieldsMap.set(fieldName, fieldVarName);
+            // data structs cannot have sop-encoded fields (thanks god)
+            // recursively introduce letted fields for nested single-constructor data structs
+            if (fieldType instanceof TirDataStructType
+                && fieldType.constructors.length === 1) {
+                this.introduceSingleConstrDataLettedFields(fieldVarName, lettedField, fieldType);
+            }
+        }
+        this.properties.set(varName, fieldsMap);
+    }
+    introduceDeconstrDataLettedFields(stmt) {
+        const structType = stmt.type;
+        if (!(stmt.initExpr))
+            throw new Error("expected init expr in deconstruct data statement");
+        if (!(structType instanceof TirDataStructType))
+            throw new Error("expected data struct type in deconstruct data statement");
+        const varName = getUniqueInternalName(structType.toString().toLowerCase());
+        const constrName = stmt.constrName;
+        const constrIdx = structType.constructors.findIndex(c => c.name === constrName);
+        if (constrIdx < 0)
+            throw new Error(`constructor ${constrName} not found in data struct ${structType.name}`);
+        const constr = structType.constructors[constrIdx];
+        if (constr.fields.length === 0)
+            return []; // no fields to extract, no assertions
+        const structExpr = stmt.initExpr;
+        const lettedUnconstrName = getUniqueInternalName(`${varName}_unconstrPair`);
+        const lettedUnconstr = this.introduceLettedConstant(lettedUnconstrName, new TirCallExpr(TirNativeFunc.unBData, [stmt.initExpr], new TirUnConstrDataResultT(), stmt.range), stmt.range);
+        const assertions = [];
+        if (structType.constructors.length > 0)
+            assertions.push(new TirAssertStmt(new TirEqualExpr(new TirCallExpr(TirNativeFunc.unConstrDataResultIndex, [lettedUnconstr], int_t, stmt.range), new TirLitIntExpr(BigInt(constrIdx), stmt.range), stmt.range), undefined, // no trace message
+            stmt.range));
+        const lettedRawFieldsName = getUniqueInternalName(`${varName}_fields`);
+        const lettedFields = this.introduceLettedConstant(lettedRawFieldsName, new TirCallExpr(TirNativeFunc.unConstrDataResultFields, [lettedUnconstr], new TirListT(data_t), stmt.range), stmt.range);
+        const fieldsToIntroduce = [...stmt.fields.keys()];
+        const hasRest = typeof stmt.rest === "string";
+        const fieldsMap = new Map();
+        for (let i = 0; i < constr.fields.length; i++) {
+            const field = constr.fields[i];
+            const fieldName = field.name;
+            const fieldType = field.type;
+            const isFieldToIntroduce = fieldsToIntroduce.includes(fieldName);
+            if (!hasRest && !isFieldToIntroduce)
+                continue; // skip unused field
+            const fieldVarDecl = stmt.fields.get(fieldName);
+            const fieldVarName = getUniqueInternalName(`${varName}_${fieldName}`);
+            const lettedField = this.introduceLettedConstant(fieldVarName, 
+            // FieldType.fromData( lettedFields[i] )
+            new TirFromDataExpr(new TirElemAccessExpr(lettedFields, new TirLitIntExpr(BigInt(i), structExpr.range), data_t, structExpr.range), fieldType, structExpr.range), structExpr.range);
+            if (hasRest)
+                fieldsMap.set(fieldName, fieldVarName);
+            if (!isFieldToIntroduce) {
+                continue; // we only needed to add it as "rest"
+            }
+            if (!fieldVarDecl)
+                throw new Error(`field '${fieldName}' not found in deconstruct data statement`);
+            if (fieldVarDecl instanceof TirSimpleVarDecl) {
+                this.variables.set(fieldVarDecl.name, { latestName: lettedField.varName });
+            }
+            // data structs cannot have sop-encoded fields (thanks god)
+            // recursively introduce letted fields for nested single-constructor data structs
+            if (!(fieldType instanceof TirDataStructType))
+                continue;
+            // if the field is simply introduced but still a single constr struct
+            // we need to introduce its fields as well
+            if (fieldVarDecl instanceof TirSimpleVarDecl
+                && fieldType.constructors.length === 1) {
+                this.introduceSingleConstrDataLettedFields(fieldVarName, lettedField, fieldType);
+            }
+            else if (fieldVarDecl instanceof TirNamedDeconstructVarDecl
+                || fieldVarDecl instanceof TirSingleDeconstructVarDecl) {
+                // if the field is destructured, we need to introduce its fields as well
+                const namedVarDecl = toNamedDeconstructVarDecl(fieldVarDecl);
+                namedVarDecl.initExpr = lettedField;
+                assertions.push(...this.introduceDeconstrDataLettedFields(namedVarDecl));
+            }
+            else if (fieldVarDecl instanceof TirArrayLikeDeconstr) {
+                fieldVarDecl.initExpr = lettedField;
+                assertions.push(...this.introduceArrayDeconstr(fieldVarDecl, true // is destructured field
+                ));
+            }
+        }
+        if (hasRest)
+            this.properties.set(stmt.rest, fieldsMap);
+        return assertions;
+    }
+    introduceArrayDeconstr(stmt, isDestructuredField = false) {
+        if (!(stmt.initExpr))
+            throw new Error("expected init expr in array-like deconstruct statement");
+        const elemsType = getListTypeArg(stmt.type);
+        if (!elemsType)
+            throw new Error("expected list type in array-like deconstruct statement");
+        let lettedArrayExpr;
+        if (stmt.initExpr instanceof TirLettedExpr) {
+            lettedArrayExpr = stmt.initExpr;
+        }
+        else {
+            const lettedArrayName = getUniqueInternalName(stmt.type.toString().toLowerCase());
+            lettedArrayExpr = this.introduceLettedConstant(lettedArrayName, stmt.initExpr, stmt.range);
+        }
+        const assertions = [];
+        const nElems = stmt.elements.length;
+        for (let i = 0; i < nElems; i++) {
+            const elemVarDecl = stmt.elements[i];
+            const lettedElemName = getUniqueInternalName(`${lettedArrayExpr.varName}_elem_${i}`);
+            let lettedExpr = new TirElemAccessExpr(lettedArrayExpr, new TirLitIntExpr(BigInt(i), elemVarDecl.range), isDestructuredField ? data_t : elemVarDecl.type, elemVarDecl.range);
+            if (isDestructuredField)
+                lettedExpr = new TirFromDataExpr(lettedExpr, elemVarDecl.type, elemVarDecl.range);
+            const lettedElem = this.introduceLettedConstant(lettedElemName, lettedExpr, elemVarDecl.range);
+            if (elemVarDecl instanceof TirSimpleVarDecl) {
+                this.variables.set(elemVarDecl.name, { latestName: lettedElem.varName });
+                if (lettedElem.type instanceof TirDataStructType
+                    && lettedElem.type.constructors.length === 1) {
+                    // if the element is a single-constructor data struct,
+                    // we need to introduce its fields as well
+                    this.introduceSingleConstrDataLettedFields(elemVarDecl.name, lettedElem, lettedElem.type);
+                }
+            }
+            else if (elemVarDecl instanceof TirNamedDeconstructVarDecl
+                || elemVarDecl instanceof TirSingleDeconstructVarDecl) {
+                const namedVarDecl = toNamedDeconstructVarDecl(elemVarDecl);
+                namedVarDecl.initExpr = lettedElem;
+                assertions.push(...this.introduceDeconstrDataLettedFields(namedVarDecl));
+            }
+            else if (elemVarDecl instanceof TirArrayLikeDeconstr) {
+                elemVarDecl.initExpr = lettedElem;
+                assertions.push(...this.introduceArrayDeconstr(elemVarDecl, true // is destructured field
+                ));
+            }
+        }
+        if (stmt.rest) {
+            if (isDestructuredField)
+                throw new Error("rest is not implemented in destructured field array-like deconstruct. TODO: map data elems to elem type");
+            const lettedRest = this.introduceLettedConstant(stmt.rest, new TirCallExpr(TirNativeFunc._dropList(elemsType), [
+                new TirLitIntExpr(BigInt(nElems), stmt.range),
+                lettedArrayExpr
+            ], new TirListT(elemsType), stmt.range), stmt.range);
+        }
+        return assertions;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
+import { TirBlockStmt } from "../../tir/statements/TirBlockStmt.js";
+import { TirForStmt } from "../../tir/statements/TirForStmt.js";
+import { TirStmt } from "../../tir/statements/TirStmt.js";
+import { TirSoPStructType } from "../../tir/types/TirStructType.js";
+import { ExpressifyCtx } from "./ExpressifyCtx.js";
+export interface ReassignedVariablesAndReturn {
+    reassigned: string[];
+    returns: boolean;
+}
+export interface ReassignedVariablesAndFlowInfos extends ReassignedVariablesAndReturn {
+    canContinue: boolean;
+    canBreak: boolean;
+}
+export declare function determineReassignedVariablesAndReturn(stmt: TirStmt): ReassignedVariablesAndReturn;
+export declare function determineReassignedVariablesAndFlowInfos(stmt: TirStmt): ReassignedVariablesAndFlowInfos;
+export declare function definitelyFails(stmt: TirStmt | TirBlockStmt): boolean;
+export interface BranchStmtSopAndInitState {
+    sop: TirSoPStructType;
+    initState: TirLitNamedObjExpr;
+}
+export declare function getBranchStmtReturnType({ reassigned, returns }: ReassignedVariablesAndReturn, ctx: ExpressifyCtx, stmtRange: SourceRange): BranchStmtSopAndInitState;
+export declare function getBodyStateType({ sop, initState }: BranchStmtSopAndInitState, stmt: TirForStmt): {
+    bodyStateType: TirSoPStructType;
+    initState: TirLitNamedObjExpr;
+};

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

@@ -0,0 +1,248 @@
+import { Identifier } from "../../../ast/nodes/common/Identifier.js";
+import { keepSortedStrArrInplace } from "../../../utils/array/keepSortedArrInplace.js";
+import { getUniqueInternalName } from "../../internalVar.js";
+import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
+import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
+import { TirAssertStmt } from "../../tir/statements/TirAssertStmt.js";
+import { TirAssignmentStmt } from "../../tir/statements/TirAssignmentStmt.js";
+import { TirBlockStmt } from "../../tir/statements/TirBlockStmt.js";
+import { TirBreakStmt } from "../../tir/statements/TirBreakStmt.js";
+import { TirContinueStmt } from "../../tir/statements/TirContinueStmt.js";
+import { TirFailStmt } from "../../tir/statements/TirFailStmt.js";
+import { TirForOfStmt } from "../../tir/statements/TirForOfStmt.js";
+import { TirForStmt } from "../../tir/statements/TirForStmt.js";
+import { TirIfStmt } from "../../tir/statements/TirIfStmt.js";
+import { TirMatchStmt } from "../../tir/statements/TirMatchStmt.js";
+import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.js";
+import { isTirVarDecl } from "../../tir/statements/TirVarDecl/TirVarDecl.js";
+import { TirWhileStmt } from "../../tir/statements/TirWhileStmt.js";
+import { TirSoPStructType, TirStructConstr, TirStructField } from "../../tir/types/TirStructType.js";
+import { isExpressifyFuncParam } from "./ExpressifyCtx.js";
+export function determineReassignedVariablesAndReturn(stmt) {
+    const originalStmtDeps = stmt.deps();
+    const stack = [stmt];
+    const reassignedSet = new Set();
+    let returns = false;
+    while (stmt = stack.pop()) {
+        if (stmt instanceof TirFailStmt
+            || isTirVarDecl(stmt)
+            || stmt instanceof TirBreakStmt
+            || stmt instanceof TirContinueStmt
+            || stmt instanceof TirAssertStmt)
+            continue;
+        if (stmt instanceof TirReturnStmt) {
+            returns = true;
+            continue;
+        }
+        if (stmt instanceof TirAssignmentStmt) {
+            reassignedSet.add(stmt.varIdentifier.varName);
+            continue;
+        }
+        if (stmt instanceof TirBlockStmt) {
+            stack.push(...stmt.stmts);
+            continue;
+        }
+        if (stmt instanceof TirIfStmt) {
+            stack.push(stmt.thenBranch);
+            if (stmt.elseBranch)
+                stack.push(stmt.elseBranch);
+            continue;
+        }
+        if (stmt instanceof TirMatchStmt) {
+            for (const caseStmt of stmt.cases) {
+                stack.push(caseStmt.body);
+            }
+            continue;
+        }
+        if (stmt instanceof TirForStmt) {
+            stack.push(stmt.body);
+            if (stmt.update)
+                stack.push(...stmt.update);
+            continue;
+        }
+        if (stmt instanceof TirForOfStmt
+            || stmt instanceof TirWhileStmt) {
+            stack.push(stmt.body);
+            continue;
+        }
+        const tsEnsureExsaustiveCheck = stmt;
+    }
+    let reassigned = [...reassignedSet].sort();
+    reassigned = keepSortedStrArrInplace(reassigned, originalStmtDeps);
+    return {
+        reassigned,
+        returns
+    };
+}
+export function determineReassignedVariablesAndFlowInfos(stmt) {
+    const originalStmtDeps = stmt.deps();
+    const stack = [stmt];
+    const reassignedSet = new Set();
+    let returns = false;
+    let canBreak = false;
+    let canContinue = false;
+    while (stmt = stack.pop()) {
+        if (stmt instanceof TirFailStmt
+            || isTirVarDecl(stmt)
+            || stmt instanceof TirBreakStmt
+            || stmt instanceof TirContinueStmt
+            || stmt instanceof TirAssertStmt)
+            continue;
+        if (stmt instanceof TirBreakStmt) {
+            canBreak = true;
+            continue;
+        }
+        if (stmt instanceof TirContinueStmt) {
+            canContinue = true;
+            continue;
+        }
+        if (stmt instanceof TirReturnStmt) {
+            returns = true;
+            continue;
+        }
+        if (stmt instanceof TirAssignmentStmt) {
+            reassignedSet.add(stmt.varIdentifier.varName);
+            continue;
+        }
+        if (stmt instanceof TirBlockStmt) {
+            stack.push(...stmt.stmts);
+            continue;
+        }
+        if (stmt instanceof TirIfStmt) {
+            stack.push(stmt.thenBranch);
+            if (stmt.elseBranch)
+                stack.push(stmt.elseBranch);
+            continue;
+        }
+        if (stmt instanceof TirMatchStmt) {
+            for (const caseStmt of stmt.cases) {
+                stack.push(caseStmt.body);
+            }
+            continue;
+        }
+        // for loop statements
+        // we are only intersted in eventual reassignments and returns
+        // 
+        // if conitnue or break statements are present there
+        // they refer to the inner loop itself, not to this outer loop
+        if (stmt instanceof TirForStmt) {
+            const reassignedAndReturn = determineReassignedVariablesAndReturn(stmt.body);
+            for (const varName of reassignedAndReturn.reassigned) {
+                reassignedSet.add(varName);
+            }
+            if (reassignedAndReturn.returns)
+                returns = true;
+            if (stmt.update)
+                stack.push(...stmt.update);
+            continue;
+        }
+        if (stmt instanceof TirForOfStmt
+            || stmt instanceof TirWhileStmt) {
+            const reassignedAndReturn = determineReassignedVariablesAndReturn(stmt.body);
+            for (const varName of reassignedAndReturn.reassigned) {
+                reassignedSet.add(varName);
+            }
+            if (reassignedAndReturn.returns)
+                returns = true;
+            continue;
+        }
+        const tsEnsureExsaustiveCheck = stmt;
+    }
+    let reassigned = [...reassignedSet].sort();
+    reassigned = keepSortedStrArrInplace(reassigned, originalStmtDeps);
+    return {
+        reassigned,
+        returns,
+        canBreak,
+        canContinue
+    };
+}
+export function definitelyFails(stmt) {
+    const stack = [stmt];
+    while (stmt = stack.pop()) {
+        if (stmt instanceof TirFailStmt)
+            return true;
+        if (stmt instanceof TirBlockStmt) {
+            stack.push(...stmt.stmts);
+            continue;
+        }
+        if (isTirVarDecl(stmt))
+            continue;
+        if (stmt instanceof TirIfStmt) {
+            stack.push(stmt.thenBranch);
+            if (stmt.elseBranch)
+                stack.push(stmt.elseBranch);
+            continue;
+        }
+        if (stmt instanceof TirMatchStmt) {
+            if (stmt.cases.every(({ body }) => definitelyFails(body)))
+                return true;
+            continue;
+        }
+        if (stmt instanceof TirForStmt
+            || stmt instanceof TirForOfStmt
+            || stmt instanceof TirWhileStmt) {
+            stack.push(stmt.body);
+            continue;
+        }
+        if (stmt instanceof TirReturnStmt
+            || stmt instanceof TirBlockStmt
+            || stmt instanceof TirBreakStmt
+            || stmt instanceof TirContinueStmt
+            || stmt instanceof TirAssertStmt
+            || stmt instanceof TirAssignmentStmt)
+            continue;
+        // const tsEnsureExsaustiveCheck: never = stmt;
+    }
+    return false;
+}
+export function getBranchStmtReturnType({ reassigned, returns }, ctx, stmtRange) {
+    const uniqueName = getUniqueInternalName("__StmtSideEffects");
+    const reassignsConstrName = "Reassigns";
+    const earlyReturnConstrName = "EarlyReturn";
+    const initVars = reassigned.map(varName => {
+        const varExpr = ctx.getVariable(varName);
+        if (isExpressifyFuncParam(varExpr))
+            return new TirVariableAccessExpr({
+                variableInfos: {
+                    name: varName,
+                    type: varExpr.type,
+                    isConstant: false
+                },
+                isDefinedOutsideFuncScope: false
+            }, stmtRange);
+        return varExpr;
+    });
+    const constrs = [
+        new TirStructConstr(reassignsConstrName, reassigned.map((varName, i) => new TirStructField(varName, initVars[i].type)))
+    ];
+    if (returns) {
+        constrs.push(new TirStructConstr(earlyReturnConstrName, [
+            new TirStructField("returnValue", ctx.returnType)
+        ]));
+    }
+    const sop = new TirSoPStructType(uniqueName, "", // file uid 
+    constrs, new Map());
+    return {
+        sop,
+        initState: new TirLitNamedObjExpr(new Identifier(reassignsConstrName, stmtRange), reassigned.map(varName => new Identifier(varName, stmtRange)), initVars, sop, stmtRange)
+    };
+}
+export function getBodyStateType({ sop, initState }, stmt) {
+    const bodyStateType = sop.clone();
+    bodyStateType.constructors.length = 1; // keep only the first constructor
+    const bodyStateConstr = bodyStateType.constructors[0];
+    for (const { name, type, range, initExpr, isConst } of stmt.init) {
+        if (!initExpr)
+            throw new Error("loop init variable requires initialization expression");
+        // TODO: optimize for `isConst`
+        const uniqueFieldName = getUniqueInternalName(name);
+        bodyStateConstr.fields.push(new TirStructField(uniqueFieldName, type));
+        initState.fieldNames.push(new Identifier(uniqueFieldName, range));
+        initState.values.push(initExpr);
+    }
+    return {
+        bodyStateType,
+        initState,
+    };
+}

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

@@ -0,0 +1,15 @@
+import { TirExpr } from "../../tir/expressions/TirExpr.js";
+import { TirFuncExpr } from "../../tir/expressions/TirFuncExpr.js";
+import { TirAssertStmt } from "../../tir/statements/TirAssertStmt.js";
+import { TirBreakStmt } from "../../tir/statements/TirBreakStmt.js";
+import { TirContinueStmt } from "../../tir/statements/TirContinueStmt.js";
+import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.js";
+import { TirStmt } from "../../tir/statements/TirStmt.js";
+import { ExpressifyCtx } from "./ExpressifyCtx.js";
+export declare function expressify(func: TirFuncExpr, loopReplacements: LoopReplacements | undefined, parentCtx?: ExpressifyCtx | undefined): void;
+export interface LoopReplacements {
+    readonly replaceReturnValue: (ctx: ExpressifyCtx, stmt: TirReturnStmt) => TirExpr;
+    readonly compileBreak: (ctx: ExpressifyCtx, stmt: TirBreakStmt) => TirExpr;
+    readonly compileContinue: (ctx: ExpressifyCtx, stmt: TirContinueStmt) => TirExpr;
+}
+export declare function expressifyFuncBody(ctx: ExpressifyCtx, bodyStmts: TirStmt[], loopReplacements: LoopReplacements | undefined, assertions?: TirAssertStmt[]): TirExpr;