@tsonic/emitter 0.0.62 → 0.0.64

package/dist/expressions/operators/assignment-emitter.js

@@ -0,0 +1,118 @@
+/**
+ * Assignment operator expression emitter
+ */
+import { emitExpressionAst } from "../../expression-emitter.js";
+import { emitRemappedLocalName } from "../../core/format/local-names.js";
+import { lowerAssignmentPatternAst } from "../../patterns.js";
+import { hasInt32Proof } from "./helpers.js";
+/**
+ * Emit an assignment expression as CSharpExpressionAst
+ *
+ * Passes the LHS type as expected type to RHS, enabling proper integer
+ * literal emission for cases like `this.value = this.value + 1`.
+ */
+export const emitAssignment = (expr, context) => {
+    // Array element assignment uses native CLR indexer
+    // HARD GATE: Index must be proven Int32 (validated by proof pass)
+    if (expr.operator === "=" &&
+        "kind" in expr.left &&
+        expr.left.kind === "memberAccess" &&
+        expr.left.isComputed &&
+        expr.left.object.inferredType?.kind === "arrayType") {
+        const leftExpr = expr.left;
+        const indexExpr = leftExpr.property;
+        if (!hasInt32Proof(indexExpr)) {
+            // ICE: Unproven index should have been caught by proof pass (TSN5107)
+            throw new Error(`Internal Compiler Error: Array index must be proven Int32. ` +
+                `This should have been caught by the numeric proof pass (TSN5107).`);
+        }
+        const [objectAst, objectContext] = emitExpressionAst(leftExpr.object, context);
+        const [indexAst, indexContext] = emitExpressionAst(indexExpr, objectContext);
+        const [rightAst, rightContext] = emitExpressionAst(expr.right, indexContext);
+        // Use native CLR indexer: arr[idx] = value
+        return [
+            {
+                kind: "assignmentExpression",
+                operatorToken: "=",
+                left: {
+                    kind: "elementAccessExpression",
+                    expression: objectAst,
+                    arguments: [indexAst],
+                },
+                right: rightAst,
+            },
+            rightContext,
+        ];
+    }
+    // Left side can be an expression or a pattern (for destructuring)
+    const isPattern = "kind" in expr.left &&
+        (expr.left.kind === "identifierPattern" ||
+            expr.left.kind === "arrayPattern" ||
+            expr.left.kind === "objectPattern");
+    // Handle destructuring assignment patterns with AST lowering.
+    if (isPattern && expr.operator === "=") {
+        const pattern = expr.left;
+        // Emit the RHS first
+        const [rightAst, rightContext] = emitExpressionAst(expr.right, context);
+        const result = lowerAssignmentPatternAst(pattern, rightAst, expr.right.inferredType, rightContext);
+        return [result.expression, result.context];
+    }
+    // Standard assignment (expression on left side)
+    let leftAst;
+    let leftContext;
+    let leftType;
+    if (isPattern) {
+        // Identifier pattern with compound assignment (+=, etc.)
+        const pattern = expr.left;
+        if (pattern.kind === "identifierPattern") {
+            leftAst = {
+                kind: "identifierExpression",
+                identifier: emitRemappedLocalName(pattern.name, context),
+            };
+            leftContext = context;
+            leftType = pattern.type;
+        }
+        else {
+            // Compound assignment to array/object pattern - not valid in JS
+            leftAst = {
+                kind: "identifierExpression",
+                identifier: "/* invalid compound destructuring */",
+            };
+            leftContext = context;
+        }
+    }
+    else {
+        const leftExpr = expr.left;
+        // Narrowing maps (instanceof / nullable / union) apply to *reads*, not writes.
+        // For assignment, the LHS is written, so we must not rewrite identifier targets
+        // to narrowed bindings (e.g., C# pattern vars).
+        const leftCtx = leftExpr.kind === "identifier" &&
+            context.narrowedBindings?.has(leftExpr.name)
+            ? (() => {
+                const next = new Map(context.narrowedBindings);
+                next.delete(leftExpr.name);
+                return { ...context, narrowedBindings: next };
+            })()
+            : context;
+        const [emittedLeftAst, ctx] = emitExpressionAst(leftExpr, leftCtx);
+        leftAst = emittedLeftAst;
+        // Restore narrowing for RHS emission (reads) when we suppressed it for the LHS.
+        leftContext =
+            leftCtx !== context
+                ? { ...ctx, narrowedBindings: context.narrowedBindings }
+                : ctx;
+        leftType = leftExpr.inferredType;
+    }
+    // Pass LHS type as expected type to RHS for proper integer handling
+    const [rightAst, rightContext] = emitExpressionAst(expr.right, leftContext, leftType);
+    return [
+        {
+            kind: "assignmentExpression",
+            operatorToken: expr.operator,
+            left: leftAst,
+            right: rightAst,
+        },
+        rightContext,
+    ];
+};
+//# sourceMappingURL=assignment-emitter.js.map

package/dist/expressions/operators/assignment-emitter.js.map

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

package/dist/expressions/operators/binary-emitter.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Binary operator expression emitter
+ *
+ * NEW NUMERIC SPEC:
+ * - Literals use raw lexeme (no contextual widening)
+ * - Integer casts only from IrCastExpression (not inferred from expectedType)
+ * - Binary ops: int op int = int, double op anything = double (C# semantics)
+ */
+import { IrExpression, IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../../types.js";
+import type { CSharpExpressionAst } from "../../core/format/backend-ast/types.js";
+/**
+ * Emit a binary operator expression as CSharpExpressionAst
+ *
+ * NEW NUMERIC SPEC: No contextual type propagation for numeric literals.
+ * Literals use their raw lexeme - C# will naturally handle int + int = int,
+ * int + double = double, etc.
+ *
+ * Explicit casts come from IrCastExpression nodes (generated by type-checker
+ * when user intent allows int → double coercion).
+ *
+ * STRING INDEXER FIX: In C#, string[int] returns char, not string.
+ * When comparing a string indexer result with a single-character string literal,
+ * we emit the string as a char literal to avoid CS0019 (char == string).
+ *
+ * @param expr - The binary expression
+ * @param context - Emitter context
+ * @param _expectedType - Currently unused
+ */
+export declare const emitBinary: (expr: Extract<IrExpression, {
+    kind: "binary";
+}>, context: EmitterContext, _expectedType?: IrType) => [CSharpExpressionAst, EmitterContext];
+//# sourceMappingURL=binary-emitter.d.ts.map

package/dist/expressions/operators/binary-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-emitter.d.ts","sourceRoot":"","sources":["../../../src/expressions/operators/binary-emitter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAgBhD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAElF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,GACrB,MAAM,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,EAC/C,SAAS,cAAc,EACvB,gBAAgB,MAAM,KACrB,CAAC,mBAAmB,EAAE,cAAc,CAoctC,CAAC"}

package/dist/expressions/operators/binary-emitter.js

@@ -0,0 +1,398 @@
+/**
+ * Binary operator expression emitter
+ *
+ * NEW NUMERIC SPEC:
+ * - Literals use raw lexeme (no contextual widening)
+ * - Integer casts only from IrCastExpression (not inferred from expectedType)
+ * - Binary ops: int op int = int, double op anything = double (C# semantics)
+ */
+import { emitExpressionAst } from "../../expression-emitter.js";
+import { resolveTypeAlias, stripNullish, getAllPropertySignatures, isDefinitelyValueType, } from "../../core/semantic/type-resolution.js";
+import { isCharTyped, isStringTyped, getSingleCharLiteral, escapeCharLiteral, isNullishLiteral, } from "./helpers.js";
+import { extractCalleeNameFromAst } from "../../core/format/backend-ast/utils.js";
+/**
+ * Emit a binary operator expression as CSharpExpressionAst
+ *
+ * NEW NUMERIC SPEC: No contextual type propagation for numeric literals.
+ * Literals use their raw lexeme - C# will naturally handle int + int = int,
+ * int + double = double, etc.
+ *
+ * Explicit casts come from IrCastExpression nodes (generated by type-checker
+ * when user intent allows int → double coercion).
+ *
+ * STRING INDEXER FIX: In C#, string[int] returns char, not string.
+ * When comparing a string indexer result with a single-character string literal,
+ * we emit the string as a char literal to avoid CS0019 (char == string).
+ *
+ * @param expr - The binary expression
+ * @param context - Emitter context
+ * @param _expectedType - Currently unused
+ */
+export const emitBinary = (expr, context, _expectedType) => {
+    // Map JavaScript operators to C# operators
+    const operatorMap = {
+        "===": "==",
+        "!==": "!=",
+        "==": "==", // Loose equality - needs special handling
+        "!=": "!=", // Loose inequality - needs special handling
+        instanceof: "is",
+        in: "/* in */", // Needs special handling
+    };
+    const op = operatorMap[expr.operator] ?? expr.operator;
+    // Handle `"prop" in x` (union narrowing / dictionary membership)
+    if (expr.operator === "in") {
+        // LHS must be a string literal for deterministic lowering.
+        if (expr.left.kind !== "literal" || typeof expr.left.value !== "string") {
+            throw new Error("ICE: Unsupported `in` operator form. Left-hand side must be a string literal.");
+        }
+        const rhsType = expr.right.inferredType;
+        if (!rhsType) {
+            throw new Error("ICE: `in` operator RHS missing inferredType.");
+        }
+        const [rhsAst, rhsCtx] = emitExpressionAst(expr.right, context);
+        const resolvedRhs = resolveTypeAlias(stripNullish(rhsType), rhsCtx);
+        // Union<T1..Tn>: `"error" in auth` → auth.IsN() (where member N has the prop)
+        if (resolvedRhs.kind === "unionType") {
+            const propName = expr.left.value;
+            const matchingMembers = [];
+            for (let i = 0; i < resolvedRhs.types.length; i++) {
+                const member = resolvedRhs.types[i];
+                if (!member || member.kind !== "referenceType")
+                    continue;
+                const localInfo = rhsCtx.localTypes?.get(member.name);
+                if (localInfo?.kind === "interface") {
+                    const props = getAllPropertySignatures(member, rhsCtx);
+                    if (props?.some((p) => p.name === propName)) {
+                        matchingMembers.push(i + 1);
+                    }
+                    continue;
+                }
+                if (localInfo?.kind === "class") {
+                    if (localInfo.members.some((m) => (m.kind === "propertyDeclaration" ||
+                        m.kind === "methodDeclaration") &&
+                        m.name === propName)) {
+                        matchingMembers.push(i + 1);
+                    }
+                    continue;
+                }
+                // Cross-module union members: consult the batch type-member index.
+                const candidates = [];
+                const stripGlobalPrefix = (name) => name.startsWith("global::") ? name.slice("global::".length) : name;
+                if (member.resolvedClrType) {
+                    candidates.push(stripGlobalPrefix(member.resolvedClrType));
+                }
+                if (member.name.includes(".")) {
+                    candidates.push(member.name);
+                }
+                if (!member.name.includes(".") && rhsCtx.options.typeMemberIndex) {
+                    const matches = [];
+                    for (const fqn of rhsCtx.options.typeMemberIndex.keys()) {
+                        if (fqn.endsWith(`.${member.name}`) ||
+                            fqn.endsWith(`.${member.name}__Alias`)) {
+                            matches.push(fqn);
+                        }
+                    }
+                    if (matches.length === 1) {
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        candidates.push(matches[0]);
+                    }
+                    else if (matches.length > 1) {
+                        const list = matches.sort().join(", ");
+                        throw new Error(`ICE: Ambiguous union member type '${member.name}' for \`in\` narrowing. Candidates: ${list}`);
+                    }
+                }
+                // Single-file fallback (no batch indexes): assume same namespace.
+                if (rhsCtx.moduleNamespace) {
+                    candidates.push(`${rhsCtx.moduleNamespace}.${member.name}`);
+                    candidates.push(`${rhsCtx.moduleNamespace}.${member.name}__Alias`);
+                }
+                const hasMember = candidates.some((fqn) => {
+                    const perType = rhsCtx.options.typeMemberIndex?.get(fqn);
+                    return perType?.has(propName) ?? false;
+                });
+                if (hasMember) {
+                    matchingMembers.push(i + 1);
+                }
+            }
+            if (matchingMembers.length === 0) {
+                return [{ kind: "literalExpression", text: "false" }, rhsCtx];
+            }
+            // Build IsN() call ASTs and chain with ||
+            const checkAsts = matchingMembers.map((n) => ({
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: rhsAst,
+                    memberName: `Is${n}`,
+                },
+                arguments: [],
+            }));
+            const orChain = checkAsts.reduce((left, right) => ({
+                kind: "binaryExpression",
+                operatorToken: "||",
+                left,
+                right,
+            }));
+            // Wrap multi-member OR chains in parens so they compose correctly
+            // with surrounding operators (e.g., `(x.Is1() || x.Is2()) && ok`).
+            const result = checkAsts.length > 1
+                ? { kind: "parenthesizedExpression", expression: orChain }
+                : orChain;
+            return [result, rhsCtx];
+        }
+        // Dictionary<K,V>: `"k" in dict` → dict.ContainsKey("k")
+        if (resolvedRhs.kind === "dictionaryType") {
+            const keyType = stripNullish(resolvedRhs.keyType);
+            const isStringKey = (keyType.kind === "primitiveType" && keyType.name === "string") ||
+                (keyType.kind === "referenceType" && keyType.name === "string");
+            if (!isStringKey) {
+                throw new Error("ICE: Unsupported `in` operator on dictionary with non-string keys.");
+            }
+            const [keyAst, keyCtx] = emitExpressionAst(expr.left, rhsCtx);
+            const containsKeyAst = {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: rhsAst,
+                    memberName: "ContainsKey",
+                },
+                arguments: [keyAst],
+            };
+            return [containsKeyAst, keyCtx];
+        }
+        throw new Error("ICE: Unsupported `in` operator. Only union shape guards and Dictionary<string, T> membership are supported.");
+    }
+    // Handle instanceof operator specially
+    if (expr.operator === "instanceof") {
+        const [leftAst, leftContext] = emitExpressionAst(expr.left, context);
+        const [rightAst, rightContext] = emitExpressionAst(expr.right, leftContext);
+        // For `is`, convert expression to type name (extract from identifierExpression)
+        const rightText = extractCalleeNameFromAst(rightAst);
+        const isExpr = {
+            kind: "isExpression",
+            expression: leftAst,
+            pattern: {
+                kind: "typePattern",
+                type: { kind: "identifierType", name: rightText },
+            },
+        };
+        return [isExpr, rightContext];
+    }
+    // CHAR VS STRING COMPARISON FIX:
+    // In C#, string[int] returns char, but in TypeScript it returns string.
+    // When comparing a char-typed expression with a single-character string literal,
+    // emit the string as a char literal to avoid CS0019 (char == string).
+    const isComparisonOp = op === "==" ||
+        op === "!=" ||
+        op === "<" ||
+        op === ">" ||
+        op === "<=" ||
+        op === ">=";
+    if (isComparisonOp) {
+        const leftIsChar = isCharTyped(expr.left);
+        const rightIsChar = isCharTyped(expr.right);
+        const leftSingleChar = getSingleCharLiteral(expr.left);
+        const rightSingleChar = getSingleCharLiteral(expr.right);
+        // Case 1: left is char-typed, right is single-char literal → emit right as char
+        if (leftIsChar && rightSingleChar !== undefined) {
+            const [leftAst, leftContext] = emitExpressionAst(expr.left, context);
+            const charLiteralAst = {
+                kind: "literalExpression",
+                text: `'${escapeCharLiteral(rightSingleChar)}'`,
+            };
+            return [
+                {
+                    kind: "binaryExpression",
+                    operatorToken: op,
+                    left: leftAst,
+                    right: charLiteralAst,
+                },
+                leftContext,
+            ];
+        }
+        // Case 2: right is char-typed, left is single-char literal → emit left as char
+        if (rightIsChar && leftSingleChar !== undefined) {
+            const [rightAst, rightContext] = emitExpressionAst(expr.right, context);
+            const charLiteralAst = {
+                kind: "literalExpression",
+                text: `'${escapeCharLiteral(leftSingleChar)}'`,
+            };
+            return [
+                {
+                    kind: "binaryExpression",
+                    operatorToken: op,
+                    left: charLiteralAst,
+                    right: rightAst,
+                },
+                rightContext,
+            ];
+        }
+    }
+    // C# does not support relational operators directly on strings.
+    // TypeScript's lexicographic ordering maps to ordinal string comparison.
+    if (isComparisonOp &&
+        (op === "<" || op === ">" || op === "<=" || op === ">=") &&
+        isStringTyped(expr.left) &&
+        isStringTyped(expr.right)) {
+        const [leftAst, leftContext] = emitExpressionAst(expr.left, context);
+        const [rightAst, rightContext] = emitExpressionAst(expr.right, leftContext);
+        const compareAst = {
+            kind: "invocationExpression",
+            expression: {
+                kind: "identifierExpression",
+                identifier: "global::System.String.CompareOrdinal",
+            },
+            arguments: [leftAst, rightAst],
+        };
+        return [
+            {
+                kind: "binaryExpression",
+                operatorToken: op,
+                left: compareAst,
+                right: { kind: "literalExpression", text: "0" },
+            },
+            rightContext,
+        ];
+    }
+    // NULLISH COMPARISONS:
+    //
+    // Prefer `== null` / `!= null` for normal reference/nullable types so the result
+    // is expression-tree friendly (EF Core query providers do not support pattern matching).
+    //
+    // For unconstrained generics (T), `== null` is not always valid, so we instead cast
+    // to `object` to force reference-equality semantics and avoid operator overloads:
+    //   ((object)x) == null
+    //
+    // TypeScript:  x === undefined  →  C#: x == null
+    // TypeScript:  x !== undefined  →  C#: x != null
+    // TypeScript:  x === null       →  C#: x == null
+    // TypeScript:  x !== null       →  C#: x != null
+    const leftIsNullish = isNullishLiteral(expr.left);
+    const rightIsNullish = isNullishLiteral(expr.right);
+    const isNullishComparison = isComparisonOp &&
+        (op === "==" || op === "!=") &&
+        (leftIsNullish || rightIsNullish);
+    if (isNullishComparison) {
+        // One side is null/undefined literal, emit the other side as a C# null check.
+        // Clear narrowedBindings so we emit the raw identifier (not .Value)
+        const nonNullishExpr = leftIsNullish ? expr.right : expr.left;
+        const nullishExpr = leftIsNullish ? expr.left : expr.right;
+        const isUndefinedLiteral = (nullishExpr.kind === "literal" && nullishExpr.value === undefined) ||
+            (nullishExpr.kind === "identifier" && nullishExpr.name === "undefined");
+        // JS dictionary-style access (`dict[key]`) with undefined comparison should
+        // model key existence, not CLR value-type nullability.
+        //
+        //   dict[key] === undefined  -> !dict.ContainsKey(key)
+        //   dict[key] !== undefined  ->  dict.ContainsKey(key)
+        if (isUndefinedLiteral &&
+            nonNullishExpr.kind === "memberAccess" &&
+            nonNullishExpr.isComputed &&
+            typeof nonNullishExpr.property !== "string" &&
+            (nonNullishExpr.accessKind === "dictionary" ||
+                nonNullishExpr.object.inferredType?.kind === "dictionaryType")) {
+            const nonNullishContext = { ...context, narrowedBindings: undefined };
+            const [dictAst, dictContext] = emitExpressionAst(nonNullishExpr.object, nonNullishContext);
+            const [keyAst, keyContext] = emitExpressionAst(nonNullishExpr.property, dictContext);
+            const containsAst = {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: {
+                        kind: "parenthesizedExpression",
+                        expression: dictAst,
+                    },
+                    memberName: "ContainsKey",
+                },
+                arguments: [keyAst],
+            };
+            const resultAst = op === "=="
+                ? {
+                    kind: "prefixUnaryExpression",
+                    operatorToken: "!",
+                    operand: containsAst,
+                }
+                : containsAst;
+            return [resultAst, keyContext];
+        }
+        const nonNullishContext = { ...context, narrowedBindings: undefined };
+        const [nonNullishAst, resultContext] = emitExpressionAst(nonNullishExpr, nonNullishContext);
+        const inferred = nonNullishExpr.inferredType;
+        const base = inferred ? stripNullish(inferred) : undefined;
+        const bareTypeParamName = (() => {
+            if (!base)
+                return undefined;
+            if (base.kind === "typeParameterType")
+                return base.name;
+            if (base.kind === "referenceType" &&
+                (resultContext.typeParameters?.has(base.name) ?? false) &&
+                (!base.typeArguments || base.typeArguments.length === 0)) {
+                return base.name;
+            }
+            return undefined;
+        })();
+        const isDefiniteNonUnionValueType = inferred !== undefined &&
+            inferred.kind !== "unionType" &&
+            isDefinitelyValueType(inferred);
+        const typeParamConstraint = bareTypeParamName !== undefined
+            ? (resultContext.typeParamConstraints?.get(bareTypeParamName) ??
+                "unconstrained")
+            : undefined;
+        const needsObjectCastForTypeParam = bareTypeParamName !== undefined &&
+            (typeParamConstraint === "unconstrained" ||
+                typeParamConstraint === "struct");
+        const needsObjectCastForValueType = isDefiniteNonUnionValueType;
+        const nullLiteral = {
+            kind: "literalExpression",
+            text: "null",
+        };
+        const nullOp = op === "==" ? "==" : "!=";
+        if (needsObjectCastForTypeParam || needsObjectCastForValueType) {
+            // ((global::System.Object)(expr)) == null
+            const castExpr = {
+                kind: "castExpression",
+                type: { kind: "identifierType", name: "global::System.Object" },
+                expression: {
+                    kind: "parenthesizedExpression",
+                    expression: nonNullishAst,
+                },
+            };
+            return [
+                {
+                    kind: "binaryExpression",
+                    operatorToken: nullOp,
+                    left: {
+                        kind: "parenthesizedExpression",
+                        expression: castExpr,
+                    },
+                    right: nullLiteral,
+                },
+                resultContext,
+            ];
+        }
+        return [
+            {
+                kind: "binaryExpression",
+                operatorToken: nullOp,
+                left: nonNullishAst,
+                right: nullLiteral,
+            },
+            resultContext,
+        ];
+    }
+    // Standard emission path
+    // Emit operands without contextual type propagation
+    // Literals will emit using their raw lexeme (42 vs 42.0)
+    // Parenthesization is handled by the printer's precedence system
+    const [leftAst, leftContext] = emitExpressionAst(expr.left, context);
+    const [rightAst, rightContext] = emitExpressionAst(expr.right, leftContext);
+    return [
+        {
+            kind: "binaryExpression",
+            operatorToken: op,
+            left: leftAst,
+            right: rightAst,
+        },
+        rightContext,
+    ];
+};
+//# sourceMappingURL=binary-emitter.js.map

package/dist/expressions/operators/binary-emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-emitter.js","sourceRoot":"","sources":["../../../src/expressions/operators/binary-emitter.ts"],"names":[],"mappings":"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"}

package/dist/expressions/operators/conditional-emitter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Conditional (ternary) expression emitter with type predicate narrowing support
+ */
+import { IrExpression, IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../../types.js";
+import type { CSharpExpressionAst } from "../../core/format/backend-ast/types.js";
+/**
+ * Emit a conditional (ternary) expression as CSharpExpressionAst
+ *
+ * Supports type predicate narrowing:
+ * - `isUser(x) ? x.name : "anon"` → `x.Is1() ? (x.As1()).name : "anon"`
+ * - `!isUser(x) ? "anon" : x.name` → `!x.Is1() ? "anon" : (x.As1()).name`
+ */
+export declare const emitConditional: (expr: Extract<IrExpression, {
+    kind: "conditional";
+}>, context: EmitterContext, expectedType?: IrType) => [CSharpExpressionAst, EmitterContext];
+//# sourceMappingURL=conditional-emitter.d.ts.map

package/dist/expressions/operators/conditional-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-emitter.d.ts","sourceRoot":"","sources":["../../../src/expressions/operators/conditional-emitter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAkC,MAAM,gBAAgB,CAAC;AAUhF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AA2QlF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAC1B,MAAM,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,EACpD,SAAS,cAAc,EACvB,eAAe,MAAM,KACpB,CAAC,mBAAmB,EAAE,cAAc,CAoHtC,CAAC"}