@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

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

@@ -5,6 +5,7 @@ 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 { TirHoistedExpr } from "../../tir/expressions/TirHoistedExpr.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";
@@ -26,12 +27,13 @@ export function isExpressifyFuncParam(thing) {
 export class ExpressifyCtx {
     parent;
     returnType;
+    program;
     variables;
     funcParams;
     lettedConstants;
     properties;
     hoisted;
-    constructor(parent, returnType, hoisted, 
+    constructor(parent, returnType, program, hoisted, 
     /** var name -> latest constant name */
     variables = new Map(), 
     /** constant name -> func param name (to build var access) */
@@ -42,39 +44,64 @@ export class ExpressifyCtx {
     properties = new Map()) {
         this.parent = parent;
         this.returnType = returnType;
+        this.program = program;
         this.variables = variables;
         this.funcParams = funcParams;
         this.lettedConstants = lettedConstants;
         this.properties = properties;
-        this.hoisted = hoisted ?? this.parent?.hoisted ?? new Map();
+        this.hoisted = (hoisted
+            ?? this.parent?.hoisted
+            ?? new Map([...program.constants.entries()].map(([name, decl]) => {
+                if (!decl.initExpr)
+                    throw new Error(`expected init expr in hoisted constant '${name}'`);
+                const expr = decl.initExpr instanceof TirHoistedExpr ? decl.initExpr : new TirHoistedExpr(name, decl.initExpr);
+                return [name, expr];
+            })));
+    }
+    allVariablesNoLetted() {
+        return (this.parent?.allVariablesNoLetted() ?? []).concat(...this.variables.keys());
+    }
+    allVariables() {
+        const thisVars = new Set([
+            ...this.variables.keys(),
+            ...this.lettedConstants.keys(),
+            ...this.hoisted.keys(),
+        ]);
+        return (this.parent?.allVariables() ?? []).concat(...thisVars);
     }
     newChild() {
-        return new ExpressifyCtx(this, this.returnType);
+        return new ExpressifyCtx(this, this.returnType, this.program);
     }
     setNewVariableName(oldName, newName) {
         let latestNameSSA = this.variables.get(oldName);
         if (!latestNameSSA)
             this.variables.set(oldName, { latestName: newName });
-        else
+        else {
+            const prevName = latestNameSSA.latestName;
+            if (prevName === newName)
+                return; // no change
             latestNameSSA.latestName = newName;
+            this.setNewVariableName(prevName, newName);
+            this.setNewVariableName(newName, newName);
+        }
     }
     setFuncParam(name, type) {
-        this.variables.set(name, { latestName: name });
+        this.setNewVariableName(name, 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;
+        // no such variable (mutable at least)
+        if (!latestConstName) {
+            // try to get var declared as constant
+            // return undefined if not present
+            return this.lettedConstants.get(name);
+        }
+        ;
         return (this.lettedConstants.get(latestConstName)
             ?? this.funcParams.get(latestConstName));
     }
@@ -92,11 +119,15 @@ export class ExpressifyCtx {
         const result = (this._getNonHoistedVariable(name)
             ?? this.hoisted.get(name));
         if (!result) {
-            console.log(this);
+            console.log(this.allVariables());
             throw new Error(`variable '${name}' not found in the context`);
         }
         return result;
     }
+    getVariableSSA(name) {
+        return (this.variables.get(name)
+            ?? this.parent?.getVariableSSA(name));
+    }
     introduceFuncParams(params) {
         for (const param of params) {
             param.isConst = true;
@@ -104,9 +135,13 @@ export class ExpressifyCtx {
         }
     }
     introduceLettedConstant(name, lettedExpr, declRange) {
+        // if( this.lettedConstants.has( name ) ) throw new Error(`constant '${name}' already introduced in the context`);
+        const existing = this.lettedConstants.get(name);
+        if (existing)
+            return existing.clone();
         const result = new TirLettedExpr(name, lettedExpr, declRange);
         this.lettedConstants.set(name, result);
-        return result.unsafeClone();
+        return result.clone();
     }
     introduceSopConstrFieldsAsProperties(sopName, destructuredPattern) {
         const fieldsMap = new Map();
@@ -130,7 +165,7 @@ export class ExpressifyCtx {
         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 lettedFields = this.introduceLettedConstant(lettedRawFieldsName, new TirLettedExpr(lettedRawFieldsName, new TirCallExpr(TirNativeFunc.unConstrDataResultFields, [new TirCallExpr(TirNativeFunc.unConstrData, [structExpr], new TirUnConstrDataResultT(), structExpr.range)], new TirListT(data_t), structExpr.range), structExpr.range), structExpr.range);
         const fieldsMap = new Map();
         for (let i = 0; i < constr.fields.length; i++) {
             const field = constr.fields[i];
@@ -150,25 +185,26 @@ export class ExpressifyCtx {
         }
         this.properties.set(varName, fieldsMap);
     }
-    introduceDeconstrDataLettedFields(stmt) {
+    introduceDeconstrDataLettedFields(stmt, lettedInitExpr) {
         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 varName = lettedInitExpr.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;
+            return { implicitAssertions: [], nestedDeconstructs: [] }; // no fields to extract, no assertions
+        const structExpr = lettedInitExpr ?? 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 lettedUnconstr = this.introduceLettedConstant(lettedUnconstrName, new TirCallExpr(TirNativeFunc.unConstrData, [structExpr], new TirUnConstrDataResultT(), stmt.range), stmt.range);
         const assertions = [];
-        if (structType.constructors.length > 0)
+        const nestedDeconstructs = [];
+        if (structType.constructors.length > 1)
             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`);
@@ -179,7 +215,7 @@ export class ExpressifyCtx {
         for (let i = 0; i < constr.fields.length; i++) {
             const field = constr.fields[i];
             const fieldName = field.name;
-            const fieldType = field.type;
+            let fieldType = field.type;
             const isFieldToIntroduce = fieldsToIntroduce.includes(fieldName);
             if (!hasRest && !isFieldToIntroduce)
                 continue; // skip unused field
@@ -196,34 +232,20 @@ export class ExpressifyCtx {
             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));
+                this.setNewVariableName(fieldVarDecl.name, lettedField.varName);
             }
-            else if (fieldVarDecl instanceof TirArrayLikeDeconstr) {
+            else {
+                // fieldVarDecl.type ??= fieldType;
                 fieldVarDecl.initExpr = lettedField;
-                assertions.push(...this.introduceArrayDeconstr(fieldVarDecl, true // is destructured field
-                ));
+                nestedDeconstructs.push(fieldVarDecl);
             }
         }
         if (hasRest)
             this.properties.set(stmt.rest, fieldsMap);
-        return assertions;
+        return {
+            implicitAssertions: assertions,
+            nestedDeconstructs
+        };
     }
     introduceArrayDeconstr(stmt, isDestructuredField = false) {
         if (!(stmt.initExpr))
@@ -240,6 +262,7 @@ export class ExpressifyCtx {
             lettedArrayExpr = this.introduceLettedConstant(lettedArrayName, stmt.initExpr, stmt.range);
         }
         const assertions = [];
+        const nestedDeconstructs = [];
         const nElems = stmt.elements.length;
         for (let i = 0; i < nElems; i++) {
             const elemVarDecl = stmt.elements[i];
@@ -249,7 +272,7 @@ export class ExpressifyCtx {
                 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 });
+                this.setNewVariableName(elemVarDecl.name, lettedElem.varName);
                 if (lettedElem.type instanceof TirDataStructType
                     && lettedElem.type.constructors.length === 1) {
                     // if the element is a single-constructor data struct,
@@ -261,12 +284,16 @@ export class ExpressifyCtx {
                 || elemVarDecl instanceof TirSingleDeconstructVarDecl) {
                 const namedVarDecl = toNamedDeconstructVarDecl(elemVarDecl);
                 namedVarDecl.initExpr = lettedElem;
-                assertions.push(...this.introduceDeconstrDataLettedFields(namedVarDecl));
+                const introduceFieldsResult = this.introduceDeconstrDataLettedFields(namedVarDecl, lettedElem);
+                assertions.push(...introduceFieldsResult.implicitAssertions);
+                nestedDeconstructs.push(...introduceFieldsResult.nestedDeconstructs);
             }
             else if (elemVarDecl instanceof TirArrayLikeDeconstr) {
                 elemVarDecl.initExpr = lettedElem;
-                assertions.push(...this.introduceArrayDeconstr(elemVarDecl, true // is destructured field
-                ));
+                const introduceFieldsResult = this.introduceArrayDeconstr(elemVarDecl, true // is destructured field
+                );
+                assertions.push(...introduceFieldsResult.implicitAssertions);
+                nestedDeconstructs.push(...introduceFieldsResult.nestedDeconstructs);
             }
         }
         if (stmt.rest) {
@@ -277,6 +304,9 @@ export class ExpressifyCtx {
                 lettedArrayExpr
             ], new TirListT(elemsType), stmt.range), stmt.range);
         }
-        return assertions;
+        return {
+            implicitAssertions: assertions,
+            nestedDeconstructs
+        };
     }
 }

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

@@ -34,6 +34,7 @@ export function determineReassignedVariablesAndReturn(stmt) {
             returns = true;
             continue;
         }
+        // TODO: can optimize list iterations
         if (stmt instanceof TirAssignmentStmt) {
             reassignedSet.add(stmt.varIdentifier.varName);
             continue;
@@ -147,6 +148,8 @@ export function determineReassignedVariablesAndFlowInfos(stmt) {
             continue;
         }
         const tsEnsureExsaustiveCheck = stmt;
+        console.error("unexpected", stmt);
+        throw new Error("unexpected statement type");
     }
     let reassigned = [...reassignedSet].sort();
     reassigned = keepSortedStrArrInplace(reassigned, originalStmtDeps);
@@ -235,8 +238,16 @@ export function getBodyStateType({ sop, initState }, stmt) {
     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);
+        // using `getUniqueInternalName` here messes up variable access later
+        // due to how for statements are expressified (see piece of code from expressifyForStmt)
+        // ```
+        // // define loop function parameters
+        // for( const { name, type } of bodyStateType.constructors[0].fields ) {
+        //     loopCompilationCtx.setFuncParam( name, type );
+        // }
+        // ```
+        // the introduced vars are taken from the bodyStateType that we derive here
+        const uniqueFieldName = name; // getUniqueInternalName( name );
         bodyStateConstr.fields.push(new TirStructField(uniqueFieldName, type));
         initState.fieldNames.push(new Identifier(uniqueFieldName, range));
         initState.values.push(initExpr);

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

@@ -6,7 +6,8 @@ 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;
+import { TypedProgram } from "../../tir/program/TypedProgram.js";
+export declare function expressify(func: TirFuncExpr, loopReplacements: LoopReplacements | undefined, program: TypedProgram, parentCtx?: ExpressifyCtx | undefined): void;
 export interface LoopReplacements {
     readonly replaceReturnValue: (ctx: ExpressifyCtx, stmt: TirReturnStmt) => TirExpr;
     readonly compileBreak: (ctx: ExpressifyCtx, stmt: TirBreakStmt) => TirExpr;

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

@@ -33,14 +33,14 @@ 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 { expressifyForStmt, loopToForStmt } 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);
+export function expressify(func, loopReplacements, program, parentCtx = undefined) {
+    const ctx = new ExpressifyCtx(parentCtx, func.returnType, program);
     ctx.introduceFuncParams(func.params);
     func.body.stmts = [
         new TirReturnStmt(expressifyFuncBody(ctx, func.body.stmts, loopReplacements), func.body.range)
@@ -52,6 +52,9 @@ loopReplacements, assertions = []) {
     bodyStmts = bodyStmts.slice();
     let stmt;
     while (stmt = bodyStmts.shift()) {
+        // const isEdgeCase = stmt instanceof TirForStmt || stmt instanceof TirForOfStmt || stmt instanceof TirWhileStmt;
+        // if( isEdgeCase ) console.log([stmt, ...bodyStmts].map(s => s.toString()));
+        // if( isEdgeCase ) console.log( stmt );
         if (stmt instanceof TirBreakStmt) {
             if (typeof loopReplacements?.compileBreak !== "function")
                 throw new Error("break statement in function body.");
@@ -71,8 +74,9 @@ loopReplacements, assertions = []) {
                 stmt.value = modifiedExpr;
                 return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, modifiedExpr);
             }
-            else
+            else {
                 return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirLitVoidExpr(stmt.range));
+            }
         }
         // if( isTirVarDecl( stmt ) ) expressifyVarDecl( ctx, stmt );
         else if (stmt instanceof TirSimpleVarDecl) {
@@ -80,7 +84,10 @@ loopReplacements, assertions = []) {
                 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);
+            const lettedExpr = initExpr instanceof TirLettedExpr ? initExpr : ctx.introduceLettedConstant(stmt.name, initExpr, stmt.range);
+            if (!stmt.isConst) {
+                ctx.setNewVariableName(stmt.name, lettedExpr.varName);
+            }
             if (!isSingleConstrStruct(stmt.type))
                 continue;
             if ((initExpr instanceof TirVariableAccessExpr || initExpr instanceof TirLettedExpr)
@@ -128,9 +135,12 @@ loopReplacements, assertions = []) {
                         .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)));
+                const { implicitAssertions, nestedDeconstructs } = ctx.introduceDeconstrDataLettedFields(stmt, lettedExpr);
+                assertions.push(...implicitAssertions);
+                bodyStmts.unshift(...nestedDeconstructs);
                 continue;
             }
+            throw new Error("deconstruction of non-struct type" + stmt.type.toString());
         }
         else if (stmt instanceof TirArrayLikeDeconstr) {
             if (!stmt.initExpr)
@@ -175,8 +185,21 @@ loopReplacements, assertions = []) {
             bodyStmts.push(...nextDeclarations);
             continue;
         }
-        else if (stmt instanceof TirAssignmentStmt)
-            bodyStmts.unshift(expressifyVarAssignmentStmt(ctx, stmt));
+        else if (stmt instanceof TirAssignmentStmt) {
+            void expressifyVarAssignmentStmt(ctx, stmt);
+            // !!! IMPORTANT BUG !!!
+            // .unshift the resulting `TirSimpleVarDecl` into bodyStmts
+            // will cause the assigned expression to be re-expressified
+            // meaning that variables that depend on themselves (e.g. `x = x + 1`) will be processed twice
+            //
+            // x = (x + 1) --> const x_i = (x + 1) --> const x_i = (x_i/*x + 1*/ */ + 1) (??? BUG ???)
+            //
+            // so ultimately `x = x + 1` would be compiled as `x = x + 1 + 1`
+            //
+            // const constDecl = expressifyVarAssignmentStmt( ctx, stmt );
+            // bodyStmts.unshift( constDecl );
+            continue;
+        }
         else if (stmt instanceof TirBlockStmt) {
             // inline the block
             bodyStmts = stmt.stmts.concat(bodyStmts);
@@ -188,8 +211,9 @@ loopReplacements, assertions = []) {
                 stmt.failMsgExpr = modifiedExpr;
                 return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirFailExpr(modifiedExpr, ctx.returnType, stmt.range));
             }
-            else
+            else {
                 return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirFailExpr(undefined, ctx.returnType, stmt.range));
+            }
         }
         else if (stmt instanceof TirAssertStmt) {
             const condition = expressifyVars(ctx, stmt.condition);
@@ -239,7 +263,7 @@ loopReplacements, assertions = []) {
             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));
+            return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, wrapNonTerminatingFinalStmtAsCaseExpr(stmtExpr, sop, ctx, stmt.range, reassignsAndReturns, bodyStmts, loopReplacements));
         }
         else if (stmt instanceof TirMatchStmt) {
             /**
@@ -272,9 +296,8 @@ loopReplacements, assertions = []) {
             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 => {
+                // const { sop, initState } = getBranchStmtReturnType( reassignsAndReturns, ctx, stmt.range );
+                const finalExpression = 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);
@@ -282,43 +305,79 @@ loopReplacements, assertions = []) {
                     flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(_case.pattern, caseCtx);
                     const caseBody = expressifyFuncBody(caseCtx, _case.body instanceof TirBlockStmt
                         ? _case.body.stmts
-                        : [_case.body], loopReplacements, assertions);
+                        : [_case.body], loopReplacements, []);
                     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
+                    : [stmt.wildcardCase.body], loopReplacements, []), stmt.wildcardCase.range) : undefined, ctx.returnType, stmt.range);
+                // expressify as ternary that returns the SoP type
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, 
+                // isDirectReturn === true, so we don't need to wrap
+                finalExpression
+                /*
+                true ? finalExpression : wrapNonTerminatingFinalStmtAsCaseExpr(
+                    finalExpression,
+                    sop,
+                    ctx,
+                    stmt.range,
+                    reassignsAndReturns,
+                    bodyStmts,
+                    loopReplacements
+                )
+                //*/
+                );
             }
+            throw new Error("match statement with multiple non-terminating cases is not implemented yet (sorry)");
         }
+        // else if( stmt instanceof TirForOfStmt ) {
+        // 
+        //     const definitelyTerminates = stmt.definitelyTerminates();
+        // 
+        //     // 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) {
+            || stmt instanceof TirWhileStmt
+            || stmt instanceof TirForOfStmt) {
+            const definitelyTerminates = stmt.definitelyTerminates();
             const reassignedAndFlow = determineReassignedVariablesAndFlowInfos(stmt);
             const returnTypeAndInvalidInit = getBranchStmtReturnType(reassignedAndFlow, ctx, stmt.range);
-            const forStmt = whileToFor(stmt);
+            const forStmt = loopToForStmt(stmt);
             const { bodyStateType, initState } = getBodyStateType(returnTypeAndInvalidInit, forStmt);
-            const loopExpr = expressifyForStmt(ctx.newChild(), forStmt, returnTypeAndInvalidInit.sop, bodyStateType, initState);
+            const loopExprCtx = ctx.newChild();
+            const loopExpr = expressifyForStmt(loopExprCtx, forStmt, returnTypeAndInvalidInit.sop, bodyStateType, initState);
+            const result = TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, definitelyTerminates ? loopExpr : wrapNonTerminatingFinalStmtAsCaseExpr(loopExpr, returnTypeAndInvalidInit.sop, ctx, stmt.range, reassignedAndFlow, bodyStmts, loopReplacements));
+            return result;
         }
         else {
-            const tsEnsureExsautstiveCheck = stmt;
-            console.error(stmt);
-            throw new Error("unreachable::expressify::stmt");
+            // const tsEnsureExhautstiveCheck: never = stmt;
+            // console.error( stmt );
+            // throw new Error("unreachable::expressify::stmt");
         }
+        const tsEnsureExhautstiveCheck = stmt;
+        console.error(stmt);
+        throw new Error("unreachable::expressify::stmt");
     }
     return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirLitVoidExpr(SourceRange.mock));
 }
@@ -355,7 +414,8 @@ function getNestedDestructsInSingleSopDestructPattern(pattern) {
     }
     return result;
 }
-function getFinalStmtCaseExpr(finalStmtExpr, sop, ctx, stmtRange, reassignsAndReturns, nextBodyStmts, loopReplacements) {
+function wrapNonTerminatingFinalStmtAsCaseExpr(finalStmtExpr, sop, ctx, stmtRange, reassignsAndReturns, nextBodyStmts, loopReplacements) {
+    nextBodyStmts = nextBodyStmts.slice();
     const continuations = [];
     const contBranchCtx = ctx.newChild();
     const contConstr = sop.constructors[0];
@@ -370,9 +430,10 @@ function getFinalStmtCaseExpr(finalStmtExpr, sop, ctx, stmtRange, reassignsAndRe
     false, // not a constant
     stmtRange);
     const nestedDeconstructs = flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(contPattern, contBranchCtx);
-    continuations.push(new TirCaseMatcher(contPattern, expressifyFuncBody(contBranchCtx, nestedDeconstructs
+    const mainContinuaiton = expressifyFuncBody(contBranchCtx, nestedDeconstructs
         .concat(nextBodyStmts), loopReplacements, [] // assertions are added before if statement exectution
-    ), stmtRange));
+    );
+    continuations.push(new TirCaseMatcher(contPattern, mainContinuaiton, stmtRange));
     if (reassignsAndReturns.returns) {
         const earlyRetConstr = sop.constructors[1];
         const earlyRetField = earlyRetConstr.fields[0];

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

@@ -1,8 +1,9 @@
 import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
 import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
+import { TirForOfStmt } from "../../tir/statements/TirForOfStmt.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 loopToForStmt(stmt: TirWhileStmt | TirForOfStmt | TirForStmt): TirForStmt;
 export declare function expressifyForStmt(ctx: ExpressifyCtx, stmt: TirForStmt, returnType: TirSoPStructType, bodyStateType: TirSoPStructType, initState: TirLitNamedObjExpr): TirCallExpr;