@tsonic/frontend 0.0.62 → 0.0.63

package/dist/ir/validation/yield-lowering-pass.js

@@ -10,13 +10,19 @@
  * - `x = yield expr;` → IrYieldStatement with receiveTarget = identifierPattern
  * - `const {a, b} = yield expr;` → IrYieldStatement with receiveTarget = objectPattern
  * - `const [a, b] = yield expr;` → IrYieldStatement with receiveTarget = arrayPattern
+ * - `return yield expr;` → IrYieldStatement + IrGeneratorReturnStatement(temp)
+ * - `throw yield expr;` → IrYieldStatement + IrThrowStatement(temp)
+ * - `for (x = yield expr; ... )` → IrYieldStatement + ForStatement(without initializer)
+ * - `for (; yield cond; ... )` → ForStatement(condition=true) + loop-body condition prelude
+ * - `for (...; ...; yield update)` → ForStatement(update=undefined) + loop-body update prelude
+ * - `for (... of yield expr)` / `for (... in yield expr)` → IrYieldStatement + loop over temp
+ * - `if (yield expr) { ... }` → IrYieldStatement + IfStatement(temp)
+ * - `switch (yield expr) { ... }` → IrYieldStatement + SwitchStatement(temp)
+ * - `while (yield expr) { ... }` → While(true) with per-iteration yield+guard
+ * - `const x = cond ? (yield a) : (yield b)` → temp + branch-lowered yields
  *
  * Unsupported patterns (emit TSN6101 diagnostic):
- * - `foo(yield x)` - yield in call argument
- * - `yield x + yield y` - multiple yields in expression
- * - `[yield x, 1]` - yield in array literal
- * - `{a: yield x}` - yield in object literal
- * - `cond ? yield a : b` - yield in ternary
+ * - assignment target forms that cannot be lowered as a deterministic l-value
  */
 import { createDiagnostic, } from "../../types/diagnostic.js";
 /**
@@ -142,6 +148,17 @@ const createYieldStatement = (yieldExpr, receiveTarget, receivedType) => ({
     receiveTarget,
     receivedType,
 });
+const toReceivePattern = (target) => {
+    if (target.kind === "identifierPattern" ||
+        target.kind === "arrayPattern" ||
+        target.kind === "objectPattern") {
+        return target;
+    }
+    if (target.kind === "identifier") {
+        return { kind: "identifierPattern", name: target.name };
+    }
+    return undefined;
+};
 /**
  * Create an IrGeneratorReturnStatement from a return statement's expression.
  * This captures the return value for generators with TReturn.
@@ -156,6 +173,425 @@ const createGeneratorReturnStatement = (expression) => ({
 const emitUnsupportedYieldDiagnostic = (ctx, position, location) => {
     ctx.diagnostics.push(createDiagnostic("TSN6101", "error", `Yield expression in ${position} is not supported`, location ?? moduleLocation(ctx), "Extract yield to a separate statement: `const result = yield expr; use(result);`"));
 };
+const allocateYieldTempName = (ctx) => {
+    ctx.yieldTempCounter += 1;
+    return `__tsonic_yield_${ctx.yieldTempCounter}`;
+};
+const createTempVariableDeclaration = (name, initializer, inferredType) => ({
+    kind: "variableDeclaration",
+    declarationKind: "const",
+    isExported: false,
+    declarations: [
+        {
+            kind: "variableDeclarator",
+            name: { kind: "identifierPattern", name },
+            type: inferredType,
+            initializer,
+        },
+    ],
+});
+const lowerMemberAccessAssignmentWithYields = (assignment, ctx, positionLabels) => {
+    if (assignment.left.kind !== "memberAccess") {
+        return undefined;
+    }
+    const loweredObject = lowerExpressionWithYields(assignment.left.object, ctx, positionLabels.object, assignment.left.object.inferredType);
+    if (!loweredObject) {
+        return undefined;
+    }
+    const leadingStatements = [...loweredObject.prelude];
+    const objectTempName = allocateYieldTempName(ctx);
+    leadingStatements.push(createTempVariableDeclaration(objectTempName, loweredObject.expression, loweredObject.expression.inferredType));
+    let loweredProperty = assignment.left.property;
+    if (typeof assignment.left.property !== "string") {
+        const loweredPropertyExpr = lowerExpressionWithYields(assignment.left.property, ctx, positionLabels.property, assignment.left.property.inferredType);
+        if (!loweredPropertyExpr) {
+            return undefined;
+        }
+        leadingStatements.push(...loweredPropertyExpr.prelude);
+        const propertyTempName = allocateYieldTempName(ctx);
+        leadingStatements.push(createTempVariableDeclaration(propertyTempName, loweredPropertyExpr.expression, loweredPropertyExpr.expression.inferredType));
+        loweredProperty = { kind: "identifier", name: propertyTempName };
+    }
+    let loweredRight = assignment.right;
+    if (assignment.right.kind === "yield" && !assignment.right.delegate) {
+        const receiveTempName = allocateYieldTempName(ctx);
+        leadingStatements.push(createYieldStatement(assignment.right, { kind: "identifierPattern", name: receiveTempName }, assignment.right.inferredType));
+        loweredRight = { kind: "identifier", name: receiveTempName };
+    }
+    else if (containsYield(assignment.right)) {
+        const loweredRightExpr = lowerExpressionWithYields(assignment.right, ctx, positionLabels.right, assignment.right.inferredType);
+        if (!loweredRightExpr) {
+            return undefined;
+        }
+        leadingStatements.push(...loweredRightExpr.prelude);
+        loweredRight = loweredRightExpr.expression;
+    }
+    return {
+        leadingStatements,
+        loweredAssignment: {
+            ...assignment,
+            left: {
+                ...assignment.left,
+                object: { kind: "identifier", name: objectTempName },
+                property: loweredProperty,
+            },
+            right: loweredRight,
+        },
+    };
+};
+/**
+ * Lower yield expressions that appear inside larger expression trees into
+ * leading IrYieldStatement nodes plus a rewritten expression that references
+ * temp identifiers.
+ *
+ * This preserves left-to-right evaluation order for supported expression forms.
+ * Unsupported forms emit TSN6101 and return undefined.
+ */
+const lowerExpressionWithYields = (expression, ctx, position, expectedType) => {
+    const lower = (expr) => {
+        if (!containsYield(expr)) {
+            return { prelude: [], expression: expr };
+        }
+        switch (expr.kind) {
+            case "yield": {
+                const tempName = allocateYieldTempName(ctx);
+                return {
+                    prelude: [
+                        createYieldStatement(expr, { kind: "identifierPattern", name: tempName }, expr.inferredType),
+                    ],
+                    expression: { kind: "identifier", name: tempName },
+                };
+            }
+            case "unary":
+            case "update":
+            case "await":
+            case "spread":
+            case "numericNarrowing":
+            case "typeAssertion":
+            case "asinterface":
+            case "trycast": {
+                const lowered = lower(expr.expression);
+                if (!lowered)
+                    return undefined;
+                return {
+                    prelude: lowered.prelude,
+                    expression: {
+                        ...expr,
+                        expression: lowered.expression,
+                    },
+                };
+            }
+            case "stackalloc": {
+                const loweredSize = lower(expr.size);
+                if (!loweredSize)
+                    return undefined;
+                return {
+                    prelude: loweredSize.prelude,
+                    expression: {
+                        ...expr,
+                        size: loweredSize.expression,
+                    },
+                };
+            }
+            case "binary":
+            case "logical": {
+                const loweredLeft = lower(expr.left);
+                if (!loweredLeft)
+                    return undefined;
+                const loweredRight = lower(expr.right);
+                if (!loweredRight)
+                    return undefined;
+                return {
+                    prelude: [...loweredLeft.prelude, ...loweredRight.prelude],
+                    expression: {
+                        ...expr,
+                        left: loweredLeft.expression,
+                        right: loweredRight.expression,
+                    },
+                };
+            }
+            case "assignment": {
+                if (expr.left.kind !== "identifierPattern" &&
+                    expr.left.kind !== "arrayPattern" &&
+                    expr.left.kind !== "objectPattern" &&
+                    containsYield(expr.left)) {
+                    if (expr.left.kind !== "memberAccess") {
+                        emitUnsupportedYieldDiagnostic(ctx, `${position} assignment target`);
+                        return undefined;
+                    }
+                    const loweredObject = lower(expr.left.object);
+                    if (!loweredObject)
+                        return undefined;
+                    let loweredProperty = expr.left.property;
+                    let propertyPrelude = [];
+                    if (typeof expr.left.property !== "string") {
+                        const loweredPropertyExpr = lower(expr.left.property);
+                        if (!loweredPropertyExpr)
+                            return undefined;
+                        loweredProperty = loweredPropertyExpr.expression;
+                        propertyPrelude = loweredPropertyExpr.prelude;
+                    }
+                    const loweredRight = lower(expr.right);
+                    if (!loweredRight)
+                        return undefined;
+                    return {
+                        prelude: [
+                            ...loweredObject.prelude,
+                            ...propertyPrelude,
+                            ...loweredRight.prelude,
+                        ],
+                        expression: {
+                            ...expr,
+                            left: {
+                                ...expr.left,
+                                object: loweredObject.expression,
+                                property: loweredProperty,
+                            },
+                            right: loweredRight.expression,
+                        },
+                    };
+                }
+                const loweredRight = lower(expr.right);
+                if (!loweredRight)
+                    return undefined;
+                return {
+                    prelude: loweredRight.prelude,
+                    expression: {
+                        ...expr,
+                        right: loweredRight.expression,
+                    },
+                };
+            }
+            case "memberAccess": {
+                const loweredObject = lower(expr.object);
+                if (!loweredObject)
+                    return undefined;
+                let loweredProperty = expr.property;
+                let propertyPrelude = [];
+                if (typeof expr.property !== "string") {
+                    const loweredPropExpr = lower(expr.property);
+                    if (!loweredPropExpr)
+                        return undefined;
+                    loweredProperty = loweredPropExpr.expression;
+                    propertyPrelude = loweredPropExpr.prelude;
+                }
+                return {
+                    prelude: [...loweredObject.prelude, ...propertyPrelude],
+                    expression: {
+                        ...expr,
+                        object: loweredObject.expression,
+                        property: loweredProperty,
+                    },
+                };
+            }
+            case "call":
+            case "new": {
+                const loweredCallee = lower(expr.callee);
+                if (!loweredCallee)
+                    return undefined;
+                const preludes = [...loweredCallee.prelude];
+                const loweredArgs = [];
+                for (const argument of expr.arguments) {
+                    if (argument.kind === "spread") {
+                        const loweredSpreadExpr = lower(argument.expression);
+                        if (!loweredSpreadExpr)
+                            return undefined;
+                        preludes.push(...loweredSpreadExpr.prelude);
+                        loweredArgs.push({
+                            kind: "spread",
+                            expression: loweredSpreadExpr.expression,
+                        });
+                    }
+                    else {
+                        const loweredArg = lower(argument);
+                        if (!loweredArg)
+                            return undefined;
+                        preludes.push(...loweredArg.prelude);
+                        loweredArgs.push(loweredArg.expression);
+                    }
+                }
+                return {
+                    prelude: preludes,
+                    expression: {
+                        ...expr,
+                        callee: loweredCallee.expression,
+                        arguments: loweredArgs,
+                    },
+                };
+            }
+            case "array": {
+                const preludes = [];
+                const loweredElements = [];
+                for (const element of expr.elements) {
+                    if (!element) {
+                        loweredElements.push(undefined);
+                        continue;
+                    }
+                    if (element.kind === "spread") {
+                        const loweredSpreadExpr = lower(element.expression);
+                        if (!loweredSpreadExpr)
+                            return undefined;
+                        preludes.push(...loweredSpreadExpr.prelude);
+                        loweredElements.push({
+                            kind: "spread",
+                            expression: loweredSpreadExpr.expression,
+                        });
+                        continue;
+                    }
+                    const loweredElement = lower(element);
+                    if (!loweredElement)
+                        return undefined;
+                    preludes.push(...loweredElement.prelude);
+                    loweredElements.push(loweredElement.expression);
+                }
+                return {
+                    prelude: preludes,
+                    expression: {
+                        ...expr,
+                        elements: loweredElements,
+                    },
+                };
+            }
+            case "object": {
+                const preludes = [];
+                const loweredProperties = [];
+                for (const property of expr.properties) {
+                    if (property.kind === "spread") {
+                        const loweredSpreadExpr = lower(property.expression);
+                        if (!loweredSpreadExpr)
+                            return undefined;
+                        preludes.push(...loweredSpreadExpr.prelude);
+                        loweredProperties.push({
+                            kind: "spread",
+                            expression: loweredSpreadExpr.expression,
+                        });
+                        continue;
+                    }
+                    let loweredKey = property.key;
+                    if (typeof property.key !== "string") {
+                        const loweredKeyExpr = lower(property.key);
+                        if (!loweredKeyExpr)
+                            return undefined;
+                        preludes.push(...loweredKeyExpr.prelude);
+                        loweredKey = loweredKeyExpr.expression;
+                    }
+                    const loweredValue = lower(property.value);
+                    if (!loweredValue)
+                        return undefined;
+                    preludes.push(...loweredValue.prelude);
+                    loweredProperties.push({
+                        kind: "property",
+                        key: loweredKey,
+                        value: loweredValue.expression,
+                        shorthand: property.shorthand,
+                    });
+                }
+                return {
+                    prelude: preludes,
+                    expression: {
+                        ...expr,
+                        properties: loweredProperties,
+                    },
+                };
+            }
+            case "templateLiteral": {
+                const preludes = [];
+                const loweredExpressions = [];
+                for (const templateExpr of expr.expressions) {
+                    const loweredTemplateExpr = lower(templateExpr);
+                    if (!loweredTemplateExpr)
+                        return undefined;
+                    preludes.push(...loweredTemplateExpr.prelude);
+                    loweredExpressions.push(loweredTemplateExpr.expression);
+                }
+                return {
+                    prelude: preludes,
+                    expression: {
+                        ...expr,
+                        expressions: loweredExpressions,
+                    },
+                };
+            }
+            case "conditional": {
+                const loweredCondition = lower(expr.condition);
+                if (!loweredCondition)
+                    return undefined;
+                const loweredWhenTrue = lower(expr.whenTrue);
+                if (!loweredWhenTrue)
+                    return undefined;
+                const loweredWhenFalse = lower(expr.whenFalse);
+                if (!loweredWhenFalse)
+                    return undefined;
+                const tempType = expr.inferredType ??
+                    expectedType ??
+                    loweredWhenTrue.expression.inferredType ??
+                    loweredWhenFalse.expression.inferredType;
+                if (!tempType) {
+                    emitUnsupportedYieldDiagnostic(ctx, `${position} conditional expression`, expr.sourceSpan);
+                    return undefined;
+                }
+                const tempName = allocateYieldTempName(ctx);
+                const tempPattern = {
+                    kind: "identifierPattern",
+                    name: tempName,
+                };
+                const assignTrueStatement = {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "assignment",
+                        operator: "=",
+                        left: tempPattern,
+                        right: loweredWhenTrue.expression,
+                    },
+                };
+                const assignFalseStatement = {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "assignment",
+                        operator: "=",
+                        left: tempPattern,
+                        right: loweredWhenFalse.expression,
+                    },
+                };
+                return {
+                    prelude: [
+                        ...loweredCondition.prelude,
+                        {
+                            kind: "variableDeclaration",
+                            declarationKind: "let",
+                            isExported: false,
+                            declarations: [
+                                {
+                                    kind: "variableDeclarator",
+                                    name: tempPattern,
+                                    type: tempType,
+                                    initializer: { kind: "literal", value: undefined },
+                                },
+                            ],
+                        },
+                        {
+                            kind: "ifStatement",
+                            condition: loweredCondition.expression,
+                            thenStatement: {
+                                kind: "blockStatement",
+                                statements: [...loweredWhenTrue.prelude, assignTrueStatement],
+                            },
+                            elseStatement: {
+                                kind: "blockStatement",
+                                statements: [...loweredWhenFalse.prelude, assignFalseStatement],
+                            },
+                        },
+                    ],
+                    expression: { kind: "identifier", name: tempName },
+                };
+            }
+            default:
+                emitUnsupportedYieldDiagnostic(ctx, position, expr.sourceSpan);
+                return undefined;
+        }
+    };
+    return lower(expression);
+};
 /**
  * Process a statement in a generator function body.
  * Returns the transformed statement(s) - may return multiple statements
@@ -174,28 +610,116 @@ const processStatement = (stmt, ctx) => {
                 return createYieldStatement(expr, undefined, undefined);
             }
             // Pattern 3: x = yield expr; (assignment with yield on right)
-            if (expr.kind === "assignment" &&
-                expr.right.kind === "yield" &&
-                !expr.right.delegate) {
-                // Only support simple assignment operators (=)
-                if (expr.operator !== "=") {
-                    emitUnsupportedYieldDiagnostic(ctx, "compound assignment", expr.right.sourceSpan);
-                    return stmt;
+            if (expr.kind === "assignment") {
+                if (expr.operator === "=" &&
+                    expr.left.kind === "memberAccess" &&
+                    ((expr.right.kind === "yield" && !expr.right.delegate) ||
+                        containsYield(expr.left))) {
+                    const loweredMemberAssignment = lowerMemberAccessAssignmentWithYields(expr, ctx, {
+                        object: "assignment target object",
+                        property: "assignment target property",
+                        right: "assignment value",
+                    });
+                    if (!loweredMemberAssignment) {
+                        return stmt;
+                    }
+                    return [
+                        ...loweredMemberAssignment.leadingStatements,
+                        {
+                            kind: "expressionStatement",
+                            expression: loweredMemberAssignment.loweredAssignment,
+                        },
+                    ];
                 }
-                // Extract the target pattern
-                const target = expr.left;
-                if (target.kind === "identifierPattern" ||
-                    target.kind === "arrayPattern" ||
-                    target.kind === "objectPattern") {
-                    return createYieldStatement(expr.right, target, expr.right.inferredType);
+                if (expr.right.kind === "yield" && !expr.right.delegate) {
+                    // Compound assignment (x += yield y) needs a temporary receive target,
+                    // then an explicit compound update statement.
+                    if (expr.operator !== "=") {
+                        if (expr.left.kind !== "identifierPattern" &&
+                            expr.left.kind !== "identifier" &&
+                            expr.left.kind !== "memberAccess") {
+                            emitUnsupportedYieldDiagnostic(ctx, "compound assignment to complex target", expr.right.sourceSpan);
+                            return stmt;
+                        }
+                        if (expr.left.kind === "identifierPattern" ||
+                            expr.left.kind === "identifier") {
+                            const tempName = allocateYieldTempName(ctx);
+                            const leftExpr = expr.left.kind === "identifierPattern"
+                                ? { kind: "identifier", name: expr.left.name }
+                                : expr.left;
+                            return [
+                                createYieldStatement(expr.right, { kind: "identifierPattern", name: tempName }, expr.right.inferredType),
+                                {
+                                    kind: "expressionStatement",
+                                    expression: {
+                                        ...expr,
+                                        left: leftExpr,
+                                        right: { kind: "identifier", name: tempName },
+                                    },
+                                },
+                            ];
+                        }
+                        const loweredObject = lowerExpressionWithYields(expr.left.object, ctx, "compound assignment target object", expr.left.object.inferredType);
+                        if (!loweredObject) {
+                            return stmt;
+                        }
+                        const objectTempName = allocateYieldTempName(ctx);
+                        const leadingStatements = [
+                            ...loweredObject.prelude,
+                            createTempVariableDeclaration(objectTempName, loweredObject.expression, loweredObject.expression.inferredType),
+                        ];
+                        let propertyExpr = expr.left.property;
+                        if (typeof expr.left.property !== "string") {
+                            const loweredProperty = lowerExpressionWithYields(expr.left.property, ctx, "compound assignment target property", expr.left.property.inferredType);
+                            if (!loweredProperty) {
+                                return stmt;
+                            }
+                            leadingStatements.push(...loweredProperty.prelude);
+                            const propertyTempName = allocateYieldTempName(ctx);
+                            leadingStatements.push(createTempVariableDeclaration(propertyTempName, loweredProperty.expression, loweredProperty.expression.inferredType));
+                            propertyExpr = { kind: "identifier", name: propertyTempName };
+                        }
+                        const receiveTempName = allocateYieldTempName(ctx);
+                        return [
+                            ...leadingStatements,
+                            createYieldStatement(expr.right, { kind: "identifierPattern", name: receiveTempName }, expr.right.inferredType),
+                            {
+                                kind: "expressionStatement",
+                                expression: {
+                                    ...expr,
+                                    left: {
+                                        ...expr.left,
+                                        object: { kind: "identifier", name: objectTempName },
+                                        property: propertyExpr,
+                                    },
+                                    right: { kind: "identifier", name: receiveTempName },
+                                },
+                            },
+                        ];
+                    }
+                    // Extract the target pattern
+                    const receiveTarget = toReceivePattern(expr.left);
+                    if (receiveTarget) {
+                        return createYieldStatement(expr.right, receiveTarget, expr.right.inferredType);
+                    }
+                    // Assignment to member expression or other LHS - not supported
+                    emitUnsupportedYieldDiagnostic(ctx, "assignment to complex target", expr.right.sourceSpan);
+                    return stmt;
                 }
-                // Assignment to member expression or other LHS - not supported
-                emitUnsupportedYieldDiagnostic(ctx, "assignment to complex target", expr.right.sourceSpan);
-                return stmt;
             }
             // Check for yield in unsupported positions
             if (containsYield(expr)) {
-                emitUnsupportedYieldDiagnostic(ctx, "complex expression", expr.sourceSpan);
+                const lowered = lowerExpressionWithYields(expr, ctx, "expression statement");
+                if (!lowered) {
+                    return stmt;
+                }
+                return [
+                    ...lowered.prelude,
+                    {
+                        ...stmt,
+                        expression: lowered.expression,
+                    },
+                ];
             }
             return stmt;
         }
@@ -219,12 +743,26 @@ const processStatement = (stmt, ctx) => {
                     transformedDeclarations.push(createYieldStatement(decl.initializer, decl.name, decl.type ?? decl.initializer.inferredType));
                 }
                 else if (decl.initializer && containsYield(decl.initializer)) {
-                    // Yield nested in initializer expression - not supported
-                    emitUnsupportedYieldDiagnostic(ctx, "nested initializer expression", decl.initializer.sourceSpan);
+                    const lowered = lowerExpressionWithYields(decl.initializer, ctx, "variable initializer", decl.type ?? decl.initializer.inferredType);
+                    if (!lowered) {
+                        transformedDeclarations.push({
+                            kind: "variableDeclaration",
+                            declarationKind: stmt.declarationKind,
+                            declarations: [decl],
+                            isExported: false,
+                        });
+                        continue;
+                    }
+                    transformedDeclarations.push(...lowered.prelude);
                     transformedDeclarations.push({
                         kind: "variableDeclaration",
                         declarationKind: stmt.declarationKind,
-                        declarations: [decl],
+                        declarations: [
+                            {
+                                ...decl,
+                                initializer: lowered.expression,
+                            },
+                        ],
                         isExported: false,
                     });
                 }
@@ -254,6 +792,29 @@ const processStatement = (stmt, ctx) => {
                 }),
             };
         case "ifStatement":
+            if (containsYield(stmt.condition)) {
+                const loweredCondition = lowerExpressionWithYields(stmt.condition, ctx, "if condition");
+                if (!loweredCondition) {
+                    return {
+                        ...stmt,
+                        thenStatement: flattenStatement(processStatement(stmt.thenStatement, ctx)),
+                        elseStatement: stmt.elseStatement
+                            ? flattenStatement(processStatement(stmt.elseStatement, ctx))
+                            : undefined,
+                    };
+                }
+                return [
+                    ...loweredCondition.prelude,
+                    {
+                        ...stmt,
+                        condition: loweredCondition.expression,
+                        thenStatement: flattenStatement(processStatement(stmt.thenStatement, ctx)),
+                        elseStatement: stmt.elseStatement
+                            ? flattenStatement(processStatement(stmt.elseStatement, ctx))
+                            : undefined,
+                    },
+                ];
+            }
             return {
                 ...stmt,
                 thenStatement: flattenStatement(processStatement(stmt.thenStatement, ctx)),
@@ -262,40 +823,310 @@ const processStatement = (stmt, ctx) => {
                     : undefined,
             };
         case "whileStatement":
+            if (containsYield(stmt.condition)) {
+                const loweredCondition = lowerExpressionWithYields(stmt.condition, ctx, "while condition");
+                if (!loweredCondition) {
+                    return {
+                        ...stmt,
+                        body: flattenStatement(processStatement(stmt.body, ctx)),
+                    };
+                }
+                const transformedBody = flattenStatement(processStatement(stmt.body, ctx));
+                const bodyStatements = [
+                    ...loweredCondition.prelude,
+                    {
+                        kind: "ifStatement",
+                        condition: {
+                            kind: "unary",
+                            operator: "!",
+                            expression: loweredCondition.expression,
+                        },
+                        thenStatement: { kind: "breakStatement" },
+                    },
+                ];
+                if (transformedBody.kind === "blockStatement") {
+                    bodyStatements.push(...transformedBody.statements);
+                }
+                else {
+                    bodyStatements.push(transformedBody);
+                }
+                return {
+                    kind: "whileStatement",
+                    condition: { kind: "literal", value: true },
+                    body: {
+                        kind: "blockStatement",
+                        statements: bodyStatements,
+                    },
+                };
+            }
             return {
                 ...stmt,
                 body: flattenStatement(processStatement(stmt.body, ctx)),
             };
         case "forStatement": {
-            // Check for yield in initializer - not supported
-            if (stmt.initializer) {
-                if (stmt.initializer.kind === "variableDeclaration" &&
-                    stmt.initializer.declarations.some((d) => d.initializer && containsYield(d.initializer))) {
-                    emitUnsupportedYieldDiagnostic(ctx, "for loop initializer");
+            const leadingStatements = [];
+            let initializer = stmt.initializer;
+            if (initializer) {
+                if (initializer.kind === "assignment" &&
+                    initializer.operator === "=" &&
+                    ((initializer.right.kind === "yield" &&
+                        !initializer.right.delegate) ||
+                        (initializer.left.kind === "memberAccess" &&
+                            containsYield(initializer.left)))) {
+                    const receiveTarget = toReceivePattern(initializer.left);
+                    if (receiveTarget &&
+                        initializer.right.kind === "yield" &&
+                        !initializer.right.delegate) {
+                        leadingStatements.push(createYieldStatement(initializer.right, receiveTarget, initializer.right.inferredType));
+                        initializer = undefined;
+                    }
+                    else if (receiveTarget) {
+                        emitUnsupportedYieldDiagnostic(ctx, "for loop initializer", initializer.right.sourceSpan);
+                    }
+                    else if (initializer.left.kind === "memberAccess") {
+                        const loweredMemberAssignment = lowerMemberAccessAssignmentWithYields(initializer, ctx, {
+                            object: "for loop initializer target object",
+                            property: "for loop initializer target property",
+                            right: "for loop initializer value",
+                        });
+                        if (!loweredMemberAssignment) {
+                            emitUnsupportedYieldDiagnostic(ctx, "for loop initializer", initializer.right.sourceSpan);
+                        }
+                        else {
+                            leadingStatements.push(...loweredMemberAssignment.leadingStatements);
+                            leadingStatements.push({
+                                kind: "expressionStatement",
+                                expression: loweredMemberAssignment.loweredAssignment,
+                            });
+                            initializer = undefined;
+                        }
+                    }
+                    else {
+                        emitUnsupportedYieldDiagnostic(ctx, "for loop initializer", initializer.right.sourceSpan);
+                    }
+                }
+                else if (initializer.kind === "variableDeclaration") {
+                    const transformedDecls = initializer.declarations.map((decl) => {
+                        if (!decl.initializer || !containsYield(decl.initializer)) {
+                            return decl;
+                        }
+                        if (decl.initializer.kind === "yield" &&
+                            !decl.initializer.delegate) {
+                            const tempName = allocateYieldTempName(ctx);
+                            leadingStatements.push(createYieldStatement(decl.initializer, { kind: "identifierPattern", name: tempName }, decl.type ?? decl.initializer.inferredType));
+                            return {
+                                ...decl,
+                                initializer: {
+                                    kind: "identifier",
+                                    name: tempName,
+                                },
+                            };
+                        }
+                        const loweredInitializer = lowerExpressionWithYields(decl.initializer, ctx, "for loop initializer", decl.type ?? decl.initializer.inferredType);
+                        if (!loweredInitializer) {
+                            return decl;
+                        }
+                        leadingStatements.push(...loweredInitializer.prelude);
+                        return {
+                            ...decl,
+                            initializer: loweredInitializer.expression,
+                        };
+                    });
+                    initializer = {
+                        ...initializer,
+                        declarations: transformedDecls,
+                    };
+                }
+                else if (containsYield(initializer)) {
+                    const loweredInitializer = lowerExpressionWithYields(initializer, ctx, "for loop initializer");
+                    if (loweredInitializer) {
+                        leadingStatements.push(...loweredInitializer.prelude);
+                        initializer = loweredInitializer.expression;
+                    }
+                }
+            }
+            const loweredCondition = stmt.condition && containsYield(stmt.condition)
+                ? lowerExpressionWithYields(stmt.condition, ctx, "for loop condition")
+                : undefined;
+            const loweredUpdate = stmt.update && containsYield(stmt.update)
+                ? lowerExpressionWithYields(stmt.update, ctx, "for loop update")
+                : undefined;
+            const transformedBody = flattenStatement(processStatement(stmt.body, ctx));
+            if (!loweredCondition && !loweredUpdate) {
+                const transformedFor = {
+                    ...stmt,
+                    initializer,
+                    body: transformedBody,
+                };
+                if (leadingStatements.length === 0) {
+                    return transformedFor;
                 }
-                else if (stmt.initializer.kind !== "variableDeclaration" &&
-                    containsYield(stmt.initializer)) {
-                    emitUnsupportedYieldDiagnostic(ctx, "for loop initializer");
+                return [...leadingStatements, transformedFor];
+            }
+            const bodyStatements = [];
+            let updateFirstFlagName;
+            if (loweredUpdate) {
+                updateFirstFlagName = allocateYieldTempName(ctx);
+                leadingStatements.push({
+                    kind: "variableDeclaration",
+                    declarationKind: "let",
+                    isExported: false,
+                    declarations: [
+                        {
+                            kind: "variableDeclarator",
+                            name: { kind: "identifierPattern", name: updateFirstFlagName },
+                            type: { kind: "primitiveType", name: "boolean" },
+                            initializer: { kind: "literal", value: true },
+                        },
+                    ],
+                });
+                const updateBodyStatements = [...loweredUpdate.prelude];
+                if (!stmt.update || stmt.update.kind !== "yield") {
+                    updateBodyStatements.push({
+                        kind: "expressionStatement",
+                        expression: loweredUpdate.expression,
+                    });
                 }
+                bodyStatements.push({
+                    kind: "ifStatement",
+                    condition: {
+                        kind: "unary",
+                        operator: "!",
+                        expression: { kind: "identifier", name: updateFirstFlagName },
+                    },
+                    thenStatement: {
+                        kind: "blockStatement",
+                        statements: updateBodyStatements,
+                    },
+                });
+                bodyStatements.push({
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "assignment",
+                        operator: "=",
+                        left: { kind: "identifierPattern", name: updateFirstFlagName },
+                        right: { kind: "literal", value: false },
+                    },
+                });
+            }
+            if (loweredCondition) {
+                bodyStatements.push(...loweredCondition.prelude);
+                bodyStatements.push({
+                    kind: "ifStatement",
+                    condition: {
+                        kind: "unary",
+                        operator: "!",
+                        expression: loweredCondition.expression,
+                    },
+                    thenStatement: { kind: "breakStatement" },
+                });
             }
-            // Check for yield in condition/update - not supported
-            if (stmt.condition && containsYield(stmt.condition)) {
-                emitUnsupportedYieldDiagnostic(ctx, "for loop condition");
+            else if (loweredUpdate && stmt.condition) {
+                bodyStatements.push({
+                    kind: "ifStatement",
+                    condition: {
+                        kind: "unary",
+                        operator: "!",
+                        expression: stmt.condition,
+                    },
+                    thenStatement: { kind: "breakStatement" },
+                });
             }
-            if (stmt.update && containsYield(stmt.update)) {
-                emitUnsupportedYieldDiagnostic(ctx, "for loop update");
+            if (transformedBody.kind === "blockStatement") {
+                bodyStatements.push(...transformedBody.statements);
             }
-            return {
+            else {
+                bodyStatements.push(transformedBody);
+            }
+            const transformedFor = {
                 ...stmt,
-                body: flattenStatement(processStatement(stmt.body, ctx)),
+                initializer,
+                condition: { kind: "literal", value: true },
+                update: loweredUpdate ? undefined : stmt.update,
+                body: {
+                    kind: "blockStatement",
+                    statements: bodyStatements,
+                },
             };
+            if (leadingStatements.length === 0) {
+                return transformedFor;
+            }
+            return [...leadingStatements, transformedFor];
         }
         case "forOfStatement":
+            if (containsYield(stmt.expression)) {
+                const loweredExpression = lowerExpressionWithYields(stmt.expression, ctx, "for-of expression");
+                if (!loweredExpression) {
+                    return {
+                        ...stmt,
+                        body: flattenStatement(processStatement(stmt.body, ctx)),
+                    };
+                }
+                return [
+                    ...loweredExpression.prelude,
+                    {
+                        ...stmt,
+                        expression: loweredExpression.expression,
+                        body: flattenStatement(processStatement(stmt.body, ctx)),
+                    },
+                ];
+            }
+            return {
+                ...stmt,
+                body: flattenStatement(processStatement(stmt.body, ctx)),
+            };
+        case "forInStatement":
+            if (containsYield(stmt.expression)) {
+                const loweredExpression = lowerExpressionWithYields(stmt.expression, ctx, "for-in expression");
+                if (!loweredExpression) {
+                    return {
+                        ...stmt,
+                        body: flattenStatement(processStatement(stmt.body, ctx)),
+                    };
+                }
+                return [
+                    ...loweredExpression.prelude,
+                    {
+                        ...stmt,
+                        expression: loweredExpression.expression,
+                        body: flattenStatement(processStatement(stmt.body, ctx)),
+                    },
+                ];
+            }
             return {
                 ...stmt,
                 body: flattenStatement(processStatement(stmt.body, ctx)),
             };
         case "switchStatement":
+            if (containsYield(stmt.expression)) {
+                const loweredExpression = lowerExpressionWithYields(stmt.expression, ctx, "switch expression");
+                if (!loweredExpression) {
+                    return {
+                        ...stmt,
+                        cases: stmt.cases.map((c) => ({
+                            ...c,
+                            statements: c.statements.flatMap((s) => {
+                                const result = processStatement(s, ctx);
+                                return Array.isArray(result) ? result : [result];
+                            }),
+                        })),
+                    };
+                }
+                return [
+                    ...loweredExpression.prelude,
+                    {
+                        ...stmt,
+                        expression: loweredExpression.expression,
+                        cases: stmt.cases.map((c) => ({
+                            ...c,
+                            statements: c.statements.flatMap((s) => {
+                                const result = processStatement(s, ctx);
+                                return Array.isArray(result) ? result : [result];
+                            }),
+                        })),
+                    },
+                ];
+            }
             return {
                 ...stmt,
                 cases: stmt.cases.map((c) => ({
@@ -321,18 +1152,33 @@ const processStatement = (stmt, ctx) => {
                     : undefined,
             };
         case "returnStatement":
-            // Check for yield in return expression
             if (stmt.expression && containsYield(stmt.expression)) {
-                emitUnsupportedYieldDiagnostic(ctx, "return expression", stmt.expression.sourceSpan);
+                const lowered = lowerExpressionWithYields(stmt.expression, ctx, "return expression");
+                if (!lowered) {
+                    return createGeneratorReturnStatement(stmt.expression);
+                }
+                return [
+                    ...lowered.prelude,
+                    createGeneratorReturnStatement(lowered.expression),
+                ];
             }
             // Transform return statements in generators to IrGeneratorReturnStatement
             // This captures the return value for generators with TReturn
             // The emitter will emit: __returnValue = expr; yield break;
             return createGeneratorReturnStatement(stmt.expression);
         case "throwStatement":
-            // Check for yield in throw expression
             if (containsYield(stmt.expression)) {
-                emitUnsupportedYieldDiagnostic(ctx, "throw expression", stmt.expression.sourceSpan);
+                const lowered = lowerExpressionWithYields(stmt.expression, ctx, "throw expression");
+                if (!lowered) {
+                    return stmt;
+                }
+                return [
+                    ...lowered.prelude,
+                    {
+                        kind: "throwStatement",
+                        expression: lowered.expression,
+                    },
+                ];
             }
             return stmt;
         default:
@@ -361,6 +1207,45 @@ const flattenStatement = (result) => {
         statements: [...result],
     };
 };
+const isRecord = (value) => typeof value === "object" && value !== null;
+const collectResidualYieldExpressions = (value, collected) => {
+    if (Array.isArray(value)) {
+        for (const element of value) {
+            collectResidualYieldExpressions(element, collected);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    if (value.kind === "yield") {
+        collected.push(value);
+        return;
+    }
+    for (const nested of Object.values(value)) {
+        collectResidualYieldExpressions(nested, collected);
+    }
+};
+const locationKey = (location) => `${location.file}:${location.line}:${location.column}:${location.length}`;
+const addResidualYieldDiagnostics = (ctx, value) => {
+    const residualYields = [];
+    collectResidualYieldExpressions(value, residualYields);
+    if (residualYields.length === 0) {
+        return;
+    }
+    const existingTsn6101Locations = new Set(ctx.diagnostics
+        .filter((d) => d.code === "TSN6101")
+        .map((d) => locationKey(d.location ?? moduleLocation(ctx))));
+    for (const residualYield of residualYields) {
+        const location = residualYield.sourceSpan ?? moduleLocation(ctx);
+        const key = locationKey(location);
+        if (existingTsn6101Locations.has(key)) {
+            continue;
+        }
+        emitUnsupportedYieldDiagnostic(ctx, "an unsupported expression form after yield lowering", location);
+        existingTsn6101Locations.add(key);
+    }
+};
 /**
  * Process statements in non-generator functions (just recurse into nested generators).
  */
@@ -372,9 +1257,11 @@ const processNonGeneratorStatement = (stmt, ctx) => {
                     ...ctx,
                     inGenerator: true,
                 };
+                const loweredBody = flattenStatement(processStatement(stmt.body, generatorCtx));
+                addResidualYieldDiagnostics(generatorCtx, loweredBody);
                 return {
                     ...stmt,
-                    body: flattenStatement(processStatement(stmt.body, generatorCtx)),
+                    body: loweredBody,
                 };
             }
             return {
@@ -451,9 +1338,11 @@ const processClassMember = (member, ctx) => {
                 ...ctx,
                 inGenerator: true,
             };
+            const loweredBody = flattenStatement(processStatement(member.body, generatorCtx));
+            addResidualYieldDiagnostics(generatorCtx, loweredBody);
             return {
                 ...member,
-                body: flattenStatement(processStatement(member.body, generatorCtx)),
+                body: loweredBody,
             };
         }
         return {
@@ -477,6 +1366,7 @@ const processModule = (module) => {
         filePath: module.filePath,
         diagnostics: [],
         inGenerator: false,
+        yieldTempCounter: 0,
     };
     const processedBody = module.body.map((stmt) => {
         if (stmt.kind === "functionDeclaration" && stmt.isGenerator) {
@@ -484,9 +1374,11 @@ const processModule = (module) => {
                 ...ctx,
                 inGenerator: true,
             };
+            const loweredBody = flattenStatement(processStatement(stmt.body, generatorCtx));
+            addResidualYieldDiagnostics(generatorCtx, loweredBody);
             return {
                 ...stmt,
-                body: flattenStatement(processStatement(stmt.body, generatorCtx)),
+                body: loweredBody,
             };
         }
         return processNonGeneratorStatement(stmt, ctx);
@@ -499,11 +1391,13 @@ const processModule = (module) => {
                     ...ctx,
                     inGenerator: true,
                 };
+                const loweredBody = flattenStatement(processStatement(exp.declaration.body, generatorCtx));
+                addResidualYieldDiagnostics(generatorCtx, loweredBody);
                 return {
                     ...exp,
                     declaration: {
                         ...exp.declaration,
-                        body: flattenStatement(processStatement(exp.declaration.body, generatorCtx)),
+                        body: loweredBody,
                     },
                 };
             }