@harmoniclabs/pebble 0.1.0-dev0

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

@@ -0,0 +1,403 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { getUniqueInternalName } from "../../internalVar.js";
+import { TirLitVoidExpr } from "../../tir/expressions/litteral/TirLitVoidExpr.js";
+import { TirCaseExpr, TirCaseMatcher, TirWildcardCaseMatcher } from "../../tir/expressions/TirCaseExpr.js";
+import { TirFailExpr } from "../../tir/expressions/TirFailExpr.js";
+import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.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 { 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 { TirWhileStmt } from "../../tir/statements/TirWhileStmt.js";
+import { TirDataStructType, TirSoPStructType } from "../../tir/types/TirStructType.js";
+import { ExpressifyCtx } from "./ExpressifyCtx.js";
+import { expressifyVarAssignmentStmt } from "./expressifyVarAssignmentStmt.js";
+import { isSingleConstrStruct } from "./isSingleConstrStruct.js";
+import { expressifyVars } from "./expressifyVars.js";
+import { toNamedDeconstructVarDecl } from "./toNamedDeconstructVarDecl.js";
+import { flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct } from "./flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct.js";
+import { TirAssertAndContinueExpr } from "../../tir/expressions/TirAssertAndContinueExpr.js";
+import { expressifyTerminatingIfStmt } from "./expressifyTerminatingIfStmt.js";
+import { determineReassignedVariablesAndFlowInfos, determineReassignedVariablesAndReturn, getBodyStateType, getBranchStmtReturnType } from "./determineReassignedVariablesAndReturn.js";
+import { TirTernaryExpr } from "../../tir/expressions/TirTernaryExpr.js";
+import { expressifyIfBranch } from "./expressifyIfBranch.js";
+import { expressifyForStmt, whileToFor } from "./expressifyForStmt.js";
+import { getListTypeArg } from "../../tir/types/utils/getListTypeArg.js";
+import { TirElemAccessExpr } from "../../tir/expressions/TirElemAccessExpr.js";
+import { TirLitIntExpr } from "../../tir/expressions/litteral/TirLitIntExpr.js";
+import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
+import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
+export function expressify(func, loopReplacements, parentCtx = undefined) {
+    const ctx = new ExpressifyCtx(parentCtx, func.returnType);
+    ctx.introduceFuncParams(func.params);
+    func.body.stmts = [
+        new TirReturnStmt(expressifyFuncBody(ctx, func.body.stmts, loopReplacements), func.body.range)
+    ];
+}
+export function expressifyFuncBody(ctx, bodyStmts, 
+// passed when compiling loops
+loopReplacements, assertions = []) {
+    bodyStmts = bodyStmts.slice();
+    let stmt;
+    while (stmt = bodyStmts.shift()) {
+        if (stmt instanceof TirBreakStmt) {
+            if (typeof loopReplacements?.compileBreak !== "function")
+                throw new Error("break statement in function body.");
+            return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, loopReplacements.compileBreak(ctx, stmt));
+        }
+        else if (stmt instanceof TirContinueStmt) {
+            if (typeof loopReplacements?.compileContinue !== "function")
+                throw new Error("continue statement in function body.");
+            return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, loopReplacements.compileContinue(ctx, stmt));
+        }
+        else if (stmt instanceof TirReturnStmt) {
+            if (stmt.value) {
+                let modifiedExpr = expressifyVars(ctx, stmt.value);
+                if (typeof loopReplacements?.replaceReturnValue === "function") {
+                    modifiedExpr = loopReplacements.replaceReturnValue(ctx, stmt);
+                }
+                stmt.value = modifiedExpr;
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, modifiedExpr);
+            }
+            else
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirLitVoidExpr(stmt.range));
+        }
+        // if( isTirVarDecl( stmt ) ) expressifyVarDecl( ctx, stmt );
+        else if (stmt instanceof TirSimpleVarDecl) {
+            if (!stmt.initExpr)
+                throw new Error("simple var decl without init expr");
+            const initExpr = expressifyVars(ctx, stmt.initExpr);
+            stmt.initExpr = initExpr;
+            const lettedExpr = ctx.introduceLettedConstant(stmt.name, initExpr, stmt.range);
+            if (!isSingleConstrStruct(stmt.type))
+                continue;
+            if ((initExpr instanceof TirVariableAccessExpr || initExpr instanceof TirLettedExpr)
+                && ctx.properties.has(initExpr.varName))
+                continue; // field extraction was already done
+            if (stmt.type instanceof TirSoPStructType) {
+                const pattern = getConstrDestructPattern(stmt.type, stmt.range, undefined, // no init expr (pattern is used as case matcher)
+                0);
+                ctx.introduceSopConstrFieldsAsProperties(stmt.name, pattern);
+                // nested single constr structs
+                // are added as destructed variables in the matcher body
+                // using `getNestedDestructsInSingleSopDestructPattern`
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirCaseExpr(lettedExpr, [new TirCaseMatcher(pattern, expressifyFuncBody(ctx, getNestedDestructsInSingleSopDestructPattern(pattern)
+                        .concat(bodyStmts), loopReplacements), stmt.range)], undefined, // no wildcard case
+                ctx.returnType, stmt.range));
+            }
+            else if (stmt.type instanceof TirDataStructType) {
+                ctx.introduceSingleConstrDataLettedFields(stmt.name, stmt.initExpr, stmt.type);
+                continue;
+            }
+            continue;
+        }
+        else if (stmt instanceof TirSingleDeconstructVarDecl
+            || stmt instanceof TirNamedDeconstructVarDecl) {
+            stmt = toNamedDeconstructVarDecl(stmt);
+            // for some reason typescript goes crazy with types here
+            if (stmt instanceof TirBreakStmt)
+                throw new Error("unreachable");
+            else if (stmt instanceof TirContinueStmt)
+                throw new Error("unreachable");
+            else if (stmt instanceof TirSingleDeconstructVarDecl)
+                throw new Error("unreachable");
+            if (!stmt.initExpr)
+                throw new Error("simple var decl without init expr");
+            const initExpr = expressifyVars(ctx, stmt.initExpr);
+            stmt.initExpr = initExpr;
+            const lettedName = getUniqueInternalName(stmt.type.toString().toLowerCase());
+            const lettedExpr = ctx.introduceLettedConstant(lettedName, initExpr, stmt.range);
+            if (stmt.type instanceof TirSoPStructType) {
+                const nestedDeconstructs = flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(stmt, ctx);
+                // nested single constr structs
+                // are added as destructed variables in the matcher body
+                // using `getNestedDestructsInSingleSopDestructPattern`
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirCaseExpr(lettedExpr, [new TirCaseMatcher(stmt, expressifyFuncBody(ctx, nestedDeconstructs
+                        .concat(bodyStmts), loopReplacements), stmt.range)], new TirWildcardCaseMatcher(new TirFailExpr(undefined, ctx.returnType, stmt.range), stmt.range), ctx.returnType, stmt.range));
+            }
+            else if (stmt.type instanceof TirDataStructType) {
+                assertions.push(...ctx.introduceDeconstrDataLettedFields(toNamedDeconstructVarDecl(stmt)));
+                continue;
+            }
+        }
+        else if (stmt instanceof TirArrayLikeDeconstr) {
+            if (!stmt.initExpr)
+                throw new Error("array-like deconstruction with init expr is not supported");
+            const listType = stmt.type;
+            const elemType = getListTypeArg(stmt.type);
+            if (!elemType)
+                throw new Error("array-like deconstruction without element type is not supported");
+            const uniqueArrName = getUniqueInternalName("deconstructed_list_0");
+            let lettedArr = ctx.introduceLettedConstant(uniqueArrName, expressifyVars(ctx, stmt.initExpr), stmt.range);
+            const modTails = 3;
+            const nextDeclarations = [];
+            for (let i = 0; i < stmt.elements.length; i++) {
+                const elem = stmt.elements[i];
+                const uniqueVarName = getUniqueInternalName("elem_" + i.toString());
+                const nTails = i % modTails; // every 3 we hoist the intermediate list
+                let lettedElem;
+                if (nTails === 0 && i > 0) {
+                    // hoist the list
+                    lettedArr = ctx.introduceLettedConstant(uniqueArrName, new TirElemAccessExpr(lettedArr, new TirLitIntExpr(BigInt(modTails), elem.range), listType, elem.range), stmt.range);
+                    lettedElem = ctx.introduceLettedConstant(uniqueVarName, new TirElemAccessExpr(lettedArr, new TirLitIntExpr(BigInt(0), elem.range), elemType, elem.range), elem.range);
+                }
+                else {
+                    lettedElem = ctx.introduceLettedConstant(uniqueVarName, new TirElemAccessExpr(lettedArr, new TirLitIntExpr(BigInt(nTails), elem.range), elemType, elem.range), elem.range);
+                }
+                if (elem instanceof TirSimpleVarDecl) {
+                    ctx.setNewVariableName(elem.name, uniqueVarName);
+                }
+                else {
+                    elem.initExpr = lettedElem;
+                    nextDeclarations.push(elem);
+                }
+            }
+            if (stmt.rest) {
+                const uniqueRestName = getUniqueInternalName(stmt.rest);
+                const restLetted = ctx.introduceLettedConstant(uniqueRestName, new TirCallExpr(TirNativeFunc._dropList(elemType), [
+                    new TirLitIntExpr(BigInt(stmt.elements.length % modTails), stmt.range),
+                    lettedArr
+                ], listType, stmt.range), stmt.range);
+                ctx.setNewVariableName(stmt.rest, uniqueRestName);
+            }
+            bodyStmts.push(...nextDeclarations);
+            continue;
+        }
+        else if (stmt instanceof TirAssignmentStmt)
+            bodyStmts.unshift(expressifyVarAssignmentStmt(ctx, stmt));
+        else if (stmt instanceof TirBlockStmt) {
+            // inline the block
+            bodyStmts = stmt.stmts.concat(bodyStmts);
+            continue;
+        }
+        else if (stmt instanceof TirFailStmt) {
+            if (stmt.failMsgExpr) {
+                const modifiedExpr = expressifyVars(ctx, stmt.failMsgExpr);
+                stmt.failMsgExpr = modifiedExpr;
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirFailExpr(modifiedExpr, ctx.returnType, stmt.range));
+            }
+            else
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirFailExpr(undefined, ctx.returnType, stmt.range));
+        }
+        else if (stmt instanceof TirAssertStmt) {
+            const condition = expressifyVars(ctx, stmt.condition);
+            stmt.condition = condition;
+            if (stmt.elseExpr) {
+                const elseExpr = expressifyVars(ctx, stmt.elseExpr);
+                stmt.elseExpr = elseExpr;
+            }
+            assertions.push(stmt);
+            continue;
+        }
+        else if (stmt instanceof TirIfStmt) {
+            if (stmt.thenBranch.definitelyTerminates()) {
+                const elseBranchStmts = [];
+                if (stmt.elseBranch) {
+                    if (stmt.elseBranch instanceof TirBlockStmt) {
+                        elseBranchStmts.push(...stmt.elseBranch.stmts);
+                    }
+                    else {
+                        elseBranchStmts.push(stmt.elseBranch);
+                    }
+                }
+                // move the rest of the body into the else branch
+                elseBranchStmts.push(...bodyStmts);
+                stmt.elseBranch = new TirBlockStmt(elseBranchStmts, stmt.elseBranch?.range ?? stmt.thenBranch.range);
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, expressifyTerminatingIfStmt(ctx, stmt, loopReplacements));
+            }
+            else if (stmt.elseBranch && stmt.elseBranch.definitelyTerminates()) {
+                const thenBranchStmts = [];
+                if (stmt.thenBranch instanceof TirBlockStmt) {
+                    thenBranchStmts.push(...stmt.thenBranch.stmts);
+                }
+                else {
+                    thenBranchStmts.push(stmt.thenBranch);
+                }
+                // move the rest of the body into the then branch
+                thenBranchStmts.push(...bodyStmts);
+                stmt.thenBranch = new TirBlockStmt(thenBranchStmts, stmt.thenBranch.range);
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, expressifyTerminatingIfStmt(ctx, stmt, loopReplacements));
+            }
+            // determine affected variables
+            // determine if we have an early return
+            const reassignsAndReturns = determineReassignedVariablesAndReturn(stmt);
+            // build a SoP type to return
+            const { sop, initState } = getBranchStmtReturnType(reassignsAndReturns, ctx, stmt.range);
+            const condition = expressifyVars(ctx, stmt.condition);
+            const stmtExpr = new TirTernaryExpr(condition, expressifyIfBranch(ctx.newChild(), stmt.thenBranch, reassignsAndReturns.reassigned, sop, loopReplacements), stmt.elseBranch ? expressifyIfBranch(ctx.newChild(), stmt.elseBranch, reassignsAndReturns.reassigned, sop, loopReplacements) : initState, // no else branch means the variables stay unchanged
+            sop, stmt.range);
+            // expressify as ternary that returns the SoP type
+            return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, getFinalStmtCaseExpr(stmtExpr, sop, ctx, stmt.range, reassignsAndReturns, bodyStmts, loopReplacements));
+        }
+        else if (stmt instanceof TirMatchStmt) {
+            /**
+             * index of the **only** case that does not terminate
+             *
+             * if it is undefined, then all cases terminate
+             * if it is negative, then more than one case does not terminate
+             * if it is positive, then only one case does not terminate and this is the index
+            **/
+            let doesNotTerminateIdx = undefined;
+            for (let i = 0; i < stmt.cases.length; i++) {
+                const _case = stmt.cases[i];
+                if (_case.body.definitelyTerminates())
+                    continue;
+                if (typeof doesNotTerminateIdx !== "number")
+                    doesNotTerminateIdx = i;
+                else {
+                    doesNotTerminateIdx = -1; // more than one case does not terminate
+                    break;
+                }
+            }
+            const onlyOneCaseDoesNotTerminate = typeof doesNotTerminateIdx === "number" && doesNotTerminateIdx >= 0;
+            if (onlyOneCaseDoesNotTerminate) {
+                const theDude = stmt.cases[doesNotTerminateIdx];
+                theDude.body = theDude.body instanceof TirBlockStmt ? theDude.body : new TirBlockStmt([theDude.body], theDude.body.range);
+                theDude.body.stmts.push(...bodyStmts);
+            }
+            const isDirectReturn = typeof doesNotTerminateIdx !== "number" // all cases terminate
+                || onlyOneCaseDoesNotTerminate;
+            const reassignsAndReturns = determineReassignedVariablesAndReturn(stmt);
+            if (isDirectReturn) {
+                // build a SoP type to return
+                const { sop, initState } = getBranchStmtReturnType(reassignsAndReturns, ctx, stmt.range);
+                // expressify as ternary that returns the SoP type
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, getFinalStmtCaseExpr(new TirCaseExpr(expressifyVars(ctx, stmt.matchExpr), stmt.cases.map(_case => {
+                    if (_case.pattern instanceof TirArrayLikeDeconstr)
+                        throw new Error("array-like deconstruction in match statement is not supported");
+                    _case.pattern = toNamedDeconstructVarDecl(_case.pattern);
+                    const caseCtx = ctx.newChild();
+                    flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(_case.pattern, caseCtx);
+                    const caseBody = expressifyFuncBody(caseCtx, _case.body instanceof TirBlockStmt
+                        ? _case.body.stmts
+                        : [_case.body], loopReplacements, assertions);
+                    return new TirCaseMatcher(_case.pattern, caseBody, _case.range);
+                }), stmt.wildcardCase ? new TirWildcardCaseMatcher(expressifyFuncBody(ctx.newChild(), stmt.wildcardCase.body instanceof TirBlockStmt
+                    ? stmt.wildcardCase.body.stmts
+                    : [stmt.wildcardCase.body], loopReplacements, []), stmt.wildcardCase.range) : undefined, ctx.returnType, stmt.range), sop, ctx, stmt.range, reassignsAndReturns, bodyStmts, loopReplacements));
+            }
+        }
+        else if (stmt instanceof TirForOfStmt) {
+            // determine affected variables
+            // determine if we may have an early return
+            // determine if we can break or continue
+            const reassignedAndFlow = determineReassignedVariablesAndFlowInfos(stmt);
+            const { reassigned, returns, canBreak, canContinue } = reassignedAndFlow;
+            const { sop, initState } = getBranchStmtReturnType(reassignedAndFlow, ctx, stmt.range);
+            if (!returns
+                && !canBreak
+            // && !canContinue
+            ) {
+                // **only for...of** can be optimized as a simple `.reduce`
+                // producing the new state in this case
+                // (`.reduce` has no way to break or early return (efficiently))
+                // continue is ok, because we only need to pass the state up to that point
+            }
+        }
+        else if (stmt instanceof TirForStmt
+            || stmt instanceof TirWhileStmt) {
+            const reassignedAndFlow = determineReassignedVariablesAndFlowInfos(stmt);
+            const returnTypeAndInvalidInit = getBranchStmtReturnType(reassignedAndFlow, ctx, stmt.range);
+            const forStmt = whileToFor(stmt);
+            const { bodyStateType, initState } = getBodyStateType(returnTypeAndInvalidInit, forStmt);
+            const loopExpr = expressifyForStmt(ctx.newChild(), forStmt, returnTypeAndInvalidInit.sop, bodyStateType, initState);
+        }
+        else {
+            const tsEnsureExsautstiveCheck = stmt;
+            console.error(stmt);
+            throw new Error("unreachable::expressify::stmt");
+        }
+    }
+    return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirLitVoidExpr(SourceRange.mock));
+}
+function getConstrDestructPattern(type, range, initExpr, constrIndex) {
+    const constr = type.constructors[constrIndex];
+    if (!constr)
+        throw new Error("no constructor in single constr struct type");
+    const deconstructedFields = new Map();
+    for (const field of constr.fields) {
+        const uniqueName = getUniqueInternalName(field.name);
+        deconstructedFields.set(field.name, new TirSimpleVarDecl(uniqueName, field.type, initExpr, false, // not a constant (reassigned if deconstruction statement already exists later)
+        range));
+    }
+    return new TirNamedDeconstructVarDecl(constr.name, deconstructedFields, undefined, type, undefined, false, // not a constant
+    range);
+}
+function getNestedDestructsInSingleSopDestructPattern(pattern) {
+    const result = [];
+    for (const [fName, varDecl] of pattern.fields) {
+        if (!(varDecl instanceof TirSimpleVarDecl))
+            throw new Error("expected simple var decl in single destruct pattern");
+        if (!(varDecl.type instanceof TirSoPStructType))
+            continue;
+        result.push(getConstrDestructPattern(varDecl.type, varDecl.range, 
+        // init expr
+        new TirVariableAccessExpr({
+            variableInfos: {
+                name: varDecl.name,
+                type: varDecl.type,
+                isConstant: true,
+            },
+            isDefinedOutsideFuncScope: false,
+        }, varDecl.range), 0));
+    }
+    return result;
+}
+function getFinalStmtCaseExpr(finalStmtExpr, sop, ctx, stmtRange, reassignsAndReturns, nextBodyStmts, loopReplacements) {
+    const continuations = [];
+    const contBranchCtx = ctx.newChild();
+    const contConstr = sop.constructors[0];
+    const contFields = contConstr.fields;
+    const contPattern = new TirNamedDeconstructVarDecl(sop.constructors[0].name, new Map(contFields.map((f, i) => [
+        f.name,
+        new TirSimpleVarDecl(getUniqueInternalName(f.name), f.type, undefined, // no init expr (pattern is used as case matcher)
+        false, // not a constant
+        stmtRange)
+    ])), undefined, // no rest
+    sop, undefined, // no init expr
+    false, // not a constant
+    stmtRange);
+    const nestedDeconstructs = flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(contPattern, contBranchCtx);
+    continuations.push(new TirCaseMatcher(contPattern, expressifyFuncBody(contBranchCtx, nestedDeconstructs
+        .concat(nextBodyStmts), loopReplacements, [] // assertions are added before if statement exectution
+    ), stmtRange));
+    if (reassignsAndReturns.returns) {
+        const earlyRetConstr = sop.constructors[1];
+        const earlyRetField = earlyRetConstr.fields[0];
+        const uniqueFieldName = getUniqueInternalName(earlyRetField.name);
+        const earlyRetPattern = new TirNamedDeconstructVarDecl(earlyRetConstr.name, new Map([
+            [
+                earlyRetField.name,
+                new TirSimpleVarDecl(uniqueFieldName, earlyRetField.type, undefined, // no init expr (pattern is used as case matcher)
+                false, // not a constant
+                stmtRange)
+            ]
+        ]), undefined, // no rest
+        sop, undefined, // no init expr
+        false, // not a constant
+        stmtRange);
+        continuations.push(new TirCaseMatcher(earlyRetPattern, new TirVariableAccessExpr({
+            variableInfos: {
+                name: uniqueFieldName,
+                type: earlyRetField.type,
+                isConstant: true,
+            },
+            isDefinedOutsideFuncScope: false,
+        }, stmtRange), stmtRange));
+    }
+    // expressify as ternary that returns the SoP type
+    return new TirCaseExpr(finalStmtExpr, continuations, undefined, // no wildcard case
+    ctx.returnType, stmtRange);
+}

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

@@ -0,0 +1,8 @@
+import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
+import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
+import { TirForStmt } from "../../tir/statements/TirForStmt.js";
+import { TirWhileStmt } from "../../tir/statements/TirWhileStmt.js";
+import { TirSoPStructType } from "../../tir/types/TirStructType.js";
+import { ExpressifyCtx } from "./ExpressifyCtx.js";
+export declare function whileToFor(stmt: TirWhileStmt | TirForStmt): TirForStmt;
+export declare function expressifyForStmt(ctx: ExpressifyCtx, stmt: TirForStmt, returnType: TirSoPStructType, bodyStateType: TirSoPStructType, initState: TirLitNamedObjExpr): TirCallExpr;

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

@@ -0,0 +1,115 @@
+import { Identifier } from "../../../ast/nodes/common/Identifier.js";
+import { getUniqueInternalName } from "../../internalVar.js";
+import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
+import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
+import { TirFuncExpr } from "../../tir/expressions/TirFuncExpr.js";
+import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
+import { TirBlockStmt } from "../../tir/statements/TirBlockStmt.js";
+import { TirBreakStmt } from "../../tir/statements/TirBreakStmt.js";
+import { TirContinueStmt } from "../../tir/statements/TirContinueStmt.js";
+import { TirForStmt } from "../../tir/statements/TirForStmt.js";
+import { TirIfStmt } from "../../tir/statements/TirIfStmt.js";
+import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.js";
+import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirFuncT } from "../../tir/types/TirNativeType/native/function.js";
+import { expressifyFuncBody } from "./expressify.js";
+import { isExpressifyFuncParam } from "./ExpressifyCtx.js";
+export function whileToFor(stmt) {
+    if (stmt instanceof TirForStmt)
+        return stmt;
+    // convert while to for
+    return new TirForStmt([], // no init
+    stmt.condition, // condition
+    [], // no update
+    stmt.body, // loopBody
+    stmt.range);
+}
+export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initState) {
+    const loopBody = stmt.body instanceof TirBlockStmt ? stmt.body : new TirBlockStmt([stmt.body], stmt.range);
+    if (stmt.condition)
+        loopBody.stmts.unshift(new TirIfStmt(stmt.condition, 
+        // then
+        loopBody, 
+        // else
+        new TirBlockStmt([new TirBreakStmt(stmt.condition.range)], stmt.condition.range), stmt.condition.range));
+    loopBody.stmts.push(new TirContinueStmt(loopBody.range.atEnd()));
+    const loopFuncName = getUniqueInternalName("loop");
+    const loopFuncType = new TirFuncT(bodyStateType.constructors[0].fields.map(f => f.type), returnType);
+    const loopReplacements = {
+        compileBreak(ctx, stmt) {
+            // return first constructor of the return type
+            const ctor = returnType.constructors[0];
+            return new TirLitNamedObjExpr(new Identifier(ctor.name, stmt.range), ctor.fields.map(f => new Identifier(f.name, stmt.range)), bodyStateType.constructors[0].fields
+                .slice(0, ctor.fields.length)
+                .map(f => {
+                const resolved = ctx.getVariable(f.name);
+                if (isExpressifyFuncParam(resolved)) {
+                    return new TirVariableAccessExpr({
+                        variableInfos: {
+                            name: resolved.name,
+                            type: resolved.type,
+                            isConstant: false
+                        },
+                        isDefinedOutsideFuncScope: false
+                    }, stmt.range);
+                }
+                return resolved;
+            }), returnType, stmt.range);
+        },
+        replaceReturnValue(ctx, stmt) {
+            // return second constructor of the return type
+            const ctor = returnType.constructors[1];
+            if (!ctor) {
+                throw new Error("No return constructor found in return type");
+            }
+            return new TirLitNamedObjExpr(new Identifier(ctor.name, stmt.range), [new Identifier(ctor.fields[0].name, stmt.range)], [stmt.value], returnType, stmt.range);
+        },
+        compileContinue(ctx, stmt) {
+            // return recursive call
+            const resolvedSelfResult = ctx.getVariable(loopFuncName);
+            let resolvedSelf;
+            if (isExpressifyFuncParam(resolvedSelfResult)) {
+                resolvedSelf = new TirVariableAccessExpr({
+                    variableInfos: {
+                        name: resolvedSelfResult.name,
+                        type: resolvedSelfResult.type,
+                        isConstant: false
+                    },
+                    isDefinedOutsideFuncScope: false
+                }, stmt.range);
+            }
+            else {
+                resolvedSelf = resolvedSelfResult;
+            }
+            return new TirCallExpr(resolvedSelf, bodyStateType.constructors[0].fields
+                .map(f => {
+                const resolved = ctx.getVariable(f.name);
+                if (isExpressifyFuncParam(resolved)) {
+                    return new TirVariableAccessExpr({
+                        variableInfos: {
+                            name: resolved.name,
+                            type: resolved.type,
+                            isConstant: false
+                        },
+                        isDefinedOutsideFuncScope: false
+                    }, stmt.range);
+                }
+                return resolved;
+            }), returnType, stmt.range);
+        },
+    };
+    const loopCompilationCtx = ctx.newChild();
+    // define loop function for recursion
+    loopCompilationCtx.setFuncParam(loopFuncName, loopFuncType);
+    // define loop function parameters
+    for (const { name, type } of bodyStateType.constructors[0].fields) {
+        loopCompilationCtx.setFuncParam(name, type);
+    }
+    return new TirCallExpr(new TirFuncExpr(loopFuncName, bodyStateType.constructors[0].fields.map(f => new TirSimpleVarDecl(f.name, f.type, undefined, // no initial value
+    false, // is constant
+    stmt.range)), returnType, new TirBlockStmt([
+        new TirReturnStmt(expressifyFuncBody(loopCompilationCtx, loopBody.stmts, loopReplacements, [] // assertions
+        ), stmt.range)
+    ], stmt.range), stmt.range, true // is loop
+    ), initState.values, returnType, stmt.range);
+}

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

@@ -0,0 +1,6 @@
+import { TirExpr } from "../../tir/expressions/TirExpr.js";
+import { TirStmt } from "../../tir/statements/TirStmt.js";
+import { TirSoPStructType } from "../../tir/types/TirStructType.js";
+import { LoopReplacements } from "./expressify.js";
+import { ExpressifyCtx } from "./ExpressifyCtx.js";
+export declare function expressifyIfBranch(ctx: ExpressifyCtx, branch: TirStmt, reassignedNames: string[], sop: TirSoPStructType, loopReplacements: LoopReplacements | undefined): TirExpr;

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

@@ -0,0 +1,105 @@
+import { Identifier } from "../../../ast/nodes/common/Identifier.js";
+import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
+import { TirLitVoidExpr } from "../../tir/expressions/litteral/TirLitVoidExpr.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 { expressifyFuncBody } from "./expressify.js";
+export function expressifyIfBranch(ctx, branch, reassignedNames, sop, loopReplacements) {
+    ctx.returnType = sop;
+    const body = branch instanceof TirBlockStmt ? branch.stmts : [branch];
+    const earlyReturnConstr = sop.constructors[1];
+    const wrapReturnExpr = !earlyReturnConstr ? undefined :
+        (expr) => new TirLitNamedObjExpr(new Identifier(earlyReturnConstr.name, expr.range), [new Identifier(earlyReturnConstr.fields[0].name, expr.range)], [expr], sop, expr.range);
+    // replace explicit return statements wrapping the return value in the second constr
+    replaceReturnStatements(body, wrapReturnExpr, sop);
+    // add a final return statement (if it doesn't end with one)
+    // returning the first constr, with the modified variables
+    const lastIdx = body.length - 1;
+    if (body.length === 0 ||
+        !(body[lastIdx] instanceof TirReturnStmt)) {
+        const fstConstr = sop.constructors[0];
+        const fields = fstConstr.fields;
+        body.push(new TirReturnStmt(new TirLitNamedObjExpr(new Identifier(fstConstr.name, branch.range), fields.map(f => new Identifier(f.name, branch.range)), fields.map((f, i) => new TirVariableAccessExpr({
+            variableInfos: {
+                name: reassignedNames[i],
+                type: f.type,
+                isConstant: false
+            },
+            isDefinedOutsideFuncScope: false,
+        }, branch.range)), sop, branch.range), branch.range));
+    }
+    // finally expressify as normal function body, but with `sop` as return type
+    return expressifyFuncBody(ctx, body, loopReplacements);
+}
+function replaceReturnStatements(body, wrapReturnExpr, sopType) {
+    const hasEarlyReturn = typeof wrapReturnExpr === "function";
+    for (let i = 0; i < body.length; i++) {
+        const stmt = body[i];
+        // replace the return statement with a new one
+        // that returns the first constr, with the modified variables
+        if (stmt instanceof TirReturnStmt) {
+            if (!hasEarlyReturn)
+                throw new Error("unexpected early return statement.");
+            stmt.value = wrapReturnExpr(stmt.value ?? new TirLitVoidExpr(stmt.range));
+            body[i] = stmt;
+            continue;
+        }
+        if (isTirVarDecl(stmt)
+            || stmt instanceof TirBreakStmt
+            || stmt instanceof TirContinueStmt
+            || stmt instanceof TirFailStmt
+            || stmt instanceof TirAssertStmt
+            || stmt instanceof TirAssignmentStmt)
+            continue;
+        if (stmt instanceof TirBlockStmt) {
+            replaceReturnStatements(stmt.stmts, wrapReturnExpr, sopType);
+            continue;
+        }
+        if (stmt instanceof TirIfStmt) {
+            stmt.thenBranch = stmt.thenBranch instanceof TirBlockStmt ?
+                stmt.thenBranch :
+                new TirBlockStmt([stmt.thenBranch], stmt.range);
+            replaceReturnStatements(stmt.thenBranch.stmts, wrapReturnExpr, sopType);
+            if (stmt.elseBranch) {
+                stmt.elseBranch = stmt.elseBranch instanceof TirBlockStmt ?
+                    stmt.elseBranch :
+                    new TirBlockStmt([stmt.elseBranch], stmt.range);
+                replaceReturnStatements(stmt.elseBranch.stmts, wrapReturnExpr, sopType);
+            }
+            continue;
+        }
+        if (stmt instanceof TirMatchStmt) {
+            for (let i = 0; i < stmt.cases.length; i++) {
+                const matchCase = stmt.cases[i];
+                matchCase.body = matchCase.body instanceof TirBlockStmt ?
+                    matchCase.body :
+                    new TirBlockStmt([matchCase.body], matchCase.range);
+                replaceReturnStatements(matchCase.body.stmts, wrapReturnExpr, sopType);
+            }
+            // TODO: do wildcard
+            continue;
+        }
+        if (stmt instanceof TirForStmt
+            || stmt instanceof TirForOfStmt
+            || stmt instanceof TirWhileStmt) {
+            stmt.body = stmt.body instanceof TirBlockStmt ?
+                stmt.body :
+                new TirBlockStmt([stmt.body], stmt.range);
+            replaceReturnStatements(stmt.body.stmts, wrapReturnExpr, sopType);
+            continue;
+        }
+        const tsEnsureExsautstiveCheck = stmt;
+    }
+}

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

@@ -0,0 +1,5 @@
+import { TirExpr } from "../../tir/expressions/TirExpr.js";
+import { TirIfStmt } from "../../tir/statements/TirIfStmt.js";
+import { LoopReplacements } from "./expressify.js";
+import { ExpressifyCtx } from "./ExpressifyCtx.js";
+export declare function expressifyTerminatingIfStmt(parentCtx: ExpressifyCtx, stmt: TirIfStmt, loopReplacements: LoopReplacements | undefined): TirExpr;