@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

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

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

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

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

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