@tsonic/emitter 0.0.73 → 0.0.75

package/dist/core/semantic/assignment-flow.js

@@ -0,0 +1,161 @@
+import { resolveEffectiveExpressionType } from "./narrowed-expression-types.js";
+import { getMemberAccessNarrowKey } from "./narrowing-keys.js";
+import { materializeDirectNarrowingAst } from "./materialized-narrowing.js";
+import { unwrapParameterModifierType } from "./parameter-modifier-types.js";
+import { unwrapTransparentExpression } from "./transparent-expressions.js";
+import { resolveTypeAlias, stripNullish } from "./type-resolution.js";
+import { getPropertyType } from "./property-lookup-resolution.js";
+import { isAssignable } from "./index.js";
+import { findExactRuntimeUnionMemberIndices, getCanonicalRuntimeUnionMembers, } from "./runtime-unions.js";
+const isConcreteStorageType = (type, context) => {
+    if (!type) {
+        return false;
+    }
+    const resolved = resolveTypeAlias(stripNullish(type), context);
+    switch (resolved.kind) {
+        case "unknownType":
+        case "anyType":
+        case "objectType":
+        case "unionType":
+        case "intersectionType":
+        case "functionType":
+        case "typeParameterType":
+            return false;
+        case "referenceType":
+            return resolved.name !== "object";
+        default:
+            return true;
+    }
+};
+const shouldPreserveConcreteStorageSurface = (sourceAst, materializedAst, currentType, context) => isConcreteStorageType(currentType, context) &&
+    materializedAst.kind === "castExpression" &&
+    materializedAst.expression === sourceAst;
+const withoutNarrowedBinding = (context, bindingKey) => {
+    if (!context.narrowedBindings?.has(bindingKey)) {
+        return context;
+    }
+    const narrowedBindings = new Map(context.narrowedBindings);
+    narrowedBindings.delete(bindingKey);
+    return {
+        ...context,
+        narrowedBindings,
+    };
+};
+const tryResolveAssignmentBindingTarget = (expr) => {
+    const target = unwrapTransparentExpression(expr);
+    if (target.kind === "identifier") {
+        return {
+            bindingKey: target.name,
+            targetExpr: target,
+        };
+    }
+    if (target.kind === "memberAccess" &&
+        !target.isComputed &&
+        !target.isOptional) {
+        const bindingKey = getMemberAccessNarrowKey(target);
+        if (!bindingKey) {
+            return undefined;
+        }
+        return {
+            bindingKey,
+            targetExpr: target,
+        };
+    }
+    return undefined;
+};
+const canonicalizeAssignedTypeAgainstWritableStorage = (assignedType, writableStorageType, context) => {
+    if (!assignedType || !writableStorageType) {
+        return assignedType;
+    }
+    const canonicalRuntimeMembers = getCanonicalRuntimeUnionMembers(writableStorageType, context);
+    if (!canonicalRuntimeMembers) {
+        return assignedType;
+    }
+    const exactMatches = findExactRuntimeUnionMemberIndices(canonicalRuntimeMembers, assignedType, context);
+    if (exactMatches.length !== 1) {
+        return assignedType;
+    }
+    const [exactMatchIndex] = exactMatches;
+    return exactMatchIndex !== undefined
+        ? (canonicalRuntimeMembers[exactMatchIndex] ?? assignedType)
+        : assignedType;
+};
+export const resolveWritableTargetStorageType = (targetExpr, context) => {
+    if (targetExpr.kind === "identifier") {
+        const declaredStorageType = context.localValueTypes?.get(targetExpr.name) ??
+            context.localSemanticTypes?.get(targetExpr.name) ??
+            targetExpr.inferredType;
+        if (declaredStorageType) {
+            return declaredStorageType;
+        }
+        return targetExpr.inferredType;
+    }
+    if (!targetExpr.isComputed && !targetExpr.isOptional) {
+        const receiverType = resolveEffectiveExpressionType(targetExpr.object, context) ??
+            targetExpr.object.inferredType;
+        const exactPropertyType = typeof targetExpr.property === "string"
+            ? getPropertyType(receiverType, targetExpr.property, context)
+            : undefined;
+        if (exactPropertyType) {
+            return exactPropertyType;
+        }
+    }
+    return targetExpr.inferredType;
+};
+export const applyAssignmentStatementNarrowing = (expr, context, emitExprAst) => {
+    if (expr.kind !== "assignment" || expr.operator !== "=") {
+        return context;
+    }
+    if (expr.left.kind === "identifierPattern" ||
+        expr.left.kind === "arrayPattern" ||
+        expr.left.kind === "objectPattern") {
+        return context;
+    }
+    const bindingTarget = tryResolveAssignmentBindingTarget(expr.left);
+    if (!bindingTarget) {
+        return context;
+    }
+    const assignedType = resolveEffectiveExpressionType(expr.right, context) ??
+        expr.right.inferredType;
+    if (!assignedType) {
+        return context;
+    }
+    const currentType = resolveEffectiveExpressionType(bindingTarget.targetExpr, context) ??
+        bindingTarget.targetExpr.inferredType;
+    const storageType = resolveWritableTargetStorageType(bindingTarget.targetExpr, context) ??
+        currentType;
+    const canonicalAssignedType = canonicalizeAssignedTypeAgainstWritableStorage(assignedType, storageType, context);
+    const comparableAssignedType = unwrapParameterModifierType(canonicalAssignedType) ?? canonicalAssignedType;
+    const comparableReadableType = unwrapParameterModifierType(currentType) ?? currentType;
+    const comparableStorageType = unwrapParameterModifierType(storageType) ?? storageType;
+    const [targetExprAst, targetContext] = emitExprAst(bindingTarget.targetExpr, withoutNarrowedBinding(context, bindingTarget.bindingKey));
+    const [materializedExprAst, materializedContext] = materializeDirectNarrowingAst(targetExprAst, comparableStorageType, comparableAssignedType, targetContext);
+    const preserveConcreteStorageSurface = shouldPreserveConcreteStorageSurface(targetExprAst, materializedExprAst, comparableStorageType, materializedContext);
+    const preserveReadableMemberSurface = bindingTarget.targetExpr.kind === "memberAccess" &&
+        isConcreteStorageType(comparableReadableType, materializedContext) &&
+        !isAssignable(comparableAssignedType, comparableReadableType);
+    const narrowedBindings = new Map(materializedContext.narrowedBindings ?? []);
+    const preservedReadableType = preserveReadableMemberSurface
+        ? comparableReadableType
+        : undefined;
+    const nextBinding = {
+        kind: "expr",
+        exprAst: preserveConcreteStorageSurface || preserveReadableMemberSurface
+            ? targetExprAst
+            : materializedExprAst,
+        storageExprAst: targetExprAst,
+        storageType: comparableStorageType,
+        type: preserveConcreteStorageSurface
+            ? comparableStorageType
+            : (preservedReadableType ?? comparableAssignedType),
+        sourceType: preserveConcreteStorageSurface
+            ? comparableStorageType
+            : (preservedReadableType ?? comparableStorageType),
+    };
+    narrowedBindings.set(bindingTarget.bindingKey, nextBinding);
+    return {
+        ...materializedContext,
+        narrowedBindings,
+    };
+};
+//# sourceMappingURL=assignment-flow.js.map

package/dist/core/semantic/assignment-flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignment-flow.js","sourceRoot":"","sources":["../../../src/core/semantic/assignment-flow.ts"],"names":[],"mappings":"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"}

package/dist/core/semantic/async-wrapper-types.d.ts

@@ -0,0 +1,6 @@
+import { type IrExpression, type IrType } from "@tsonic/frontend";
+export declare const isAsyncWrapperType: (type: IrType | undefined) => boolean;
+export declare const getExpressionAsyncWrapperType: (expr: IrExpression) => IrType | undefined;
+export declare const expressionProducesAsyncWrapper: (expr: IrExpression) => boolean;
+export declare const getAsyncWrapperResultType: (expr: IrExpression) => IrType | undefined;
+//# sourceMappingURL=async-wrapper-types.d.ts.map

package/dist/core/semantic/async-wrapper-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-wrapper-types.d.ts","sourceRoot":"","sources":["../../../src/core/semantic/async-wrapper-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,MAAM,EACZ,MAAM,kBAAkB,CAAC;AAiC1B,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,GAAG,SAAS,KAAG,OAC9B,CAAC;AAEjC,eAAO,MAAM,6BAA6B,GACxC,MAAM,YAAY,KACjB,MAAM,GAAG,SAiBX,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAI,MAAM,YAAY,KAAG,OACjB,CAAC;AAEpD,eAAO,MAAM,yBAAyB,GACpC,MAAM,YAAY,KACjB,MAAM,GAAG,SA+BX,CAAC"}

package/dist/core/semantic/async-wrapper-types.js

@@ -0,0 +1,65 @@
+import { getAwaitedIrType, isAwaitableIrType, } from "@tsonic/frontend";
+const typeContainsAsyncWrapper = (type, visited = new Set()) => {
+    if (!type || visited.has(type)) {
+        return false;
+    }
+    visited.add(type);
+    if (type.kind === "referenceType") {
+        return isAwaitableIrType(type);
+    }
+    if (type.kind === "unionType" || type.kind === "intersectionType") {
+        return type.types.some((member) => typeContainsAsyncWrapper(member, visited));
+    }
+    return false;
+};
+const getCallReturnType = (expr) => {
+    if (expr.kind !== "call" && expr.kind !== "new") {
+        return undefined;
+    }
+    const calleeType = expr.callee.inferredType;
+    return calleeType?.kind === "functionType" ? calleeType.returnType : undefined;
+};
+export const isAsyncWrapperType = (type) => typeContainsAsyncWrapper(type);
+export const getExpressionAsyncWrapperType = (expr) => {
+    if (typeContainsAsyncWrapper(expr.inferredType)) {
+        return expr.inferredType;
+    }
+    if (expr.kind === "call" || expr.kind === "new") {
+        if (typeContainsAsyncWrapper(expr.sourceBackedReturnType)) {
+            return expr.sourceBackedReturnType;
+        }
+        const calleeReturnType = getCallReturnType(expr);
+        if (typeContainsAsyncWrapper(calleeReturnType)) {
+            return calleeReturnType;
+        }
+    }
+    return undefined;
+};
+export const expressionProducesAsyncWrapper = (expr) => getExpressionAsyncWrapperType(expr) !== undefined;
+export const getAsyncWrapperResultType = (expr) => {
+    const wrapperType = getExpressionAsyncWrapperType(expr);
+    if (wrapperType?.kind === "referenceType") {
+        const awaitedType = getAwaitedIrType(wrapperType);
+        if (awaitedType) {
+            return awaitedType;
+        }
+    }
+    const sourceBackedAwaited = (expr.kind === "call" || expr.kind === "new") && expr.sourceBackedReturnType
+        ? getAwaitedIrType(expr.sourceBackedReturnType)
+        : undefined;
+    if (sourceBackedAwaited) {
+        return sourceBackedAwaited;
+    }
+    const calleeReturnType = getCallReturnType(expr);
+    const calleeAwaited = calleeReturnType?.kind === "referenceType"
+        ? getAwaitedIrType(calleeReturnType)
+        : undefined;
+    if (calleeAwaited) {
+        return calleeAwaited;
+    }
+    const inferredAwaited = expr.inferredType?.kind === "referenceType"
+        ? getAwaitedIrType(expr.inferredType)
+        : undefined;
+    return inferredAwaited ?? expr.inferredType;
+};
+//# sourceMappingURL=async-wrapper-types.js.map

package/dist/core/semantic/async-wrapper-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-wrapper-types.js","sourceRoot":"","sources":["../../../src/core/semantic/async-wrapper-types.ts"],"names":[],"mappings":"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"}

package/dist/core/semantic/boolean-condition-emission.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Boolean-condition emission — facade re-exports.
+ *
+ * Implementations live in:
+ *   - boolean-condition-main.ts
+ *   - boolean-condition-union.ts
+ */
+export { type EmitExprAstFn, toBooleanConditionAst, emitBooleanConditionAst, } from "./boolean-condition-main.js";
+//# sourceMappingURL=boolean-condition-emission.d.ts.map

package/dist/core/semantic/boolean-condition-emission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-condition-emission.d.ts","sourceRoot":"","sources":["../../../src/core/semantic/boolean-condition-emission.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,aAAa,EAClB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,6BAA6B,CAAC"}

package/dist/core/semantic/boolean-condition-emission.js

@@ -0,0 +1,9 @@
+/**
+ * Boolean-condition emission — facade re-exports.
+ *
+ * Implementations live in:
+ *   - boolean-condition-main.ts
+ *   - boolean-condition-union.ts
+ */
+export { toBooleanConditionAst, emitBooleanConditionAst, } from "./boolean-condition-main.js";
+//# sourceMappingURL=boolean-condition-emission.js.map

package/dist/core/semantic/boolean-condition-emission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-condition-emission.js","sourceRoot":"","sources":["../../../src/core/semantic/boolean-condition-emission.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAEL,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,6BAA6B,CAAC"}

package/dist/core/semantic/boolean-condition-main.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Main boolean-condition lowering (toBooleanConditionAst, emitBooleanConditionAst)
+ *
+ * In TypeScript, any value can be used in a boolean context (truthy/falsy).
+ * In C#, only boolean expressions are valid conditions (if/while/for/?:/!).
+ *
+ * This module provides the main boolean-condition lowering functions
+ * that dispatch to appropriate truthiness checks based on type.
+ *
+ * IMPORTANT:
+ * - This operates on IR + emitted AST; it must not import emitExpressionAst to avoid cycles.
+ * - Callers provide an emit function.
+ */
+import type { IrExpression } from "@tsonic/frontend";
+import type { EmitterContext } from "../../types.js";
+import type { CSharpExpressionAst } from "../format/backend-ast/types.js";
+export type EmitExprAstFn = (expr: IrExpression, context: EmitterContext) => [CSharpExpressionAst, EmitterContext];
+/**
+ * Convert an expression to a valid C# boolean condition, returning a typed AST node.
+ *
+ * Rules (deterministic):
+ * - Booleans: use as-is
+ * - Reference types (objects, arrays, dictionaries, unions, ...): runtime truthiness
+ * - Strings: `!string.IsNullOrEmpty(expr)`
+ * - Numbers: JS truthiness check: false iff 0 or NaN
+ * - int: `expr != 0`
+ * - char: `expr != '\0'`
+ * - null/undefined literals: `false`
+ */
+export declare const toBooleanConditionAst: (expr: IrExpression, emittedAst: CSharpExpressionAst, context: EmitterContext) => [CSharpExpressionAst, EmitterContext];
+/**
+ * Emit a boolean-context expression as a typed AST node.
+ *
+ * Special-cases logical &&/|| into proper binaryExpression AST nodes
+ * with printer-handled parenthesization.
+ */
+export declare const emitBooleanConditionAst: (expr: IrExpression, emitExprAst: EmitExprAstFn, context: EmitterContext) => [CSharpExpressionAst, EmitterContext];
+//# sourceMappingURL=boolean-condition-main.d.ts.map

package/dist/core/semantic/boolean-condition-main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-condition-main.d.ts","sourceRoot":"","sources":["../../../src/core/semantic/boolean-condition-main.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAQrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAgB1E,MAAM,MAAM,aAAa,GAAG,CAC1B,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,cAAc,KACpB,CAAC,mBAAmB,EAAE,cAAc,CAAC,CAAC;AAM3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,GAChC,MAAM,YAAY,EAClB,YAAY,mBAAmB,EAC/B,SAAS,cAAc,KACtB,CAAC,mBAAmB,EAAE,cAAc,CAoLtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAClC,MAAM,YAAY,EAClB,aAAa,aAAa,EAC1B,SAAS,cAAc,KACtB,CAAC,mBAAmB,EAAE,cAAc,CA0DtC,CAAC"}

package/dist/core/semantic/boolean-condition-main.js

@@ -0,0 +1,235 @@
+/**
+ * Main boolean-condition lowering (toBooleanConditionAst, emitBooleanConditionAst)
+ *
+ * In TypeScript, any value can be used in a boolean context (truthy/falsy).
+ * In C#, only boolean expressions are valid conditions (if/while/for/?:/!).
+ *
+ * This module provides the main boolean-condition lowering functions
+ * that dispatch to appropriate truthiness checks based on type.
+ *
+ * IMPORTANT:
+ * - This operates on IR + emitted AST; it must not import emitExpressionAst to avoid cycles.
+ * - Callers provide an emit function.
+ */
+import { allocateLocalName } from "../format/local-names.js";
+import { resolveEffectiveExpressionType } from "./narrowed-expression-types.js";
+import { booleanLiteral, charLiteral, decimalIntegerLiteral, } from "../format/backend-ast/builders.js";
+import { coerceClrPrimitiveToPrimitiveType, emitRuntimeTruthinessConditionAst, isBooleanType, identifierExpr, isInherentlyBooleanExpression, predefinedType, resolveLocalTypeAlias, typeReferenceExpr, wrapForIs, } from "./truthiness-evaluation.js";
+import { applyLogicalOperandNarrowing } from "./condition-branch-narrowing.js";
+import { emitUnionTruthinessConditionAst } from "./boolean-condition-union.js";
+import { emitTypeAst } from "../../type-emitter.js";
+// ============================================================
+// Main boolean-condition lowering (AST-native)
+// ============================================================
+/**
+ * Convert an expression to a valid C# boolean condition, returning a typed AST node.
+ *
+ * Rules (deterministic):
+ * - Booleans: use as-is
+ * - Reference types (objects, arrays, dictionaries, unions, ...): runtime truthiness
+ * - Strings: `!string.IsNullOrEmpty(expr)`
+ * - Numbers: JS truthiness check: false iff 0 or NaN
+ * - int: `expr != 0`
+ * - char: `expr != '\0'`
+ * - null/undefined literals: `false`
+ */
+export const toBooleanConditionAst = (expr, emittedAst, context) => {
+    const inferredType = resolveEffectiveExpressionType(expr, context);
+    const resolved = inferredType
+        ? resolveLocalTypeAlias(coerceClrPrimitiveToPrimitiveType(inferredType) ?? inferredType, context)
+        : undefined;
+    const type = resolved;
+    // Literal truthiness can be fully resolved without re-evaluating anything.
+    if (expr.kind === "literal") {
+        if (expr.value === null || expr.value === undefined) {
+            return [booleanLiteral(false), context];
+        }
+        if (typeof expr.value === "boolean") {
+            return [booleanLiteral(expr.value), context];
+        }
+        if (typeof expr.value === "number") {
+            return [booleanLiteral(expr.value !== 0), context];
+        }
+        if (typeof expr.value === "string") {
+            return [booleanLiteral(expr.value.length !== 0), context];
+        }
+    }
+    // If already boolean, use as-is
+    if (isBooleanType(type)) {
+        return [emittedAst, context];
+    }
+    // If we can prove from syntax alone that this is a boolean expression, use as-is.
+    if (isInherentlyBooleanExpression(expr)) {
+        return [emittedAst, context];
+    }
+    // Unknown/any/missing type: use a safe runtime truthiness check instead of `!= null`,
+    // which can silently miscompile boxed value types (e.g., bool).
+    if (!type || type.kind === "unknownType" || type.kind === "anyType") {
+        return emitRuntimeTruthinessConditionAst(emittedAst, context);
+    }
+    if (type.kind === "unionType") {
+        return emitUnionTruthinessConditionAst(expr, emittedAst, type, context, toBooleanConditionAst, emitTypeAst);
+    }
+    // Non-primitive types in TS can still map to CLR value types (e.g. `long`, `System.Boolean` wrappers).
+    // Never emit `x != null` here: it can silently miscompile boxed value types (always true).
+    // Use canonical runtime truthiness instead.
+    if (type.kind !== "primitiveType") {
+        return emitRuntimeTruthinessConditionAst(emittedAst, context);
+    }
+    // For primitives that are not boolean
+    if (type.kind === "primitiveType") {
+        switch (type.name) {
+            case "null":
+            case "undefined":
+                return [booleanLiteral(false), context];
+            case "string":
+                // !string.IsNullOrEmpty(expr)
+                return [
+                    {
+                        kind: "parenthesizedExpression",
+                        expression: {
+                            kind: "prefixUnaryExpression",
+                            operatorToken: "!",
+                            operand: {
+                                kind: "invocationExpression",
+                                expression: {
+                                    kind: "memberAccessExpression",
+                                    expression: typeReferenceExpr(predefinedType("string")),
+                                    memberName: "IsNullOrEmpty",
+                                },
+                                arguments: [emittedAst],
+                            },
+                        },
+                    },
+                    context,
+                ];
+            case "int":
+                // expr != 0
+                return [
+                    {
+                        kind: "parenthesizedExpression",
+                        expression: {
+                            kind: "binaryExpression",
+                            operatorToken: "!=",
+                            left: emittedAst,
+                            right: decimalIntegerLiteral(0),
+                        },
+                    },
+                    context,
+                ];
+            case "char":
+                // expr != '\0'
+                return [
+                    {
+                        kind: "parenthesizedExpression",
+                        expression: {
+                            kind: "binaryExpression",
+                            operatorToken: "!=",
+                            left: emittedAst,
+                            right: charLiteral("\0"),
+                        },
+                    },
+                    context,
+                ];
+            case "number": {
+                // JS truthiness for numbers: falsy iff 0 or NaN.
+                // Use a pattern var to avoid evaluating the expression twice.
+                // Build: (operand is double __tmp && __tmp != 0 && !double.IsNaN(__tmp))
+                const nextId = (context.tempVarId ?? 0) + 1;
+                const ctxWithId = { ...context, tempVarId: nextId };
+                const numAlloc = allocateLocalName(`__tsonic_truthy_num_${nextId}`, ctxWithId);
+                const tmp = numAlloc.emittedName;
+                return [
+                    {
+                        kind: "parenthesizedExpression",
+                        expression: {
+                            kind: "binaryExpression",
+                            operatorToken: "&&",
+                            left: {
+                                kind: "isExpression",
+                                expression: wrapForIs(emittedAst),
+                                pattern: {
+                                    kind: "declarationPattern",
+                                    type: { kind: "predefinedType", keyword: "double" },
+                                    designation: tmp,
+                                },
+                            },
+                            right: {
+                                kind: "binaryExpression",
+                                operatorToken: "&&",
+                                left: {
+                                    kind: "binaryExpression",
+                                    operatorToken: "!=",
+                                    left: identifierExpr(tmp),
+                                    right: decimalIntegerLiteral(0),
+                                },
+                                right: {
+                                    kind: "prefixUnaryExpression",
+                                    operatorToken: "!",
+                                    operand: {
+                                        kind: "invocationExpression",
+                                        expression: {
+                                            kind: "memberAccessExpression",
+                                            expression: typeReferenceExpr(predefinedType("double")),
+                                            memberName: "IsNaN",
+                                        },
+                                        arguments: [identifierExpr(tmp)],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    numAlloc.context,
+                ];
+            }
+            case "boolean":
+                return [emittedAst, context];
+        }
+    }
+    return [emittedAst, context];
+};
+/**
+ * Emit a boolean-context expression as a typed AST node.
+ *
+ * Special-cases logical &&/|| into proper binaryExpression AST nodes
+ * with printer-handled parenthesization.
+ */
+export const emitBooleanConditionAst = (expr, emitExprAst, context) => {
+    if (expr.kind === "logical" &&
+        (expr.operator === "&&" || expr.operator === "||")) {
+        const [leftAst, leftCtx] = emitBooleanConditionAst(expr.left, emitExprAst, context);
+        const rightBaseContext = applyLogicalOperandNarrowing(expr.left, expr.operator, leftCtx, emitExprAst);
+        const [rightAst, rightCtx] = emitBooleanConditionAst(expr.right, emitExprAst, rightBaseContext);
+        const finalContext = {
+            ...rightCtx,
+            localNameMap: context.localNameMap,
+            conditionAliases: context.conditionAliases,
+            localSemanticTypes: context.localSemanticTypes,
+            localValueTypes: context.localValueTypes,
+            tempVarId: Math.max(context.tempVarId ?? 0, leftCtx.tempVarId ?? 0, rightCtx.tempVarId ?? 0),
+            usings: new Set([
+                ...(context.usings ?? []),
+                ...(leftCtx.usings ?? []),
+                ...(rightCtx.usings ?? []),
+            ]),
+            usedLocalNames: new Set([
+                ...(context.usedLocalNames ?? []),
+                ...(leftCtx.usedLocalNames ?? []),
+                ...(rightCtx.usedLocalNames ?? []),
+            ]),
+            narrowedBindings: leftCtx.narrowedBindings,
+        };
+        return [
+            {
+                kind: "binaryExpression",
+                operatorToken: expr.operator,
+                left: leftAst,
+                right: rightAst,
+            },
+            finalContext,
+        ];
+    }
+    const [exprAst, exprCtx] = emitExprAst(expr, context);
+    return toBooleanConditionAst(expr, exprAst, exprCtx);
+};
+//# sourceMappingURL=boolean-condition-main.js.map

package/dist/core/semantic/boolean-condition-main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-condition-main.js","sourceRoot":"","sources":["../../../src/core/semantic/boolean-condition-main.ts"],"names":[],"mappings":"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"}

package/dist/core/semantic/boolean-condition-union.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Union truthiness emission for boolean conditions (AST-native).
+ *
+ * Handles the per-variant truthiness logic for union types:
+ * - (T | null | undefined) nullable unions
+ * - literal unions (e.g., "a" | "b")
+ * - 2+ member compiler-owned runtime union carriers
+ * - fallback for broad/object-like unions emitted as object
+ */
+import type { IrExpression, IrType } from "@tsonic/frontend";
+import type { EmitterContext } from "../../types.js";
+import { type EmitTypeAstLike } from "./runtime-unions.js";
+import type { CSharpExpressionAst } from "../format/backend-ast/types.js";
+import type { toBooleanConditionAst } from "./boolean-condition-main.js";
+type ToBooleanConditionAstFn = typeof toBooleanConditionAst;
+export declare const emitUnionTruthinessConditionAst: (expr: IrExpression, emittedAst: CSharpExpressionAst, unionType: Extract<IrType, {
+    kind: "unionType";
+}>, context: EmitterContext, toBooleanConditionAstFn: ToBooleanConditionAstFn, emitTypeAst: EmitTypeAstLike) => [CSharpExpressionAst, EmitterContext];
+export {};
+//# sourceMappingURL=boolean-condition-union.d.ts.map

package/dist/core/semantic/boolean-condition-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-condition-union.d.ts","sourceRoot":"","sources":["../../../src/core/semantic/boolean-condition-union.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAMrD,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAO1E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEzE,KAAK,uBAAuB,GAAG,OAAO,qBAAqB,CAAC;AAM5D,eAAO,MAAM,+BAA+B,GAC1C,MAAM,YAAY,EAClB,YAAY,mBAAmB,EAC/B,WAAW,OAAO,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,EACjD,SAAS,cAAc,EACvB,yBAAyB,uBAAuB,EAChD,aAAa,eAAe,KAC3B,CAAC,mBAAmB,EAAE,cAAc,CA2QtC,CAAC"}