@tsonic/emitter 0.0.74 → 0.0.75

package/dist/statements/control/conditionals/if-emitter.js

@@ -1,791 +1,73 @@
 /**
- * If-statement emitter with union/instanceof/nullable guard narrowing.
- * Returns CSharpStatementAst nodes.
+ * If-statement emitter — main dispatch orchestrator.
+ *
+ * Routes if-statement guards to specialized sub-emitters for union-narrowing
+ * and type-based guards, handles compound AND cases inline, and falls through
+ * to standard condition-narrowing emission.
  */
 import { emitExpressionAst } from "../../../expression-emitter.js";
-import { emitIdentifier } from "../../../expressions/identifiers.js";
-import { emitTypeAst } from "../../../type-emitter.js";
-import { emitStatementAst } from "../../../statement-emitter.js";
-import { escapeCSharpIdentifier } from "../../../emitter-types/index.js";
 import { emitBooleanConditionAst, toBooleanConditionAst, } from "../../../core/semantic/boolean-context.js";
-import { tryResolvePredicateGuard, tryResolveInstanceofGuard, tryResolveInGuard, tryResolveDiscriminantEqualityGuard, tryResolvePropertyTruthinessGuard, tryResolveSimpleNullableGuard, tryResolveNullableGuard, isDefinitelyTerminating, } from "./guard-analysis.js";
-/** Standard emitExpressionAst adapter for emitBooleanConditionAst callback. */
-const emitExprAstCb = (e, ctx) => emitExpressionAst(e, ctx);
-/**
- * Build AST for a union narrowing expression: (escapedOrig.AsN())
- */
-const buildUnionNarrowAst = (escapedOrig, memberN) => ({
-    kind: "parenthesizedExpression",
-    expression: {
-        kind: "invocationExpression",
-        expression: {
-            kind: "memberAccessExpression",
-            expression: { kind: "identifierExpression", identifier: escapedOrig },
-            memberName: `As${memberN}`,
-        },
-        arguments: [],
-    },
-});
-const buildSubsetUnionType = (members) => {
-    if (members.length === 0)
-        return undefined;
-    if (members.length === 1)
-        return members[0];
-    return { kind: "unionType", types: [...members] };
-};
-const buildComplementNarrowedBinding = (escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, selectedMemberN) => {
-    const remainingPairs = candidateMemberNs.flatMap((runtimeMemberN, index) => {
-        if (runtimeMemberN === selectedMemberN) {
-            return [];
-        }
-        const memberType = candidateMembers[index];
-        if (!memberType) {
-            return [];
-        }
-        return [{ runtimeMemberN, memberType }];
-    });
-    if (remainingPairs.length === 0) {
-        return undefined;
-    }
-    if (remainingPairs.length === 1) {
-        const remaining = remainingPairs[0];
-        if (!remaining)
-            return undefined;
-        return {
-            kind: "expr",
-            exprAst: buildUnionNarrowAst(escapedOrig, remaining.runtimeMemberN),
-            type: remaining.memberType,
-        };
-    }
-    return {
-        kind: "runtimeSubset",
-        runtimeMemberNs: remainingPairs.map((pair) => pair.runtimeMemberN),
-        runtimeUnionArity,
-        type: buildSubsetUnionType(remainingPairs.map((pair) => pair.memberType)),
-    };
-};
-const withComplementNarrowing = (originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, selectedMemberN, baseContext) => {
-    const binding = buildComplementNarrowedBinding(escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, selectedMemberN);
-    if (!binding) {
-        return baseContext;
-    }
-    const narrowedBindings = new Map(baseContext.narrowedBindings ?? []);
-    narrowedBindings.set(originalName, binding);
-    return { ...baseContext, narrowedBindings };
-};
-/** Wrap an array of statements in a single statement (block if >1). */
-const wrapInBlock = (stmts) => {
-    if (stmts.length === 1 && stmts[0])
-        return stmts[0];
-    return { kind: "blockStatement", statements: [...stmts] };
-};
-/**
- * Emit a forced block with a preamble line as AST.
- * Builds a blockStatement with preamble statements + body statements.
- *
- * If bodyStmt is already a block, its statements are inlined to avoid nesting.
- */
-const emitForcedBlockWithPreambleAst = (preambleStmts, bodyStmt, bodyCtx) => {
-    const allStatements = [...preambleStmts];
-    const emitBodyStatements = (statements, ctx) => {
-        let currentCtx = ctx;
-        for (const s of statements) {
-            const [stmts, next] = emitStatementAst(s, currentCtx);
-            allStatements.push(...stmts);
-            currentCtx = next;
-        }
-        return currentCtx;
-    };
-    const finalCtx = bodyStmt.kind === "blockStatement"
-        ? emitBodyStatements(bodyStmt.statements, bodyCtx)
-        : (() => {
-            const [stmts, next] = emitStatementAst(bodyStmt, bodyCtx);
-            allStatements.push(...stmts);
-            return next;
-        })();
-    return [{ kind: "blockStatement", statements: allStatements }, finalCtx];
-};
-/**
- * Build a `var name = expr.AsN();` statement as AST.
- */
-const buildCastLocalDecl = (varName, receiverName, memberN) => ({
-    kind: "localDeclarationStatement",
-    modifiers: [],
-    type: { kind: "varType" },
-    declarators: [
-        {
-            name: varName,
-            initializer: {
-                kind: "invocationExpression",
-                expression: {
-                    kind: "memberAccessExpression",
-                    expression: {
-                        kind: "identifierExpression",
-                        identifier: receiverName,
-                    },
-                    memberName: `As${memberN}`,
-                },
-                arguments: [],
-            },
-        },
-    ],
-});
+import { applyConditionBranchNarrowing } from "../../../core/semantic/condition-branch-narrowing.js";
+import { tryResolveInstanceofGuard, isDefinitelyTerminating, } from "./guard-analysis.js";
+// Import from split modules
+import { emitExprAstCb, mergeBranchExitContext, mergeBranchContextMeta, resetBranchFlowState, wrapInBlock, buildIsPatternCondition, emitBranchScopedStatementAst, } from "./branch-context.js";
+import { tryEmitInGuard, tryEmitPropertyTruthinessGuard, tryEmitDiscriminantEqualityGuard, } from "./if-emit-union-guards.js";
+import { tryEmitInstanceofGuard, tryEmitArrayIsArrayGuard, tryEmitNegatedInstanceofGuard, tryEmitNullableGuard, tryEmitTypeofGuard, } from "./if-emit-type-guards.js";
 /**
- * Build the condition expression `orig.IsN()` or `!orig.IsN()`.
- */
-const buildIsNCondition = (escapedOrig, memberN, negate) => {
-    const isCall = {
-        kind: "invocationExpression",
-        expression: {
-            kind: "memberAccessExpression",
-            expression: { kind: "identifierExpression", identifier: escapedOrig },
-            memberName: `Is${memberN}`,
-        },
-        arguments: [],
-    };
-    return negate
-        ? { kind: "prefixUnaryExpression", operatorToken: "!", operand: isCall }
-        : isCall;
-};
-/**
- * Build the condition expression `orig is TypeName varName`.
- */
-const buildIsPatternCondition = (escapedOrig, rhsTypeAst, escapedNarrow) => ({
-    kind: "isExpression",
-    expression: { kind: "identifierExpression", identifier: escapedOrig },
-    pattern: {
-        kind: "declarationPattern",
-        type: rhsTypeAst,
-        designation: escapedNarrow,
-    },
-});
-const tryExtractTypeofEqualityGuard = (condition) => {
-    const extractDirectGuard = (expr) => {
-        if (expr.kind !== "binary")
-            return undefined;
-        if (expr.operator !== "===" &&
-            expr.operator !== "==" &&
-            expr.operator !== "!==" &&
-            expr.operator !== "!=") {
-            return undefined;
-        }
-        const extract = (left, right) => {
-            if (left.kind !== "unary" || left.operator !== "typeof")
-                return undefined;
-            if (left.expression.kind !== "identifier")
-                return undefined;
-            if (right.kind !== "literal" || typeof right.value !== "string") {
-                return undefined;
-            }
-            return left.expression.name;
-        };
-        const originalName = extract(expr.left, expr.right) ?? extract(expr.right, expr.left);
-        if (!originalName)
-            return undefined;
-        return {
-            originalName,
-            narrowsInThen: expr.operator === "===" || expr.operator === "==",
-        };
-    };
-    const direct = extractDirectGuard(condition);
-    if (direct) {
-        return { ...direct, compound: false };
-    }
-    if (condition.kind === "logical" && condition.operator === "&&") {
-        const left = tryExtractTypeofEqualityGuard(condition.left);
-        if (left?.narrowsInThen) {
-            return { ...left, compound: true };
-        }
-        const right = tryExtractTypeofEqualityGuard(condition.right);
-        if (right?.narrowsInThen) {
-            return { ...right, compound: true };
-        }
-    }
-    return undefined;
-};
-const findIdentifierTypeInNode = (node, identifierName) => {
-    const visit = (value) => {
-        if (!value || typeof value !== "object")
-            return undefined;
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                const found = visit(item);
-                if (found)
-                    return found;
-            }
-            return undefined;
-        }
-        const candidate = value;
-        if (candidate.kind === "identifier" &&
-            candidate.name === identifierName &&
-            candidate.inferredType) {
-            return candidate.inferredType;
-        }
-        for (const child of Object.values(value)) {
-            const found = visit(child);
-            if (found)
-                return found;
-        }
-        return undefined;
-    };
-    return visit(node);
-};
-/**
- * Emit an if statement as AST
+ * Emit an if-statement with guard-based union/instanceof/nullable narrowing.
  */
 export const emitIfStatementAst = (stmt, context) => {
-    // Case A: if (isUser(account)) { ... }
-    // Predicate narrowing rewrite → if (account.IsN()) { var account__N_k = account.AsN(); ... }
-    if (stmt.condition.kind === "call") {
-        const guard = tryResolvePredicateGuard(stmt.condition, context);
-        if (guard) {
-            const { originalName, memberN, unionArity, runtimeUnionArity, candidateMemberNs, candidateMembers, ctxWithId, escapedOrig, escapedNarrow, narrowedMap, } = guard;
-            const condAst = buildIsNCondition(escapedOrig, memberN, false);
-            const castStmt = buildCastLocalDecl(escapedNarrow, escapedOrig, memberN);
-            const thenCtx = {
-                ...ctxWithId,
-                narrowedBindings: narrowedMap,
-            };
-            const [thenBlock, thenBodyCtx] = emitForcedBlockWithPreambleAst([castStmt], stmt.thenStatement, thenCtx);
-            let finalContext = {
-                ...thenBodyCtx,
-                narrowedBindings: ctxWithId.narrowedBindings,
-            };
-            let elseStmt;
-            if (stmt.elseStatement) {
-                const elseCtxBase = unionArity === 2
-                    ? withComplementNarrowing(originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, memberN, finalContext)
-                    : finalContext;
-                const [elseStmts, elseCtx] = emitStatementAst(stmt.elseStatement, elseCtxBase);
-                elseStmt = wrapInBlock(elseStmts);
-                finalContext = {
-                    ...elseCtx,
-                    narrowedBindings: ctxWithId.narrowedBindings,
-                };
-                return [
-                    [
-                        {
-                            kind: "ifStatement",
-                            condition: condAst,
-                            thenStatement: thenBlock,
-                            elseStatement: elseStmt,
-                        },
-                    ],
-                    finalContext,
-                ];
-            }
-            if (isDefinitelyTerminating(stmt.thenStatement)) {
-                finalContext = withComplementNarrowing(originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, memberN, finalContext);
-            }
-            const ifStmt = {
-                kind: "ifStatement",
-                condition: condAst,
-                thenStatement: thenBlock,
-                elseStatement: elseStmt,
-            };
-            return [[ifStmt], finalContext];
-        }
-    }
-    // Case A3: if ("error" in auth) { ... }
-    // Union 'in' narrowing rewrite → if (auth.IsN()) { var auth__N_k = auth.AsN(); ... }
-    const inGuard = tryResolveInGuard(stmt.condition, context);
-    if (inGuard) {
-        const { originalName, memberN, unionArity, runtimeUnionArity, candidateMemberNs, candidateMembers, ctxWithId, escapedOrig, escapedNarrow, narrowedMap, } = inGuard;
-        const condAst = buildIsNCondition(escapedOrig, memberN, false);
-        const castStmt = buildCastLocalDecl(escapedNarrow, escapedOrig, memberN);
-        const thenCtx = {
-            ...ctxWithId,
-            narrowedBindings: narrowedMap,
-        };
-        const [thenBlock, thenBodyCtx] = emitForcedBlockWithPreambleAst([castStmt], stmt.thenStatement, thenCtx);
-        let finalContext = thenBodyCtx;
-        let elseStmt;
-        if (stmt.elseStatement) {
-            if (unionArity === 2) {
-                const elseCtx = withComplementNarrowing(originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, memberN, finalContext);
-                const [elseStmts, elseCtxAfter] = emitStatementAst(stmt.elseStatement, elseCtx);
-                elseStmt = wrapInBlock(elseStmts);
-                finalContext = {
-                    ...elseCtxAfter,
-                    narrowedBindings: ctxWithId.narrowedBindings,
-                };
-                return [
-                    [
-                        {
-                            kind: "ifStatement",
-                            condition: condAst,
-                            thenStatement: thenBlock,
-                            elseStatement: elseStmt,
-                        },
-                    ],
-                    finalContext,
-                ];
-            }
-            // Can't narrow ELSE safely, emit without narrowing.
-            const [elseStmts, elseCtx] = emitStatementAst(stmt.elseStatement, {
-                ...finalContext,
-                narrowedBindings: ctxWithId.narrowedBindings,
-            });
-            elseStmt = wrapInBlock(elseStmts);
-            finalContext = {
-                ...elseCtx,
-                narrowedBindings: ctxWithId.narrowedBindings,
-            };
-            return [
-                [
-                    {
-                        kind: "ifStatement",
-                        condition: condAst,
-                        thenStatement: thenBlock,
-                        elseStatement: elseStmt,
-                    },
-                ],
-                finalContext,
-            ];
-        }
-        // Post-if narrowing for early-exit patterns (2-member unions only)
-        if (isDefinitelyTerminating(stmt.thenStatement)) {
-            finalContext = withComplementNarrowing(originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, memberN, finalContext);
-            return [
-                [{ kind: "ifStatement", condition: condAst, thenStatement: thenBlock }],
-                finalContext,
-            ];
-        }
-        finalContext = {
-            ...finalContext,
-            narrowedBindings: ctxWithId.narrowedBindings,
-        };
-        return [
-            [{ kind: "ifStatement", condition: condAst, thenStatement: thenBlock }],
-            finalContext,
-        ];
-    }
-    // Case A3b: if (result.success) { ... } / if (!result.success) { ... }
-    // Truthy/falsy discriminant narrowing over runtime unions.
-    const propertyTruthinessGuard = tryResolvePropertyTruthinessGuard(stmt.condition, context);
-    if (propertyTruthinessGuard) {
-        const { originalName, memberN, unionArity, runtimeUnionArity, candidateMemberNs, candidateMembers, ctxWithId, escapedOrig, escapedNarrow, narrowedMap, } = propertyTruthinessGuard;
-        const condAst = buildIsNCondition(escapedOrig, memberN, false);
-        const castStmt = buildCastLocalDecl(escapedNarrow, escapedOrig, memberN);
-        const thenCtx = {
-            ...ctxWithId,
-            narrowedBindings: narrowedMap,
-        };
-        const [thenBlock, thenBodyCtx] = emitForcedBlockWithPreambleAst([castStmt], stmt.thenStatement, thenCtx);
-        let finalContext = thenBodyCtx;
-        let elseStmt;
-        if (stmt.elseStatement) {
-            if (unionArity === 2) {
-                const elseCtx = withComplementNarrowing(originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, memberN, finalContext);
-                const [elseStmts, elseCtxAfter] = emitStatementAst(stmt.elseStatement, elseCtx);
-                elseStmt = wrapInBlock(elseStmts);
-                finalContext = {
-                    ...elseCtxAfter,
-                    narrowedBindings: ctxWithId.narrowedBindings,
-                };
-                return [
-                    [
-                        {
-                            kind: "ifStatement",
-                            condition: condAst,
-                            thenStatement: thenBlock,
-                            elseStatement: elseStmt,
-                        },
-                    ],
-                    finalContext,
-                ];
-            }
-            const [elseStmts, elseCtx] = emitStatementAst(stmt.elseStatement, {
-                ...finalContext,
-                narrowedBindings: ctxWithId.narrowedBindings,
-            });
-            elseStmt = wrapInBlock(elseStmts);
-            finalContext = {
-                ...elseCtx,
-                narrowedBindings: ctxWithId.narrowedBindings,
-            };
-            return [
-                [
-                    {
-                        kind: "ifStatement",
-                        condition: condAst,
-                        thenStatement: thenBlock,
-                        elseStatement: elseStmt,
-                    },
-                ],
-                finalContext,
-            ];
-        }
-        if (isDefinitelyTerminating(stmt.thenStatement)) {
-            finalContext = withComplementNarrowing(originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, memberN, finalContext);
-            return [
-                [{ kind: "ifStatement", condition: condAst, thenStatement: thenBlock }],
-                finalContext,
-            ];
-        }
-        finalContext = {
-            ...finalContext,
-            narrowedBindings: ctxWithId.narrowedBindings,
-        };
-        return [
-            [{ kind: "ifStatement", condition: condAst, thenStatement: thenBlock }],
-            finalContext,
-        ];
-    }
-    // Case A4: if (shape.kind === "circle") { ... }
-    // Discriminant literal equality narrowing
-    const eqGuard = tryResolveDiscriminantEqualityGuard(stmt.condition, context);
-    if (eqGuard) {
-        const { originalName, operator, memberN, unionArity, runtimeUnionArity, candidateMemberNs, candidateMembers, ctxWithId, escapedOrig, escapedNarrow, narrowedMap, } = eqGuard;
-        const isInequality = operator === "!==" || operator === "!=";
-        const condAst = buildIsNCondition(escapedOrig, memberN, isInequality);
-        let finalContext = ctxWithId;
-        // Equality: narrow THEN to memberN. Inequality: narrow ELSE to memberN.
-        if (!isInequality) {
-            const castStmt = buildCastLocalDecl(escapedNarrow, escapedOrig, memberN);
-            const thenCtx = {
-                ...ctxWithId,
-                narrowedBindings: narrowedMap,
-            };
-            const [thenBlock, thenBodyCtx] = emitForcedBlockWithPreambleAst([castStmt], stmt.thenStatement, thenCtx);
-            finalContext = thenBodyCtx;
-            let elseStmt;
-            if (stmt.elseStatement) {
-                if (unionArity === 2) {
-                    const [elseStmts, elseCtxAfter] = emitStatementAst(stmt.elseStatement, withComplementNarrowing(originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, memberN, finalContext));
-                    elseStmt = wrapInBlock(elseStmts);
-                    finalContext = {
-                        ...elseCtxAfter,
-                        narrowedBindings: ctxWithId.narrowedBindings,
-                    };
-                    return [
-                        [
-                            {
-                                kind: "ifStatement",
-                                condition: condAst,
-                                thenStatement: thenBlock,
-                                elseStatement: elseStmt,
-                            },
-                        ],
-                        finalContext,
-                    ];
-                }
-                const [elseStmts, elseCtx] = emitStatementAst(stmt.elseStatement, {
-                    ...finalContext,
-                    narrowedBindings: ctxWithId.narrowedBindings,
-                });
-                elseStmt = wrapInBlock(elseStmts);
-                finalContext = {
-                    ...elseCtx,
-                    narrowedBindings: ctxWithId.narrowedBindings,
-                };
-                return [
-                    [
-                        {
-                            kind: "ifStatement",
-                            condition: condAst,
-                            thenStatement: thenBlock,
-                            elseStatement: elseStmt,
-                        },
-                    ],
-                    finalContext,
-                ];
-            }
-            // Post-if narrowing for early-exit patterns (2-member unions only)
-            if (isDefinitelyTerminating(stmt.thenStatement)) {
-                finalContext = withComplementNarrowing(originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, memberN, finalContext);
-                return [
-                    [
-                        {
-                            kind: "ifStatement",
-                            condition: condAst,
-                            thenStatement: thenBlock,
-                        },
-                    ],
-                    finalContext,
-                ];
-            }
-            finalContext = {
-                ...finalContext,
-                narrowedBindings: ctxWithId.narrowedBindings,
-            };
-            return [
-                [{ kind: "ifStatement", condition: condAst, thenStatement: thenBlock }],
-                finalContext,
-            ];
-        }
-        // Inequality: THEN is "not memberN", ELSE is memberN
-        {
-            let thenStmt;
-            let thenCtx;
-            if (unionArity === 2) {
-                const [thenStmts, thenCtxAfter] = emitStatementAst(stmt.thenStatement, {
-                    ...withComplementNarrowing(originalName, escapedOrig, runtimeUnionArity, candidateMemberNs, candidateMembers, memberN, ctxWithId),
-                });
-                thenStmt = wrapInBlock(thenStmts);
-                thenCtx = thenCtxAfter;
-            }
-            else {
-                const [thenStmts, thenCtxAfter] = emitStatementAst(stmt.thenStatement, ctxWithId);
-                thenStmt = wrapInBlock(thenStmts);
-                thenCtx = thenCtxAfter;
-            }
-            finalContext = thenCtx;
-            let elseStmt;
-            if (stmt.elseStatement) {
-                const castStmt = buildCastLocalDecl(escapedNarrow, escapedOrig, memberN);
-                const [elseBlock, elseBodyCtx] = emitForcedBlockWithPreambleAst([castStmt], stmt.elseStatement, { ...ctxWithId, narrowedBindings: narrowedMap });
-                elseStmt = elseBlock;
-                finalContext = {
-                    ...elseBodyCtx,
-                    narrowedBindings: ctxWithId.narrowedBindings,
-                };
-                return [
-                    [
-                        {
-                            kind: "ifStatement",
-                            condition: condAst,
-                            thenStatement: thenStmt,
-                            elseStatement: elseStmt,
-                        },
-                    ],
-                    finalContext,
-                ];
-            }
-            // Post-if narrowing for early-exit patterns
-            if (isDefinitelyTerminating(stmt.thenStatement)) {
-                const narrowedBindings = new Map(finalContext.narrowedBindings ?? []);
-                narrowedBindings.set(originalName, {
-                    kind: "expr",
-                    exprAst: buildUnionNarrowAst(escapedOrig, memberN),
-                    type: candidateMembers[candidateMemberNs.findIndex((runtimeMemberN) => runtimeMemberN === memberN)],
-                });
-                finalContext = { ...finalContext, narrowedBindings };
-                return [
-                    [
-                        {
-                            kind: "ifStatement",
-                            condition: condAst,
-                            thenStatement: thenStmt,
-                        },
-                    ],
-                    finalContext,
-                ];
-            }
-            finalContext = {
-                ...finalContext,
-                narrowedBindings: ctxWithId.narrowedBindings,
-            };
-            return [
-                [{ kind: "ifStatement", condition: condAst, thenStatement: thenStmt }],
-                finalContext,
-            ];
-        }
-    }
-    // Case A2: if (x instanceof Foo) { ... }
-    // C# pattern var narrowing → if (x is Foo x__is_k) { ... }
-    const instanceofGuard = tryResolveInstanceofGuard(stmt.condition, context);
-    if (instanceofGuard) {
-        const { ctxAfterRhs, escapedOrig, escapedNarrow, rhsTypeAst, narrowedMap } = instanceofGuard;
-        const condAst = buildIsPatternCondition(escapedOrig, rhsTypeAst, escapedNarrow);
-        const thenCtx = {
-            ...ctxAfterRhs,
-            narrowedBindings: narrowedMap,
-        };
-        const [thenStmts, thenCtxAfter] = emitStatementAst(stmt.thenStatement, thenCtx);
-        let finalContext = {
-            ...thenCtxAfter,
-            narrowedBindings: ctxAfterRhs.narrowedBindings,
-        };
-        let elseStmt;
-        if (stmt.elseStatement) {
-            const [elseStmts, elseCtx] = emitStatementAst(stmt.elseStatement, finalContext);
-            elseStmt = wrapInBlock(elseStmts);
-            finalContext = elseCtx;
-        }
-        return [
-            [
-                {
-                    kind: "ifStatement",
-                    condition: condAst,
-                    thenStatement: wrapInBlock(thenStmts),
-                    elseStatement: elseStmt,
-                },
-            ],
-            finalContext,
-        ];
-    }
-    // Case B: if (!isUser(account)) { ... } else { ... }
-    // Negated guard → for 2-member unions, narrow THEN to OTHER member, ELSE to guard's target
-    if (stmt.condition.kind === "unary" &&
-        stmt.condition.operator === "!" &&
-        stmt.condition.expression.kind === "call" &&
-        stmt.elseStatement) {
-        const innerCall = stmt.condition.expression;
-        const guard = tryResolvePredicateGuard(innerCall, context);
-        if (guard) {
-            const { originalName, memberN, unionArity, candidateMemberNs, candidateMembers, ctxWithId, escapedOrig, escapedNarrow, narrowedMap, } = guard;
-            const condAst = buildIsNCondition(escapedOrig, memberN, true);
-            // THEN branch: for 2-member unions narrow to OTHER member
-            let thenStmt;
-            let thenCtx;
-            if (unionArity === 2) {
-                const otherIndex = candidateMemberNs.findIndex((runtimeMemberN) => runtimeMemberN !== memberN);
-                const otherMemberN = otherIndex >= 0 ? candidateMemberNs[otherIndex] : undefined;
-                const otherMemberType = otherIndex >= 0 ? candidateMembers[otherIndex] : undefined;
-                if (!otherMemberN || !otherMemberType) {
-                    throw new Error("ICE: Failed to resolve complement runtime union member for negated predicate guard.");
-                }
-                const nextId = (ctxWithId.tempVarId ?? 0) + 1;
-                const thenCtxWithId = {
-                    ...ctxWithId,
-                    tempVarId: nextId,
-                };
-                const thenNarrowedName = `${originalName}__${otherMemberN}_${nextId}`;
-                const escapedThenNarrow = escapeCSharpIdentifier(thenNarrowedName);
-                const thenNarrowedMap = new Map(thenCtxWithId.narrowedBindings ?? []);
-                thenNarrowedMap.set(originalName, {
-                    kind: "rename",
-                    name: thenNarrowedName,
-                    type: otherMemberType,
-                });
-                const thenCastStmt = buildCastLocalDecl(escapedThenNarrow, escapedOrig, otherMemberN);
-                const [thenBlock, thenBlockCtx] = emitForcedBlockWithPreambleAst([thenCastStmt], stmt.thenStatement, { ...thenCtxWithId, narrowedBindings: thenNarrowedMap });
-                thenStmt = thenBlock;
-                thenCtx = thenBlockCtx;
-            }
-            else {
-                const [thenStmts, thenCtxAfter] = emitStatementAst(stmt.thenStatement, context);
-                thenStmt = wrapInBlock(thenStmts);
-                thenCtx = thenCtxAfter;
-            }
-            // ELSE branch: narrowing applies (to guard's target type)
-            const elseCastStmt = buildCastLocalDecl(escapedNarrow, escapedOrig, memberN);
-            const [elseBlock, _elseBodyCtx] = emitForcedBlockWithPreambleAst([elseCastStmt], stmt.elseStatement, { ...ctxWithId, narrowedBindings: narrowedMap });
-            return [
-                [
-                    {
-                        kind: "ifStatement",
-                        condition: condAst,
-                        thenStatement: thenStmt,
-                        elseStatement: elseBlock,
-                    },
-                ],
-                thenCtx,
-            ];
-        }
-    }
-    // Case B2: if (!(x instanceof Foo)) { ... } else { ... }
-    // Swap branches so ELSE runs under the narrowed pattern var.
-    if (stmt.condition.kind === "unary" &&
-        stmt.condition.operator === "!" &&
-        stmt.elseStatement) {
-        const inner = stmt.condition.expression;
-        const guard = tryResolveInstanceofGuard(inner, context);
-        if (guard) {
-            const { ctxAfterRhs, escapedOrig, escapedNarrow, rhsTypeAst, narrowedMap, } = guard;
-            const condAst = buildIsPatternCondition(escapedOrig, rhsTypeAst, escapedNarrow);
-            // THEN branch is the original ELSE (narrowed)
-            const thenCtx = {
-                ...ctxAfterRhs,
-                narrowedBindings: narrowedMap,
-            };
-            const [thenStmts, thenCtxAfter] = emitStatementAst(stmt.elseStatement, thenCtx);
-            // ELSE branch is the original THEN (not narrowed)
-            const [elseStmts, elseCtxAfter] = emitStatementAst(stmt.thenStatement, {
-                ...thenCtxAfter,
-                narrowedBindings: ctxAfterRhs.narrowedBindings,
-            });
-            return [
-                [
-                    {
-                        kind: "ifStatement",
-                        condition: condAst,
-                        thenStatement: wrapInBlock(thenStmts),
-                        elseStatement: wrapInBlock(elseStmts),
-                    },
-                ],
-                elseCtxAfter,
-            ];
-        }
-    }
-    // Case C: if (isUser(account) && account.foo) { ... }
-    // Logical AND with predicate guard on left → nested-if lowering
+    // Case A3: In guard ("error" in auth)
+    {
+        const result = tryEmitInGuard(stmt, context);
+        if (result)
+            return result;
+    }
+    // Case A3a: Property truthiness guard (result.success)
+    {
+        const result = tryEmitPropertyTruthinessGuard(stmt, context);
+        if (result)
+            return result;
+    }
+    // Case A3b: Discriminant equality guard (shape.kind === "circle")
+    {
+        const result = tryEmitDiscriminantEqualityGuard(stmt, context);
+        if (result)
+            return result;
+    }
+    // Case A4: Instanceof guard (x instanceof Foo)
+    {
+        const result = tryEmitInstanceofGuard(stmt, context);
+        if (result)
+            return result;
+    }
+    // Case A5: Array.isArray guard
+    {
+        const result = tryEmitArrayIsArrayGuard(stmt, context);
+        if (result)
+            return result;
+    }
+    // Case B2: Negated instanceof guard (!(x instanceof Foo))
+    {
+        const result = tryEmitNegatedInstanceofGuard(stmt, context);
+        if (result)
+            return result;
+    }
+    // Case C: Logical AND with instanceof (x instanceof Foo && x.foo)
     if (stmt.condition.kind === "logical" && stmt.condition.operator === "&&") {
         const left = stmt.condition.left;
         const right = stmt.condition.right;
-        if (left.kind === "call") {
-            const guard = tryResolvePredicateGuard(left, context);
-            if (guard) {
-                const { memberN, ctxWithId, escapedOrig, escapedNarrow, narrowedMap } = guard;
-                const outerCondAst = buildIsNCondition(escapedOrig, memberN, false);
-                const castStmt = buildCastLocalDecl(escapedNarrow, escapedOrig, memberN);
-                // Emit RHS condition under narrowed context
-                const outerThenCtx = {
-                    ...ctxWithId,
-                    narrowedBindings: narrowedMap,
-                };
-                const [rhsAst, rhsCtxAfterEmit] = emitExpressionAst(right, outerThenCtx);
-                const [rhsCondAst, rhsCtxAfterCond] = toBooleanConditionAst(right, rhsAst, rhsCtxAfterEmit);
-                // When RHS true: emit original THEN under narrowed context
-                const [thenStmts, thenCtxAfter] = emitStatementAst(stmt.thenStatement, rhsCtxAfterCond);
-                const clearNarrowing = (ctx) => ({
-                    ...ctx,
-                    narrowedBindings: ctxWithId.narrowedBindings,
-                });
-                // Build inner if
-                let innerElse;
-                let currentCtx = thenCtxAfter;
-                if (stmt.elseStatement) {
-                    const [innerElseStmts, innerElseCtx] = emitStatementAst(stmt.elseStatement, clearNarrowing(currentCtx));
-                    innerElse = wrapInBlock(innerElseStmts);
-                    currentCtx = innerElseCtx;
-                }
-                const innerIf = {
-                    kind: "ifStatement",
-                    condition: rhsCondAst,
-                    thenStatement: wrapInBlock(thenStmts),
-                    elseStatement: innerElse,
-                };
-                // Build outer then block: { cast; innerIf }
-                const outerThenBlock = {
-                    kind: "blockStatement",
-                    statements: [castStmt, innerIf],
-                };
-                // Outer else: emit ELSE as-is (no narrowing)
-                let outerElse;
-                let finalContext = clearNarrowing(currentCtx);
-                if (stmt.elseStatement) {
-                    const [outerElseStmts, outerElseCtx] = emitStatementAst(stmt.elseStatement, finalContext);
-                    outerElse = wrapInBlock(outerElseStmts);
-                    finalContext = outerElseCtx;
-                }
-                return [
-                    [
-                        {
-                            kind: "ifStatement",
-                            condition: outerCondAst,
-                            thenStatement: outerThenBlock,
-                            elseStatement: outerElse,
-                        },
-                    ],
-                    finalContext,
-                ];
-            }
-        }
-        // Case C2: if (x instanceof Foo && x.foo) { ... }
         if (left.kind === "binary" && left.operator === "instanceof") {
             const guard = tryResolveInstanceofGuard(left, context);
             if (guard) {
-                const { ctxAfterRhs, escapedOrig, escapedNarrow, rhsTypeAst, narrowedMap, } = guard;
+                const { ctxAfterRhs, receiverAst, escapedNarrow, rhsTypeAst, narrowedMap, } = guard;
                 const rhsCtx = {
                     ...ctxAfterRhs,
                     narrowedBindings: narrowedMap,
                 };
                 const [rhsAst, rhsCtxAfterEmit] = emitExpressionAst(right, rhsCtx);
                 const [rhsCondAst, rhsCtxAfterCond] = toBooleanConditionAst(right, rhsAst, rhsCtxAfterEmit);
-                // Combined condition: (orig is TypeName narrow && rhsCond)
-                const isPatternAst = buildIsPatternCondition(escapedOrig, rhsTypeAst, escapedNarrow);
+                const isPatternAst = buildIsPatternCondition(receiverAst, rhsTypeAst, escapedNarrow);
                 const combinedCondAst = {
                     kind: "parenthesizedExpression",
                     expression: {
@@ -799,14 +81,14 @@ export const emitIfStatementAst = (stmt, context) => {
                     ...rhsCtxAfterCond,
                     narrowedBindings: narrowedMap,
                 };
-                const [thenStmts, thenCtxAfter] = emitStatementAst(stmt.thenStatement, thenCtx);
+                const [thenStmts, thenCtxAfter] = emitBranchScopedStatementAst(stmt.thenStatement, thenCtx);
                 let finalContext = {
                     ...thenCtxAfter,
                     narrowedBindings: ctxAfterRhs.narrowedBindings,
                 };
                 let elseStmt;
                 if (stmt.elseStatement) {
-                    const [elseStmts, elseCtx] = emitStatementAst(stmt.elseStatement, finalContext);
+                    const [elseStmts, elseCtx] = emitBranchScopedStatementAst(stmt.elseStatement, finalContext);
                     elseStmt = wrapInBlock(elseStmts);
                     finalContext = elseCtx;
                 }
@@ -824,157 +106,58 @@ export const emitIfStatementAst = (stmt, context) => {
             }
         }
     }
-    // Case D: Nullable value type narrowing
-    // if (id !== null) { ... } → id becomes id.Value in then-branch
-    const simpleNullableGuard = tryResolveSimpleNullableGuard(stmt.condition);
-    const nullableGuard = simpleNullableGuard ?? tryResolveNullableGuard(stmt.condition, context);
-    if (nullableGuard && nullableGuard.isValueType) {
-        const { key, targetExpr, narrowsInThen, strippedType } = nullableGuard;
-        // Avoid stacking `.Value` (see detailed comment in original text emitter)
-        const [idAst] = targetExpr.kind === "identifier"
-            ? emitIdentifier(targetExpr, {
-                ...context,
-                narrowedBindings: undefined,
-            })
-            : emitExpressionAst(targetExpr, {
-                ...context,
-                narrowedBindings: undefined,
-            });
-        // Create narrowed binding: id → id.Value
-        const narrowedMap = new Map(context.narrowedBindings ?? []);
-        narrowedMap.set(key, {
-            kind: "expr",
-            exprAst: {
-                kind: "memberAccessExpression",
-                expression: idAst,
-                memberName: "Value",
-            },
-            type: strippedType,
-        });
-        // Soundness: In compound conditions (A && B), we must NOT apply "else" narrowing.
-        const isAndCondition = stmt.condition.kind === "logical" && stmt.condition.operator === "&&";
-        if (isAndCondition && !simpleNullableGuard && !narrowsInThen) {
-            // `id == null` inside `&&` - skip nullable rewrite, fall through to standard.
-        }
-        else {
-            // Emit condition
-            const [condAst, condCtxAfterCond] = emitBooleanConditionAst(stmt.condition, emitExprAstCb, context);
-            // Apply narrowing to appropriate branch
-            const thenCtx = {
-                ...condCtxAfterCond,
-                narrowedBindings: narrowsInThen
-                    ? narrowedMap
-                    : condCtxAfterCond.narrowedBindings,
-            };
-            const [thenStmts, thenCtxAfter] = emitStatementAst(stmt.thenStatement, thenCtx);
-            let finalContext = {
-                ...thenCtxAfter,
-                narrowedBindings: context.narrowedBindings,
-            };
-            let elseStmt;
-            if (stmt.elseStatement) {
-                const elseCtx = {
-                    ...finalContext,
-                    narrowedBindings: !narrowsInThen
-                        ? simpleNullableGuard
-                            ? narrowedMap
-                            : context.narrowedBindings
-                        : context.narrowedBindings,
-                };
-                const [elseStmts, elseCtxAfter] = emitStatementAst(stmt.elseStatement, elseCtx);
-                elseStmt = wrapInBlock(elseStmts);
-                finalContext = {
-                    ...elseCtxAfter,
-                    narrowedBindings: context.narrowedBindings,
-                };
-            }
-            return [
-                [
-                    {
-                        kind: "ifStatement",
-                        condition: condAst,
-                        thenStatement: wrapInBlock(thenStmts),
-                        elseStatement: elseStmt,
-                    },
-                ],
-                finalContext,
-            ];
-        }
+    // Case D: Nullable guard (id !== null)
+    {
+        const result = tryEmitNullableGuard(stmt, context);
+        if (result)
+            return result;
     }
-    // Case E: typeof narrowing on plain locals/parameters
-    // if (typeof value === "number") { ... } / else { ... }
-    const typeofGuard = tryExtractTypeofEqualityGuard(stmt.condition);
-    if (typeofGuard) {
-        const narrowedBranch = typeofGuard.narrowsInThen
-            ? stmt.thenStatement
-            : stmt.elseStatement;
-        const narrowedType = narrowedBranch
-            ? findIdentifierTypeInNode(narrowedBranch, typeofGuard.originalName)
-            : undefined;
-        if (narrowedBranch && narrowedType) {
-            const [condAst, condCtxAfterCond] = emitBooleanConditionAst(stmt.condition, emitExprAstCb, context);
-            const [rawIdAst] = emitIdentifier({ kind: "identifier", name: typeofGuard.originalName }, { ...condCtxAfterCond, narrowedBindings: undefined });
-            const [narrowedTypeAst, narrowedTypeCtx] = emitTypeAst(narrowedType, condCtxAfterCond);
-            const narrowedMap = new Map(condCtxAfterCond.narrowedBindings ?? []);
-            narrowedMap.set(typeofGuard.originalName, {
-                kind: "expr",
-                exprAst: {
-                    kind: "castExpression",
-                    type: narrowedTypeAst,
-                    expression: rawIdAst,
-                },
-                type: narrowedType,
-            });
-            const thenCtx = {
-                ...narrowedTypeCtx,
-                narrowedBindings: typeofGuard.narrowsInThen
-                    ? narrowedMap
-                    : condCtxAfterCond.narrowedBindings,
-            };
-            const [thenStmts, thenCtxAfter] = emitStatementAst(stmt.thenStatement, thenCtx);
-            let finalContext = {
-                ...thenCtxAfter,
-                narrowedBindings: condCtxAfterCond.narrowedBindings,
-            };
-            let elseStmt;
-            if (stmt.elseStatement) {
-                const elseCtx = {
-                    ...finalContext,
-                    narrowedBindings: typeofGuard.compound
-                        ? condCtxAfterCond.narrowedBindings
-                        : typeofGuard.narrowsInThen
-                            ? condCtxAfterCond.narrowedBindings
-                            : narrowedMap,
-                };
-                const [elseStmts, elseCtxAfter] = emitStatementAst(stmt.elseStatement, elseCtx);
-                elseStmt = wrapInBlock(elseStmts);
-                finalContext = {
-                    ...elseCtxAfter,
-                    narrowedBindings: condCtxAfterCond.narrowedBindings,
-                };
-            }
-            return [
-                [
-                    {
-                        kind: "ifStatement",
-                        condition: condAst,
-                        thenStatement: wrapInBlock(thenStmts),
-                        elseStatement: elseStmt,
-                    },
-                ],
-                finalContext,
-            ];
-        }
+    // Case E: Typeof guard (typeof x === "string")
+    {
+        const result = tryEmitTypeofGuard(stmt, context);
+        if (result)
+            return result;
     }
-    // Standard if-statement emission (no narrowing)
+    // Standard if-statement emission (no guard narrowing)
     const [condAst, condCtxAfterCond] = emitBooleanConditionAst(stmt.condition, emitExprAstCb, context);
-    const [thenStmts, thenContext] = emitStatementAst(stmt.thenStatement, condCtxAfterCond);
-    let finalContext = thenContext;
+    const semanticCondContext = {
+        ...condCtxAfterCond,
+        narrowedBindings: context.narrowedBindings,
+    };
+    const thenCtx = applyConditionBranchNarrowing(stmt.condition, "truthy", semanticCondContext, emitExprAstCb);
+    const [thenStmts, thenContext] = emitBranchScopedStatementAst(stmt.thenStatement, thenCtx);
+    const thenTerminates = isDefinitelyTerminating(stmt.thenStatement);
+    const basePostConditionContext = resetBranchFlowState(semanticCondContext, thenContext);
+    const falsyPostConditionContext = applyConditionBranchNarrowing(stmt.condition, "falsy", {
+        ...basePostConditionContext,
+        narrowedBindings: semanticCondContext.narrowedBindings,
+    }, emitExprAstCb) ?? {
+        ...basePostConditionContext,
+        narrowedBindings: semanticCondContext.narrowedBindings,
+    };
+    let finalContext = thenTerminates
+        ? falsyPostConditionContext
+        : mergeBranchExitContext(semanticCondContext, thenContext, falsyPostConditionContext);
     let elseStmt;
     if (stmt.elseStatement) {
-        const [elseStmts, elseContext] = emitStatementAst(stmt.elseStatement, finalContext);
+        const elseEntryContext = applyConditionBranchNarrowing(stmt.condition, "falsy", {
+            ...semanticCondContext,
+            tempVarId: basePostConditionContext.tempVarId,
+            usings: basePostConditionContext.usings,
+            usedLocalNames: basePostConditionContext.usedLocalNames,
+        }, emitExprAstCb);
+        const [elseStmts, elseContext] = emitBranchScopedStatementAst(stmt.elseStatement, elseEntryContext);
         elseStmt = wrapInBlock(elseStmts);
-        finalContext = elseContext;
+        const elseTerminates = isDefinitelyTerminating(stmt.elseStatement);
+        if (thenTerminates && !elseTerminates) {
+            finalContext = mergeBranchContextMeta(elseContext, thenContext);
+        }
+        else if (!thenTerminates && elseTerminates) {
+            finalContext = mergeBranchContextMeta(thenContext, elseContext);
+        }
+        else {
+            finalContext = mergeBranchExitContext(semanticCondContext, thenContext, elseContext);
+        }
     }
     return [
         [