@tsonic/emitter 0.0.74 → 0.0.75

package/dist/expressions/operators/binary-runtime-union-comparison.js

@@ -0,0 +1,150 @@
+import { emitExpressionAst } from "../../expression-emitter.js";
+import { emitTypeAst } from "../../type-emitter.js";
+import { buildRuntimeUnionLayout, buildRuntimeUnionTypeAst, findRuntimeUnionMemberIndices, } from "../../core/semantic/runtime-unions.js";
+import { willCarryAsRuntimeUnion } from "../../core/semantic/union-semantics.js";
+import { identifierExpression } from "../../core/format/backend-ast/builders.js";
+import { getTransparentComparisonTarget, resolveComparisonOperandType, widenLiteralComparisonType, } from "./binary-helpers.js";
+import { resolveRuntimeCarrierExpressionAst, resolveDirectStorageExpressionType, resolveIdentifierRuntimeCarrierType, } from "../direct-storage-types.js";
+import { stripNullish } from "../../core/semantic/type-resolution.js";
+const isSupportedLiteralComparison = (expr) => expr.kind === "literal" &&
+    (typeof expr.value === "boolean" ||
+        typeof expr.value === "string" ||
+        typeof expr.value === "number");
+const buildMethodInvocation = (receiver, memberName) => ({
+    kind: "invocationExpression",
+    expression: {
+        kind: "memberAccessExpression",
+        expression: receiver,
+        memberName,
+    },
+    arguments: [],
+});
+const buildAnd = (left, right) => ({
+    kind: "binaryExpression",
+    operatorToken: "&&",
+    left,
+    right,
+});
+const buildEquality = (left, right) => ({
+    kind: "binaryExpression",
+    operatorToken: "==",
+    left,
+    right,
+});
+const buildUnionLiteralEquality = (opts) => {
+    const { carrierAst, carrierType, memberIndex, literalAst, context } = opts;
+    const [layout, layoutContext] = buildRuntimeUnionLayout(carrierType, context, emitRuntimeTypeAst);
+    if (!layout) {
+        return undefined;
+    }
+    const runtimeCarrierTypeAst = buildRuntimeUnionTypeAst(layout);
+    const nextId = (layoutContext.tempVarId ?? 0) + 1;
+    const tempName = `__tsonic_union_compare_${nextId}`;
+    const capturedCarrier = {
+        kind: "isExpression",
+        expression: carrierAst,
+        pattern: {
+            kind: "declarationPattern",
+            type: runtimeCarrierTypeAst,
+            designation: tempName,
+        },
+    };
+    const capturedIdentifier = identifierExpression(tempName);
+    const memberCheck = buildMethodInvocation(capturedIdentifier, `Is${memberIndex + 1}`);
+    const memberValue = buildMethodInvocation(capturedIdentifier, `As${memberIndex + 1}`);
+    return [
+        buildAnd(buildAnd(capturedCarrier, memberCheck), buildEquality(memberValue, literalAst)),
+        {
+            ...layoutContext,
+            tempVarId: nextId,
+        },
+    ];
+};
+const emitRuntimeTypeAst = (type, context) => emitTypeAst(type, context);
+export const emitRuntimeUnionLiteralComparison = (expr, context) => {
+    if (expr.operator !== "===" &&
+        expr.operator !== "!==" &&
+        expr.operator !== "==" &&
+        expr.operator !== "!=") {
+        return undefined;
+    }
+    const leftLiteral = isSupportedLiteralComparison(expr.left)
+        ? expr.left
+        : undefined;
+    const rightLiteral = isSupportedLiteralComparison(expr.right)
+        ? expr.right
+        : undefined;
+    const candidate = leftLiteral && !rightLiteral
+        ? { unionExpr: expr.right, literalExpr: leftLiteral }
+        : rightLiteral && !leftLiteral
+            ? { unionExpr: expr.left, literalExpr: rightLiteral }
+            : undefined;
+    if (!candidate) {
+        return undefined;
+    }
+    const unionExprType = resolveComparisonOperandType(candidate.unionExpr, context);
+    if (!unionExprType) {
+        return undefined;
+    }
+    const runtimeCarrierSourceType = stripNullish(unionExprType);
+    if (!willCarryAsRuntimeUnion(runtimeCarrierSourceType, context)) {
+        return undefined;
+    }
+    const literalType = widenLiteralComparisonType(resolveComparisonOperandType(candidate.literalExpr, context) ??
+        candidate.literalExpr.inferredType);
+    if (!literalType ||
+        willCarryAsRuntimeUnion(stripNullish(literalType), context)) {
+        return undefined;
+    }
+    const unionTarget = getTransparentComparisonTarget(candidate.unionExpr);
+    const [unionAst, unionContext] = emitExpressionAst(unionTarget, context);
+    const directStorageType = unionTarget.kind === "identifier"
+        ? resolveIdentifierRuntimeCarrierType(unionTarget, unionContext)
+        : resolveDirectStorageExpressionType(unionTarget, unionAst, unionContext);
+    const runtimeCarrierType = directStorageType &&
+        willCarryAsRuntimeUnion(stripNullish(directStorageType), unionContext)
+        ? stripNullish(directStorageType)
+        : runtimeCarrierSourceType;
+    const runtimeCarrierAst = (directStorageType
+        ? resolveRuntimeCarrierExpressionAst(unionTarget, unionContext)
+        : undefined) ?? unionAst;
+    const [layout, layoutContext] = buildRuntimeUnionLayout(runtimeCarrierType, unionContext, emitRuntimeTypeAst);
+    if (!layout) {
+        return undefined;
+    }
+    const matchingMemberIndices = findRuntimeUnionMemberIndices(layout.members, literalType, layoutContext);
+    if (matchingMemberIndices.length !== 1) {
+        return undefined;
+    }
+    const memberIndex = matchingMemberIndices[0];
+    if (memberIndex === undefined) {
+        return undefined;
+    }
+    const [literalAst, literalContext] = emitExpressionAst(candidate.literalExpr, layoutContext, literalType);
+    const equalityResult = buildUnionLiteralEquality({
+        carrierAst: runtimeCarrierAst,
+        carrierType: runtimeCarrierType,
+        memberIndex,
+        literalAst,
+        context: literalContext,
+    });
+    if (!equalityResult) {
+        return undefined;
+    }
+    const [equalityAst, equalityContext] = equalityResult;
+    const isNegated = expr.operator === "!==" || expr.operator === "!=";
+    return [
+        isNegated
+            ? {
+                kind: "prefixUnaryExpression",
+                operatorToken: "!",
+                operand: {
+                    kind: "parenthesizedExpression",
+                    expression: equalityAst,
+                },
+            }
+            : equalityAst,
+        equalityContext,
+    ];
+};
+//# sourceMappingURL=binary-runtime-union-comparison.js.map

package/dist/expressions/operators/binary-runtime-union-comparison.js.map

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

package/dist/expressions/operators/binary-special-ops.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Binary operator special-case handlers — `in` operator and `instanceof`.
+ *
+ * Extracted from binary-dispatch.ts to keep the main dispatcher under 500 LOC.
+ * These handlers are called early in emitBinary before the generic binary path.
+ */
+import { IrExpression } from "@tsonic/frontend";
+import { EmitterContext } from "../../types.js";
+import type { CSharpExpressionAst } from "../../core/format/backend-ast/types.js";
+/**
+ * Emit a direct `typeof value === "tag"` comparison against a runtime-union
+ * carrier as `value.IsN()` member checks.
+ */
+export declare const emitTypeofComparison: (expr: Extract<IrExpression, {
+    kind: "binary";
+}>, context: EmitterContext) => [CSharpExpressionAst, EmitterContext] | undefined;
+/**
+ * Emit a `"prop" in x` expression — union narrowing or dictionary membership.
+ */
+export declare const emitInOperator: (expr: Extract<IrExpression, {
+    kind: "binary";
+}>, context: EmitterContext) => [CSharpExpressionAst, EmitterContext];
+/**
+ * Emit an `instanceof` expression as a C# `is` pattern expression.
+ */
+export declare const emitInstanceof: (expr: Extract<IrExpression, {
+    kind: "binary";
+}>, context: EmitterContext) => [CSharpExpressionAst, EmitterContext];
+//# sourceMappingURL=binary-special-ops.d.ts.map

package/dist/expressions/operators/binary-special-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-special-ops.d.ts","sourceRoot":"","sources":["../../../src/expressions/operators/binary-special-ops.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAU,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAqChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAmOlF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAC/B,MAAM,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,EAC/C,SAAS,cAAc,KACtB,CAAC,mBAAmB,EAAE,cAAc,CAAC,GAAG,SA6F1C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,EAC/C,SAAS,cAAc,KACtB,CAAC,mBAAmB,EAAE,cAAc,CA+LtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,EAC/C,SAAS,cAAc,KACtB,CAAC,mBAAmB,EAAE,cAAc,CA8LtC,CAAC"}

package/dist/expressions/operators/binary-special-ops.js

@@ -0,0 +1,468 @@
+/**
+ * Binary operator special-case handlers — `in` operator and `instanceof`.
+ *
+ * Extracted from binary-dispatch.ts to keep the main dispatcher under 500 LOC.
+ * These handlers are called early in emitBinary before the generic binary path.
+ */
+import { emitExpressionAst } from "../../expression-emitter.js";
+import { emitTypeAst } from "../../type-emitter.js";
+import { resolveTypeAlias, stripNullish, hasDeterministicPropertyMembership, matchesTypeofTag, } from "../../core/semantic/type-resolution.js";
+import { findExactRuntimeUnionMemberIndices, findRuntimeUnionMemberIndices, findRuntimeUnionInstanceofMemberIndices, } from "../../core/semantic/runtime-union-matching.js";
+import { willCarryAsRuntimeUnion } from "../../core/semantic/union-semantics.js";
+import { isBroadValueCarrierType } from "../../core/semantic/broad-array-storage.js";
+import { normalizeInstanceofTargetType } from "../../core/semantic/instanceof-targets.js";
+import { buildRuntimeUnionLayout, getCanonicalRuntimeUnionMembers, } from "../../core/semantic/runtime-unions.js";
+import { unwrapTransparentNarrowingTarget } from "../../core/semantic/transparent-expressions.js";
+import { getMemberAccessNarrowKey } from "../../core/semantic/narrowing-keys.js";
+import { currentNarrowedType } from "../../core/semantic/narrowing-builders.js";
+import { resolveAlignedRuntimeUnionMembers } from "../../core/semantic/narrowed-union-resolution.js";
+import { resolveIdentifierRuntimeCarrierType, resolveRuntimeCarrierExpressionAst, resolveRuntimeCarrierIrType, resolveDirectStorageExpressionType, } from "../direct-storage-types.js";
+import { booleanLiteral, identifierType, nullLiteral, } from "../../core/format/backend-ast/builders.js";
+import { extractCalleeNameFromAst } from "../../core/format/backend-ast/utils.js";
+import { describeIrTypeForDiagnostics } from "../../core/semantic/deterministic-type-keys.js";
+const buildRuntimeUnionMemberOrChain = (receiver, memberNs) => {
+    if (memberNs.length === 0) {
+        return booleanLiteral(false);
+    }
+    const checks = memberNs.map((memberN) => ({
+        kind: "invocationExpression",
+        expression: {
+            kind: "memberAccessExpression",
+            expression: receiver,
+            memberName: `Is${memberN}`,
+        },
+        arguments: [],
+    }));
+    const combined = checks.reduce((current, check) => current
+        ? {
+            kind: "parenthesizedExpression",
+            expression: {
+                kind: "binaryExpression",
+                operatorToken: "||",
+                left: current,
+                right: check,
+            },
+        }
+        : check, undefined);
+    return combined ?? booleanLiteral(false);
+};
+const formatIrTypeForDiagnostic = (type, context) => {
+    if (!type) {
+        return "<missing-type>";
+    }
+    return describeIrTypeForDiagnostics(resolveTypeAlias(stripNullish(type), context), context);
+};
+const buildRuntimeUnionMemberCheck = (opts) => {
+    const { receiver, memberNs, negate, context } = opts;
+    if (memberNs.length === 0) {
+        return [booleanLiteral(negate), context];
+    }
+    const guardedCheck = {
+        kind: "binaryExpression",
+        operatorToken: "&&",
+        left: {
+            kind: "binaryExpression",
+            operatorToken: "!=",
+            left: {
+                kind: "parenthesizedExpression",
+                expression: {
+                    kind: "castExpression",
+                    type: identifierType("global::System.Object"),
+                    expression: {
+                        kind: "parenthesizedExpression",
+                        expression: receiver,
+                    },
+                },
+            },
+            right: nullLiteral(),
+        },
+        right: buildRuntimeUnionMemberOrChain(receiver, memberNs),
+    };
+    return [
+        negate
+            ? {
+                kind: "prefixUnaryExpression",
+                operatorToken: "!",
+                operand: {
+                    kind: "parenthesizedExpression",
+                    expression: guardedCheck,
+                },
+            }
+            : guardedCheck,
+        context,
+    ];
+};
+const tryExtractRuntimeUnionMemberProjection = (ast) => {
+    let current = ast;
+    while (current.kind === "parenthesizedExpression" ||
+        current.kind === "castExpression" ||
+        current.kind === "asExpression") {
+        current = current.expression;
+    }
+    if (current.kind !== "invocationExpression" ||
+        current.arguments.length !== 0 ||
+        current.expression.kind !== "memberAccessExpression") {
+        return undefined;
+    }
+    const memberMatch = /^As([1-9][0-9]*)$/.exec(current.expression.memberName);
+    if (!memberMatch) {
+        return undefined;
+    }
+    const memberN = Number(memberMatch[1]);
+    return Number.isInteger(memberN)
+        ? {
+            receiver: current.expression.expression,
+            memberN,
+        }
+        : undefined;
+};
+const runtimeUnionMemberMatchesInstanceofTarget = (member, targetType, context) => !!member &&
+    !!targetType &&
+    (findExactRuntimeUnionMemberIndices([member], targetType, context).length >
+        0 ||
+        findRuntimeUnionMemberIndices([member], targetType, context).length > 0 ||
+        findRuntimeUnionInstanceofMemberIndices([member], targetType, context)
+            .length > 0);
+const getRuntimeUnionCarrierMembers = (candidate, context) => {
+    if (!candidate) {
+        return undefined;
+    }
+    return (getCanonicalRuntimeUnionMembers(candidate, context) ??
+        buildRuntimeUnionLayout(candidate, context, emitTypeAst)[0]?.members);
+};
+const selectRuntimeUnionCarrierType = (context, ...candidates) => candidates.find((candidate) => candidate !== undefined &&
+    getRuntimeUnionCarrierMembers(candidate, context) !== undefined);
+const tryExtractTypeofComparison = (expr) => {
+    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 (right.kind !== "literal" || typeof right.value !== "string") {
+            return undefined;
+        }
+        return {
+            operand: left.expression,
+            tag: right.value,
+        };
+    };
+    const direct = extract(expr.left, expr.right) ?? extract(expr.right, expr.left);
+    if (!direct) {
+        return undefined;
+    }
+    return {
+        ...direct,
+        negate: expr.operator === "!==" || expr.operator === "!=",
+    };
+};
+/**
+ * Emit a direct `typeof value === "tag"` comparison against a runtime-union
+ * carrier as `value.IsN()` member checks.
+ */
+export const emitTypeofComparison = (expr, context) => {
+    const directGuard = tryExtractTypeofComparison(expr);
+    if (!directGuard) {
+        return undefined;
+    }
+    const operandType = directGuard.operand.inferredType;
+    if (!operandType) {
+        return undefined;
+    }
+    const target = unwrapTransparentNarrowingTarget(directGuard.operand);
+    if (target?.kind === "memberAccess" && target.isOptional) {
+        return undefined;
+    }
+    const bindingKey = target?.kind === "identifier"
+        ? target.name
+        : target
+            ? getMemberAccessNarrowKey(target)
+            : undefined;
+    const effectiveType = (bindingKey
+        ? currentNarrowedType(bindingKey, target?.inferredType ?? operandType, context)
+        : undefined) ?? operandType;
+    if (isBroadValueCarrierType(effectiveType, context) ||
+        isBroadValueCarrierType(target?.inferredType, context)) {
+        return undefined;
+    }
+    const [operandAst, operandContext] = emitExpressionAst(target ?? directGuard.operand, context);
+    const directStorageType = resolveRuntimeCarrierIrType(target ?? directGuard.operand, operandContext) ??
+        (target?.kind === "identifier"
+            ? resolveIdentifierRuntimeCarrierType(target, operandContext)
+            : resolveDirectStorageExpressionType(target ?? directGuard.operand, operandAst, operandContext));
+    const runtimeCarrierAst = (directStorageType
+        ? resolveRuntimeCarrierExpressionAst(target ?? directGuard.operand, operandContext)
+        : undefined) ?? operandAst;
+    if (isBroadValueCarrierType(directStorageType, operandContext)) {
+        return undefined;
+    }
+    const carriesRuntimeUnion = directStorageType
+        ? willCarryAsRuntimeUnion(directStorageType, operandContext)
+        : willCarryAsRuntimeUnion(effectiveType, operandContext);
+    if (!carriesRuntimeUnion) {
+        return undefined;
+    }
+    const alignedCarrierMembers = resolveAlignedRuntimeUnionMembers(bindingKey, effectiveType, directStorageType, operandContext);
+    if (!alignedCarrierMembers) {
+        return undefined;
+    }
+    const { members: effectiveMembers, candidateMemberNs } = alignedCarrierMembers;
+    const matchingMemberNs = effectiveMembers.flatMap((member, index) => member && matchesTypeofTag(member, directGuard.tag, operandContext)
+        ? [candidateMemberNs[index] ?? index + 1]
+        : []);
+    return buildRuntimeUnionMemberCheck({
+        receiver: runtimeCarrierAst,
+        memberNs: matchingMemberNs,
+        negate: directGuard.negate,
+        context: operandContext,
+    });
+};
+/**
+ * Emit a `"prop" in x` expression — union narrowing or dictionary membership.
+ */
+export const emitInOperator = (expr, context) => {
+    // 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 target = unwrapTransparentNarrowingTarget(expr.right);
+    if (target?.kind === "memberAccess" && target.isOptional) {
+        throw new Error("ICE: Unsupported `in` operator on optional member access target.");
+    }
+    const bindingKey = target?.kind === "identifier"
+        ? target.name
+        : target
+            ? getMemberAccessNarrowKey(target)
+            : undefined;
+    const effectiveType = (bindingKey
+        ? currentNarrowedType(bindingKey, target?.inferredType ?? rhsType, context)
+        : undefined) ?? rhsType;
+    const [rhsAst, rhsCtx] = emitExpressionAst(target ?? expr.right, context);
+    const resolvedRhs = resolveTypeAlias(stripNullish(rhsType), rhsCtx);
+    const resolvedEffectiveType = resolveTypeAlias(stripNullish(effectiveType), rhsCtx);
+    const singleEffectiveMember = resolvedEffectiveType.kind === "unionType"
+        ? resolvedEffectiveType.types.length === 1
+            ? resolvedEffectiveType.types[0]
+            : undefined
+        : resolvedEffectiveType;
+    const propName = expr.left.value;
+    if (singleEffectiveMember) {
+        const hasMember = hasDeterministicPropertyMembership(singleEffectiveMember, propName, rhsCtx);
+        if (hasMember === true) {
+            return [booleanLiteral(true), rhsCtx];
+        }
+        if (hasMember === false) {
+            return [booleanLiteral(false), rhsCtx];
+        }
+    }
+    const directStorageType = resolveRuntimeCarrierIrType(target ?? expr.right, rhsCtx) ??
+        (target?.kind === "identifier"
+            ? resolveIdentifierRuntimeCarrierType(target, rhsCtx)
+            : resolveDirectStorageExpressionType(target ?? expr.right, rhsAst, rhsCtx));
+    const runtimeCarrierAst = (directStorageType
+        ? resolveRuntimeCarrierExpressionAst(target ?? expr.right, rhsCtx)
+        : undefined) ?? rhsAst;
+    const alignedCarrierMembers = !isBroadValueCarrierType(effectiveType, rhsCtx) &&
+        !isBroadValueCarrierType(directStorageType, rhsCtx)
+        ? resolveAlignedRuntimeUnionMembers(bindingKey, effectiveType, directStorageType, rhsCtx)
+        : undefined;
+    // Union<T1..Tn>: `"error" in auth` -> auth.IsN() (where member N has the prop)
+    if (alignedCarrierMembers) {
+        const { members: runtimeMembers, candidateMemberNs } = alignedCarrierMembers;
+        const matchingMembers = [];
+        const unresolvedMembers = [];
+        for (let i = 0; i < runtimeMembers.length; i += 1) {
+            const member = runtimeMembers[i];
+            if (!member)
+                continue;
+            const hasMember = hasDeterministicPropertyMembership(member, propName, rhsCtx);
+            if (hasMember === true) {
+                matchingMembers.push(candidateMemberNs[i] ?? i + 1);
+                continue;
+            }
+            if (hasMember === undefined) {
+                unresolvedMembers.push(formatIrTypeForDiagnostic(member, rhsCtx));
+            }
+        }
+        if (unresolvedMembers.length > 0) {
+            throw new Error("ICE: Unable to deterministically resolve `in`-operator membership for one or more union members. " +
+                `Property: '${propName}'. Members: ${unresolvedMembers.join(", ")}`);
+        }
+        if (matchingMembers.length === 0) {
+            return [booleanLiteral(false), rhsCtx];
+        }
+        // Build IsN() call ASTs and chain with ||
+        const checkAsts = matchingMembers.map((n) => ({
+            kind: "invocationExpression",
+            expression: {
+                kind: "memberAccessExpression",
+                expression: runtimeCarrierAst,
+                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];
+    }
+    const deterministicMembership = hasDeterministicPropertyMembership(rhsType, expr.left.value, rhsCtx);
+    if (deterministicMembership !== undefined) {
+        return [booleanLiteral(deterministicMembership), rhsCtx];
+    }
+    throw new Error("ICE: Unsupported `in` operator. Only union shape guards and Dictionary<string, T> membership are supported.");
+};
+/**
+ * Emit an `instanceof` expression as a C# `is` pattern expression.
+ */
+export const emitInstanceof = (expr, context) => {
+    const normalizedTargetType = normalizeInstanceofTargetType(expr.right.inferredType);
+    const leftOperandType = expr.left.inferredType;
+    const target = unwrapTransparentNarrowingTarget(expr.left);
+    const bindingKey = target?.kind === "identifier"
+        ? target.name
+        : target
+            ? getMemberAccessNarrowKey(target)
+            : undefined;
+    const effectiveLeftType = (bindingKey && leftOperandType
+        ? currentNarrowedType(bindingKey, target?.inferredType ?? leftOperandType, context)
+        : undefined) ?? leftOperandType;
+    const [leftAst, leftContext] = emitExpressionAst(target ?? expr.left, context);
+    const directStorageType = target?.kind === "identifier"
+        ? resolveIdentifierRuntimeCarrierType(target, leftContext)
+        : resolveDirectStorageExpressionType(target ?? expr.left, leftAst, leftContext);
+    const identifierStorageType = target?.kind === "identifier"
+        ? leftContext.localValueTypes?.get(target.name)
+        : undefined;
+    const identifierSemanticType = target?.kind === "identifier"
+        ? leftContext.localSemanticTypes?.get(target.name)
+        : undefined;
+    const runtimeCarrierType = selectRuntimeUnionCarrierType(leftContext, identifierStorageType, identifierSemanticType, directStorageType, resolveRuntimeCarrierIrType(target ?? expr.left, leftContext), leftOperandType) ??
+        directStorageType ??
+        resolveRuntimeCarrierIrType(target ?? expr.left, leftContext);
+    const runtimeCarrierAst = (runtimeCarrierType
+        ? resolveRuntimeCarrierExpressionAst(target ?? expr.left, leftContext)
+        : undefined) ?? leftAst;
+    const alignedCarrierMembers = normalizedTargetType && effectiveLeftType
+        ? resolveAlignedRuntimeUnionMembers(bindingKey, effectiveLeftType, runtimeCarrierType, leftContext)
+        : undefined;
+    if (normalizedTargetType && alignedCarrierMembers) {
+        const { members: effectiveMembers, candidateMemberNs } = alignedCarrierMembers;
+        const matchingMemberNs = effectiveMembers.flatMap((member, index) => {
+            if (!member) {
+                return [];
+            }
+            const exactMatches = findExactRuntimeUnionMemberIndices([member], normalizedTargetType, leftContext);
+            if (exactMatches.length > 0) {
+                return [candidateMemberNs[index] ?? index + 1];
+            }
+            const semanticMatches = findRuntimeUnionMemberIndices([member], normalizedTargetType, leftContext);
+            const instanceofMatches = findRuntimeUnionInstanceofMemberIndices([member], normalizedTargetType, leftContext);
+            return semanticMatches.length > 0
+                ? [candidateMemberNs[index] ?? index + 1]
+                : instanceofMatches.length > 0
+                    ? [candidateMemberNs[index] ?? index + 1]
+                    : [];
+        });
+        if (matchingMemberNs.length > 0) {
+            return buildRuntimeUnionMemberCheck({
+                receiver: runtimeCarrierAst,
+                memberNs: matchingMemberNs,
+                negate: false,
+                context: leftContext,
+            });
+        }
+    }
+    if (normalizedTargetType && runtimeCarrierType) {
+        const hasActiveNarrowing = bindingKey !== undefined && leftContext.narrowedBindings?.has(bindingKey);
+        if (!hasActiveNarrowing) {
+            const runtimeMembers = getRuntimeUnionCarrierMembers(runtimeCarrierType, leftContext);
+            const matchingMemberNs = runtimeMembers?.flatMap((member, index) => runtimeUnionMemberMatchesInstanceofTarget(member, normalizedTargetType, leftContext)
+                ? [index + 1]
+                : []) ?? [];
+            if (matchingMemberNs.length > 0) {
+                return buildRuntimeUnionMemberCheck({
+                    receiver: runtimeCarrierAst,
+                    memberNs: matchingMemberNs,
+                    negate: false,
+                    context: leftContext,
+                });
+            }
+        }
+        const projection = tryExtractRuntimeUnionMemberProjection(leftAst);
+        const runtimeMembers = getRuntimeUnionCarrierMembers(runtimeCarrierType, leftContext);
+        const projectedMember = projection
+            ? runtimeMembers?.[projection.memberN - 1]
+            : undefined;
+        if (projection &&
+            runtimeUnionMemberMatchesInstanceofTarget(projectedMember, normalizedTargetType, leftContext)) {
+            return buildRuntimeUnionMemberCheck({
+                receiver: projection.receiver,
+                memberNs: [projection.memberN],
+                negate: false,
+                context: leftContext,
+            });
+        }
+    }
+    let rightContext = leftContext;
+    let rightText;
+    if (normalizedTargetType) {
+        const [rightTypeAst, nextContext] = emitTypeAst(normalizedTargetType, leftContext);
+        rightText = extractCalleeNameFromAst({
+            kind: "typeReferenceExpression",
+            type: rightTypeAst,
+        });
+        rightContext = nextContext;
+    }
+    else {
+        const [rightAst, nextContext] = emitExpressionAst(expr.right, leftContext);
+        rightText = extractCalleeNameFromAst(rightAst);
+        rightContext = nextContext;
+    }
+    const isExpr = {
+        kind: "isExpression",
+        expression: leftAst,
+        pattern: {
+            kind: "typePattern",
+            type: identifierType(rightText ?? "object"),
+        },
+    };
+    return [isExpr, rightContext];
+};
+//# sourceMappingURL=binary-special-ops.js.map