@tsonic/emitter 0.0.62 → 0.0.64

package/dist/core/semantic/boolean-context.js

@@ -0,0 +1,717 @@
+/**
+ * Boolean-context emission (truthiness / ToBoolean)
+ *
+ * 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 a shared, deterministic lowering for boolean contexts.
+ * All functions return typed CSharpExpressionAst nodes — no text bridging.
+ *
+ * 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 { substituteTypeArgs } from "./type-resolution.js";
+const stripGlobalPrefix = (name) => name.startsWith("global::") ? name.slice("global::".length) : name;
+/**
+ * Coerce CLR primitive reference types (System.Boolean, System.Int32, ...) to IR primitiveType.
+ *
+ * This prevents boolean-context lowering from emitting `x != null` for CLR value types,
+ * which is both semantically wrong and can silently miscompile (it compiles with boxing).
+ */
+const coerceClrPrimitiveToPrimitiveType = (type) => {
+    if (type.kind !== "referenceType")
+        return undefined;
+    const resolved = type.resolvedClrType ?? type.typeId?.clrName;
+    if (!resolved)
+        return undefined;
+    const clr = stripGlobalPrefix(resolved);
+    switch (clr) {
+        case "System.Boolean":
+        case "bool":
+            return { kind: "primitiveType", name: "boolean" };
+        case "System.String":
+        case "string":
+            return { kind: "primitiveType", name: "string" };
+        case "System.Int32":
+        case "int":
+            return { kind: "primitiveType", name: "int" };
+        case "System.Double":
+        case "double":
+            return { kind: "primitiveType", name: "number" };
+        case "System.Char":
+        case "char":
+            return { kind: "primitiveType", name: "char" };
+    }
+    return undefined;
+};
+/**
+ * Check if an expression's inferred type is boolean.
+ */
+const isBooleanCondition = (expr) => {
+    const type = expr.inferredType;
+    if (!type)
+        return false;
+    if (type.kind === "primitiveType") {
+        return type.name === "boolean";
+    }
+    // Some CLR APIs (via bindings) surface as referenceType with a resolved CLR primitive
+    // (e.g. System.Boolean). Treat those as booleans for C# conditions.
+    const coerced = coerceClrPrimitiveToPrimitiveType(type);
+    return (!!coerced && coerced.kind === "primitiveType" && coerced.name === "boolean");
+};
+/**
+ * Expressions that are always boolean in JS/TS, even if the IR is missing inferredType.
+ *
+ * This makes boolean-context emission robust: comparisons and `!expr` are already valid
+ * C# conditions and should not be rewritten to `!= null` fallbacks.
+ */
+const isInherentlyBooleanExpression = (expr) => {
+    if (expr.kind === "binary") {
+        return (expr.operator === "==" ||
+            expr.operator === "!=" ||
+            expr.operator === "===" ||
+            expr.operator === "!==" ||
+            expr.operator === "<" ||
+            expr.operator === ">" ||
+            expr.operator === "<=" ||
+            expr.operator === ">=" ||
+            expr.operator === "instanceof" ||
+            expr.operator === "in");
+    }
+    if (expr.kind === "unary") {
+        return expr.operator === "!";
+    }
+    return false;
+};
+// ============================================================
+// AST construction helpers
+// ============================================================
+/** Wrap an AST expression in parentheses if it has lower precedence than `is` (relational = 10). */
+const wrapForIs = (ast) => {
+    switch (ast.kind) {
+        case "assignmentExpression":
+        case "conditionalExpression":
+        case "lambdaExpression":
+        case "throwExpression":
+            return { kind: "parenthesizedExpression", expression: ast };
+        case "binaryExpression": {
+            // Binary operators with precedence < relational (10) need wrapping
+            switch (ast.operatorToken) {
+                case "??":
+                case "||":
+                case "&&":
+                case "|":
+                case "^":
+                case "&":
+                case "==":
+                case "!=":
+                    return { kind: "parenthesizedExpression", expression: ast };
+                default:
+                    return ast;
+            }
+        }
+        default:
+            return ast;
+    }
+};
+const identifierExpr = (name) => ({
+    kind: "identifierExpression",
+    identifier: name,
+});
+const literalExpr = (text) => ({
+    kind: "literalExpression",
+    text,
+});
+const predefinedType = (keyword) => ({
+    kind: "predefinedType",
+    keyword,
+});
+const identifierType = (name) => ({
+    kind: "identifierType",
+    name,
+});
+const castExpr = (type, expression) => ({
+    kind: "castExpression",
+    type,
+    expression,
+});
+const typePattern = (type) => ({
+    kind: "typePattern",
+    type,
+});
+const notEqualsExpr = (left, right) => ({
+    kind: "binaryExpression",
+    operatorToken: "!=",
+    left,
+    right,
+});
+const andExpr = (left, right) => ({
+    kind: "binaryExpression",
+    operatorToken: "&&",
+    left,
+    right,
+});
+const notExpr = (operand) => ({
+    kind: "prefixUnaryExpression",
+    operatorToken: "!",
+    operand,
+});
+const staticMemberExpr = (typeName, memberName) => ({
+    kind: "memberAccessExpression",
+    expression: identifierExpr(typeName),
+    memberName,
+});
+const callExpr = (callee, args) => ({
+    kind: "invocationExpression",
+    expression: callee,
+    arguments: args,
+});
+const makeSwitchArm = (pattern, expression) => ({ pattern, expression });
+const buildTruthySwitchAst = (tmp) => {
+    const tmpExpr = identifierExpr(tmp);
+    const typedNonZeroArm = (type, zeroLiteralText) => makeSwitchArm(typePattern(type), notEqualsExpr(castExpr(type, tmpExpr), literalExpr(zeroLiteralText)));
+    const floatLikeArm = (type, isNaNStaticTypeName, zeroLiteralText) => {
+        const casted = castExpr(type, tmpExpr);
+        const nonZero = notEqualsExpr(casted, literalExpr(zeroLiteralText));
+        const isNaNCall = callExpr(staticMemberExpr(isNaNStaticTypeName, "IsNaN"), [
+            castExpr(type, tmpExpr),
+        ]);
+        return makeSwitchArm(typePattern(type), andExpr(nonZero, notExpr(isNaNCall)));
+    };
+    return {
+        kind: "switchExpression",
+        governingExpression: tmpExpr,
+        arms: [
+            makeSwitchArm(typePattern(predefinedType("bool")), castExpr(predefinedType("bool"), tmpExpr)),
+            makeSwitchArm(typePattern(predefinedType("string")), notEqualsExpr({
+                kind: "memberAccessExpression",
+                expression: castExpr(predefinedType("string"), tmpExpr),
+                memberName: "Length",
+            }, literalExpr("0"))),
+            typedNonZeroArm(predefinedType("sbyte"), "0"),
+            typedNonZeroArm(predefinedType("byte"), "0"),
+            typedNonZeroArm(predefinedType("short"), "0"),
+            typedNonZeroArm(predefinedType("ushort"), "0"),
+            typedNonZeroArm(predefinedType("int"), "0"),
+            typedNonZeroArm(predefinedType("uint"), "0U"),
+            typedNonZeroArm(predefinedType("long"), "0L"),
+            typedNonZeroArm(predefinedType("ulong"), "0UL"),
+            typedNonZeroArm(predefinedType("nint"), "0"),
+            typedNonZeroArm(predefinedType("nuint"), "0"),
+            typedNonZeroArm(identifierType("global::System.Int128"), "0"),
+            typedNonZeroArm(identifierType("global::System.UInt128"), "0"),
+            floatLikeArm(identifierType("global::System.Half"), "global::System.Half", "(global::System.Half)0"),
+            floatLikeArm(predefinedType("float"), "global::System.Single", "0f"),
+            floatLikeArm(predefinedType("double"), "global::System.Double", "0d"),
+            typedNonZeroArm(predefinedType("decimal"), "0m"),
+            typedNonZeroArm(predefinedType("char"), "'\\0'"),
+            makeSwitchArm({ kind: "discardPattern" }, literalExpr("true")),
+        ],
+    };
+};
+// ============================================================
+// Runtime truthiness (AST-native)
+// ============================================================
+const emitRuntimeTruthinessConditionAst = (emittedAst, context) => {
+    // Use a pattern variable to evaluate the operand exactly once, then apply JS-like truthiness.
+    //
+    // This is the airplane-grade fallback when we cannot trust inferredType:
+    // - Never emit `x != null` for unknowns (silently miscompiles boxed value types like bool/int).
+    // - Use runtime type checks to preserve semantics deterministically.
+    const nextId = (context.tempVarId ?? 0) + 1;
+    const ctxWithId = { ...context, tempVarId: nextId };
+    const alloc = allocateLocalName(`__tsonic_truthy_${nextId}`, ctxWithId);
+    const tmp = alloc.emittedName;
+    // Build: (operand is object __tmp && (__tmp switch { ... }))
+    const isObjectExpr = {
+        kind: "isExpression",
+        expression: wrapForIs(emittedAst),
+        pattern: {
+            kind: "declarationPattern",
+            type: { kind: "predefinedType", keyword: "object" },
+            designation: tmp,
+        },
+    };
+    const switchExpr = {
+        kind: "parenthesizedExpression",
+        expression: buildTruthySwitchAst(tmp),
+    };
+    return [
+        {
+            kind: "parenthesizedExpression",
+            expression: {
+                kind: "binaryExpression",
+                operatorToken: "&&",
+                left: isObjectExpr,
+                right: switchExpr,
+            },
+        },
+        alloc.context,
+    ];
+};
+// ============================================================
+// Type resolution helpers
+// ============================================================
+const resolveLocalTypeAlias = (type, context) => {
+    let current = type;
+    const visited = new Set();
+    while (current.kind === "referenceType") {
+        const name = current.name;
+        if (visited.has(name))
+            break;
+        visited.add(name);
+        const local = context.localTypes?.get(name);
+        if (!local || local.kind !== "typeAlias")
+            break;
+        // If the alias is generic, substitute type arguments when provided.
+        if (local.typeParameters.length > 0) {
+            if (!current.typeArguments || current.typeArguments.length === 0)
+                break;
+            current = substituteTypeArgs(local.type, local.typeParameters, current.typeArguments);
+            continue;
+        }
+        current = local.type;
+    }
+    return current;
+};
+const isNullishType = (type) => type.kind === "primitiveType" &&
+    (type.name === "null" || type.name === "undefined");
+const getLiteralUnionBasePrimitive = (types) => {
+    let base;
+    for (const t of types) {
+        if (t.kind !== "literalType")
+            return undefined;
+        const v = t.value;
+        const next = typeof v === "string"
+            ? "string"
+            : typeof v === "number"
+                ? "number"
+                : typeof v === "boolean"
+                    ? "boolean"
+                    : undefined;
+        if (!next)
+            return undefined;
+        if (!base)
+            base = next;
+        else if (base !== next)
+            return undefined;
+    }
+    return base;
+};
+// ============================================================
+// Union truthiness (AST-native)
+// ============================================================
+const emitUnionTruthinessConditionAst = (expr, emittedAst, unionType, context) => {
+    // Align boolean-context emission with union type emission:
+    // - (T | null | undefined) behaves like a nullable (falsy when nullish)
+    // - literal unions behave like their primitive base at runtime
+    // - 2-8 unions emit as global::Tsonic.Runtime.Union<T1..Tn>, which requires per-variant truthiness
+    const nonNullTypes = unionType.types.filter((t) => !isNullishType(t));
+    const hasNullish = nonNullTypes.length !== unionType.types.length;
+    const literalBase = getLiteralUnionBasePrimitive(nonNullTypes);
+    if (literalBase) {
+        const baseType = {
+            kind: "primitiveType",
+            name: literalBase,
+        };
+        if (!hasNullish) {
+            return toBooleanConditionAst({ ...expr, inferredType: baseType }, emittedAst, context);
+        }
+        // Nullable literal union (e.g. "a" | "b" | null) → value is falsy when nullish.
+        const nextId = (context.tempVarId ?? 0) + 1;
+        const ctxWithId = { ...context, tempVarId: nextId };
+        const alloc = allocateLocalName(`__tsonic_truthy_nullable_${nextId}`, ctxWithId);
+        const tmp = alloc.emittedName;
+        const [innerCondAst, innerCtx] = toBooleanConditionAst({
+            kind: "identifier",
+            name: tmp,
+            inferredType: baseType,
+        }, identifierExpr(tmp), alloc.context);
+        const emittedNonNull = literalBase === "string"
+            ? "string"
+            : literalBase === "number"
+                ? "double"
+                : "bool";
+        // Build: (operand is Type tmp && innerCond)
+        return [
+            {
+                kind: "parenthesizedExpression",
+                expression: {
+                    kind: "binaryExpression",
+                    operatorToken: "&&",
+                    left: {
+                        kind: "isExpression",
+                        expression: wrapForIs(emittedAst),
+                        pattern: {
+                            kind: "declarationPattern",
+                            type: { kind: "predefinedType", keyword: emittedNonNull },
+                            designation: tmp,
+                        },
+                    },
+                    right: innerCondAst,
+                },
+            },
+            innerCtx,
+        ];
+    }
+    // Nullable union: (T | null | undefined) → treat as `T?` truthiness.
+    if (hasNullish && nonNullTypes.length === 1) {
+        const nonNull = nonNullTypes[0];
+        if (!nonNull)
+            return [literalExpr("false"), context];
+        // For non-primitive nullable unions (e.g. `T[] | undefined`, `SomeRef | null`),
+        // emit truthiness directly against the operand with non-null inferred type.
+        // This avoids nested nullable pattern variables while preserving exact semantics.
+        if (nonNull.kind !== "primitiveType") {
+            return toBooleanConditionAst({ ...expr, inferredType: nonNull }, emittedAst, context);
+        }
+        const nextId = (context.tempVarId ?? 0) + 1;
+        const ctxWithId = { ...context, tempVarId: nextId };
+        const alloc = allocateLocalName(`__tsonic_truthy_nullable_${nextId}`, ctxWithId);
+        const tmp = alloc.emittedName;
+        // Pattern-match the non-null value into a strongly-typed temp and apply truthiness to it.
+        // This handles both nullable value types (int?) and nullable reference types (string?).
+        const [innerCondAst, innerCtx] = toBooleanConditionAst({
+            kind: "identifier",
+            name: tmp,
+            inferredType: nonNull,
+        }, identifierExpr(tmp), alloc.context);
+        const emittedNonNull = nonNull.name === "number"
+            ? "double"
+            : nonNull.name === "int"
+                ? "int"
+                : nonNull.name === "string"
+                    ? "string"
+                    : nonNull.name === "boolean"
+                        ? "bool"
+                        : nonNull.name === "char"
+                            ? "char"
+                            : "object";
+        // Build: (operand is Type tmp && innerCond)
+        return [
+            {
+                kind: "parenthesizedExpression",
+                expression: {
+                    kind: "binaryExpression",
+                    operatorToken: "&&",
+                    left: {
+                        kind: "isExpression",
+                        expression: wrapForIs(emittedAst),
+                        pattern: {
+                            kind: "declarationPattern",
+                            type: { kind: "predefinedType", keyword: emittedNonNull },
+                            designation: tmp,
+                        },
+                    },
+                    right: innerCondAst,
+                },
+            },
+            innerCtx,
+        ];
+    }
+    // 2-8 unions use runtime Union<T1..Tn>. We must inspect the active variant.
+    if (unionType.types.length >= 2 && unionType.types.length <= 8) {
+        const nextId = (context.tempVarId ?? 0) + 1;
+        const ctxWithId = { ...context, tempVarId: nextId };
+        const alloc = allocateLocalName(`__tsonic_truthy_union_${nextId}`, ctxWithId);
+        const u = alloc.emittedName;
+        // Build per-member truthiness ASTs
+        let chainCtx = alloc.context;
+        const branchAsts = [];
+        for (let i = 0; i < unionType.types.length; i++) {
+            const memberN = i + 1;
+            const memberType = unionType.types[i];
+            if (!memberType || isNullishType(memberType)) {
+                branchAsts.push(literalExpr("false"));
+                continue;
+            }
+            const memberEmittedAst = {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: identifierExpr(u),
+                    memberName: `As${memberN}`,
+                },
+                arguments: [],
+            };
+            const [memberCondAst, memberCtx] = toBooleanConditionAst({
+                kind: "identifier",
+                name: `${u}__${memberN}`,
+                inferredType: memberType,
+            }, memberEmittedAst, chainCtx);
+            branchAsts.push(memberCondAst);
+            chainCtx = memberCtx;
+        }
+        // Build nested conditional chain: u.Is1() ? (cond1) : u.Is2() ? (cond2) : ...
+        const buildChain = (start) => {
+            const last = branchAsts[branchAsts.length - 1];
+            if (start === branchAsts.length - 1) {
+                return last ?? literalExpr("false");
+            }
+            const branch = branchAsts[start];
+            return {
+                kind: "conditionalExpression",
+                condition: {
+                    kind: "invocationExpression",
+                    expression: {
+                        kind: "memberAccessExpression",
+                        expression: identifierExpr(u),
+                        memberName: `Is${start + 1}`,
+                    },
+                    arguments: [],
+                },
+                whenTrue: {
+                    kind: "parenthesizedExpression",
+                    expression: branch ?? literalExpr("false"),
+                },
+                whenFalse: {
+                    kind: "parenthesizedExpression",
+                    expression: buildChain(start + 1),
+                },
+            };
+        };
+        const chainAst = buildChain(0);
+        // Build: (operand is var u && u is not null && (chain))
+        return [
+            {
+                kind: "parenthesizedExpression",
+                expression: {
+                    kind: "binaryExpression",
+                    operatorToken: "&&",
+                    left: {
+                        kind: "binaryExpression",
+                        operatorToken: "&&",
+                        left: {
+                            kind: "isExpression",
+                            expression: wrapForIs(emittedAst),
+                            pattern: { kind: "varPattern", designation: u },
+                        },
+                        right: {
+                            kind: "isExpression",
+                            expression: identifierExpr(u),
+                            pattern: {
+                                kind: "negatedPattern",
+                                pattern: {
+                                    kind: "constantPattern",
+                                    expression: literalExpr("null"),
+                                },
+                            },
+                        },
+                    },
+                    right: {
+                        kind: "parenthesizedExpression",
+                        expression: chainAst,
+                    },
+                },
+            },
+            chainCtx,
+        ];
+    }
+    // Fallback for unions >8 (emitted as object): runtime truthiness matches JS semantics.
+    return emitRuntimeTruthinessConditionAst(emittedAst, context);
+};
+// ============================================================
+// 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 = expr.inferredType;
+    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 [literalExpr("false"), context];
+        }
+        if (typeof expr.value === "boolean") {
+            return [literalExpr(expr.value ? "true" : "false"), context];
+        }
+        if (typeof expr.value === "number") {
+            return [literalExpr(expr.value === 0 ? "false" : "true"), context];
+        }
+        if (typeof expr.value === "string") {
+            return [literalExpr(expr.value.length === 0 ? "false" : "true"), context];
+        }
+    }
+    // If already boolean, use as-is
+    if (isBooleanCondition(expr)) {
+        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);
+    }
+    // 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 [literalExpr("false"), context];
+            case "string":
+                // !string.IsNullOrEmpty(expr)
+                return [
+                    {
+                        kind: "parenthesizedExpression",
+                        expression: {
+                            kind: "prefixUnaryExpression",
+                            operatorToken: "!",
+                            operand: {
+                                kind: "invocationExpression",
+                                expression: {
+                                    kind: "memberAccessExpression",
+                                    expression: literalExpr("string"),
+                                    memberName: "IsNullOrEmpty",
+                                },
+                                arguments: [emittedAst],
+                            },
+                        },
+                    },
+                    context,
+                ];
+            case "int":
+                // expr != 0
+                return [
+                    {
+                        kind: "parenthesizedExpression",
+                        expression: {
+                            kind: "binaryExpression",
+                            operatorToken: "!=",
+                            left: emittedAst,
+                            right: literalExpr("0"),
+                        },
+                    },
+                    context,
+                ];
+            case "char":
+                // expr != '\0'
+                return [
+                    {
+                        kind: "parenthesizedExpression",
+                        expression: {
+                            kind: "binaryExpression",
+                            operatorToken: "!=",
+                            left: emittedAst,
+                            right: literalExpr("'\\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: literalExpr("0"),
+                                },
+                                right: {
+                                    kind: "prefixUnaryExpression",
+                                    operatorToken: "!",
+                                    operand: {
+                                        kind: "invocationExpression",
+                                        expression: {
+                                            kind: "memberAccessExpression",
+                                            expression: literalExpr("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 [rightAst, rightCtx] = emitBooleanConditionAst(expr.right, emitExprAst, leftCtx);
+        return [
+            {
+                kind: "binaryExpression",
+                operatorToken: expr.operator,
+                left: leftAst,
+                right: rightAst,
+            },
+            rightCtx,
+        ];
+    }
+    const [exprAst, exprCtx] = emitExprAst(expr, context);
+    return toBooleanConditionAst(expr, exprAst, exprCtx);
+};
+/**
+ * Whether a type is boolean.
+ *
+ * Used by callers that need a fast check (e.g., logical operator selection).
+ */
+export const isBooleanType = (type) => {
+    return !!type && type.kind === "primitiveType" && type.name === "boolean";
+};
+//# sourceMappingURL=boolean-context.js.map