@tsonic/emitter 0.0.62 → 0.0.64

package/dist/expression-emitter.js

@@ -1,19 +1,22 @@
 /**
  * Expression Emitter - IR expressions to C# code
  * Main dispatcher - delegates to specialized modules
+ *
+ * Primary entry point is emitExpressionAst which returns [CSharpExpressionAst, EmitterContext].
  */
-import { emitType } from "./type-emitter.js";
-import { substituteTypeArgs } from "./core/type-resolution.js";
+import { emitTypeAst } from "./type-emitter.js";
+import { substituteTypeArgs, resolveTypeAlias, stripNullish, } from "./core/semantic/type-resolution.js";
+import { renderTypeAst } from "./core/format/backend-ast/utils.js";
 // Import expression emitters from specialized modules
 import { emitLiteral } from "./expressions/literals.js";
 import { emitIdentifier } from "./expressions/identifiers.js";
 import { emitArray, emitObject } from "./expressions/collections.js";
 import { emitMemberAccess } from "./expressions/access.js";
-import { emitCall, emitNew } from "./expressions/calls.js";
+import { emitCall } from "./expressions/calls/call-emitter.js";
+import { emitNew } from "./expressions/calls/new-emitter.js";
 import { emitBinary, emitLogical, emitUnary, emitUpdate, emitAssignment, emitConditional, } from "./expressions/operators.js";
 import { emitFunctionExpression, emitArrowFunction, } from "./expressions/functions.js";
 import { emitTemplateLiteral, emitSpread, emitAwait, } from "./expressions/other.js";
-import { formatCastOperandText } from "./expressions/parentheses.js";
 const getBareTypeParameterName = (type, context) => {
     if (type.kind === "typeParameterType")
         return type.name;
@@ -40,21 +43,28 @@ const getUnconstrainedNullishTypeParamName = (type, context) => {
     const constraintKind = context.typeParamConstraints?.get(typeParamName) ?? "unconstrained";
     return constraintKind === "unconstrained" ? typeParamName : undefined;
 };
-const maybeCastNullishTypeParam = (expr, fragment, context, expectedType) => {
+const maybeCastNullishTypeParamAst = (expr, ast, context, expectedType) => {
     if (!expectedType)
-        return [fragment, context];
+        return [ast, context];
     if (!expr.inferredType)
-        return [fragment, context];
+        return [ast, context];
     const expectedTypeParam = getBareTypeParameterName(expectedType, context);
     if (!expectedTypeParam)
-        return [fragment, context];
+        return [ast, context];
     const unionTypeParam = getUnconstrainedNullishTypeParamName(expr.inferredType, context);
     if (!unionTypeParam)
-        return [fragment, context];
+        return [ast, context];
     if (unionTypeParam !== expectedTypeParam)
-        return [fragment, context];
-    const [typeName, newContext] = emitType(expectedType, context);
-    return [{ text: `(${typeName})${fragment.text}` }, newContext];
+        return [ast, context];
+    const [typeAst, newContext] = emitTypeAst(expectedType, context);
+    return [
+        {
+            kind: "castExpression",
+            type: typeAst,
+            expression: ast,
+        },
+        newContext,
+    ];
 };
 const getNullableUnionBaseType = (type) => {
     if (type.kind !== "unionType")
@@ -73,8 +83,6 @@ const isNonNullableValueType = (type) => {
             type.name === "char");
     }
     if (type.kind === "referenceType") {
-        // C# primitive aliases represented as reference types via @tsonic/core.
-        // Keep this list strict — we only unwrap when `.Value` exists.
         return (type.name === "sbyte" ||
             type.name === "short" ||
             type.name === "int" ||
@@ -103,23 +111,20 @@ const isSameTypeForNullableUnwrap = (base, expected) => {
         return base.name === expected.name;
     }
     if (base.kind === "referenceType" && expected.kind === "referenceType") {
-        // This unwrap is only for Nullable<T> value types, so keep matching strict.
         return (base.name === expected.name &&
             (base.typeArguments?.length ?? 0) === 0 &&
             (expected.typeArguments?.length ?? 0) === 0);
     }
     return false;
 };
-const maybeUnwrapNullableValueType = (expr, fragment, context, expectedType) => {
+const maybeUnwrapNullableValueTypeAst = (expr, ast, context, expectedType) => {
     if (!expectedType)
-        return [fragment, context];
+        return [ast, context];
     if (!expr.inferredType)
-        return [fragment, context];
-    // Only unwrap direct nullable values. For composite expressions (e.g. `a ?? b`)
-    // C# nullish coalescing already produces a non-nullable result when the
-    // fallback is non-nullable, so adding `.Value` is incorrect.
+        return [ast, context];
+    // Only unwrap direct nullable values.
     if (expr.kind !== "identifier" && expr.kind !== "memberAccess") {
-        return [fragment, context];
+        return [ast, context];
     }
     const getMemberAccessNarrowKey = (m) => {
         if (m.isComputed)
@@ -135,8 +140,6 @@ const maybeUnwrapNullableValueType = (expr, fragment, context, expectedType) =>
         }
         return undefined;
     };
-    // If a narrowing pass already rewrote this identifier (e.g., `id` → `id.Value`
-    // or `id` → `id__n`), don't apply a second Nullable<T> unwrap.
     if (context.narrowedBindings &&
         ((expr.kind === "identifier" && context.narrowedBindings.has(expr.name)) ||
             (expr.kind === "memberAccess" &&
@@ -144,67 +147,278 @@ const maybeUnwrapNullableValueType = (expr, fragment, context, expectedType) =>
                     const key = getMemberAccessNarrowKey(expr);
                     return key ? context.narrowedBindings.has(key) : false;
                 })()))) {
-        return [fragment, context];
+        return [ast, context];
     }
     const nullableBase = getNullableUnionBaseType(expr.inferredType);
     if (!nullableBase)
-        return [fragment, context];
-    // Only unwrap when the expected type is a non-nullable value type and
-    // the expression is a nullable union of that exact base type.
+        return [ast, context];
     if (!isNonNullableValueType(expectedType))
-        return [fragment, context];
+        return [ast, context];
     if (!isSameTypeForNullableUnwrap(nullableBase, expectedType)) {
-        return [fragment, context];
+        return [ast, context];
     }
-    const needsParens = expr.kind !== "identifier" && expr.kind !== "memberAccess";
-    const inner = needsParens ? `(${fragment.text})` : fragment.text;
-    return [{ text: `${inner}.Value` }, context];
+    // Append .Value
+    return [
+        {
+            kind: "memberAccessExpression",
+            expression: ast,
+            memberName: "Value",
+        },
+        context,
+    ];
+};
+const normalizeComparableType = (type, context) => resolveTypeAlias(stripNullish(type), context);
+const areIrTypesEquivalent = (left, right, context) => {
+    const a = normalizeComparableType(left, context);
+    const b = normalizeComparableType(right, context);
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case "primitiveType":
+            return a.name === b.name;
+        case "literalType":
+            return a.value === b.value;
+        case "referenceType": {
+            const rb = b;
+            if (a.name !== rb.name)
+                return false;
+            const aArgs = a.typeArguments ?? [];
+            const bArgs = rb.typeArguments ?? [];
+            if (aArgs.length !== bArgs.length)
+                return false;
+            for (let i = 0; i < aArgs.length; i++) {
+                const aa = aArgs[i];
+                const bb = bArgs[i];
+                if (!aa || !bb || !areIrTypesEquivalent(aa, bb, context))
+                    return false;
+            }
+            return true;
+        }
+        case "arrayType":
+            return areIrTypesEquivalent(a.elementType, b.elementType, context);
+        case "dictionaryType":
+            return (areIrTypesEquivalent(a.keyType, b.keyType, context) &&
+                areIrTypesEquivalent(a.valueType, b.valueType, context));
+        case "tupleType": {
+            const rb = b;
+            if (a.elementTypes.length !== rb.elementTypes.length)
+                return false;
+            for (let i = 0; i < a.elementTypes.length; i++) {
+                const ae = a.elementTypes[i];
+                const be = rb.elementTypes[i];
+                if (!ae || !be || !areIrTypesEquivalent(ae, be, context))
+                    return false;
+            }
+            return true;
+        }
+        case "functionType": {
+            const rb = b;
+            if (a.parameters.length !== rb.parameters.length)
+                return false;
+            for (let i = 0; i < a.parameters.length; i++) {
+                const ap = a.parameters[i];
+                const bp = rb.parameters[i];
+                if (!ap || !bp)
+                    return false;
+                if (!ap.type && !bp.type)
+                    continue;
+                if (!ap.type || !bp.type)
+                    return false;
+                if (!areIrTypesEquivalent(ap.type, bp.type, context))
+                    return false;
+            }
+            return areIrTypesEquivalent(a.returnType, rb.returnType, context);
+        }
+        case "unionType":
+        case "intersectionType": {
+            const rb = b;
+            if (a.types.length !== rb.types.length)
+                return false;
+            const used = new Set();
+            for (const at of a.types) {
+                if (!at)
+                    return false;
+                let matched = false;
+                for (let i = 0; i < rb.types.length; i++) {
+                    if (used.has(i))
+                        continue;
+                    const bt = rb.types[i];
+                    if (!bt)
+                        continue;
+                    if (areIrTypesEquivalent(at, bt, context)) {
+                        used.add(i);
+                        matched = true;
+                        break;
+                    }
+                }
+                if (!matched)
+                    return false;
+            }
+            return true;
+        }
+        case "typeParameterType":
+            return a.name === b.name;
+        case "voidType":
+        case "anyType":
+        case "unknownType":
+        case "neverType":
+            return true;
+        case "objectType": {
+            const rb = b;
+            if (a.members.length !== rb.members.length)
+                return false;
+            for (let i = 0; i < a.members.length; i++) {
+                const am = a.members[i];
+                const bm = rb.members[i];
+                if (!am || !bm || am.kind !== bm.kind)
+                    return false;
+                if (am.kind === "propertySignature" &&
+                    bm.kind === "propertySignature") {
+                    if (am.name !== bm.name)
+                        return false;
+                    if (!areIrTypesEquivalent(am.type, bm.type, context))
+                        return false;
+                    continue;
+                }
+                if (am.kind === "methodSignature" && bm.kind === "methodSignature") {
+                    if (am.name !== bm.name)
+                        return false;
+                    if (am.parameters.length !== bm.parameters.length)
+                        return false;
+                    for (let j = 0; j < am.parameters.length; j++) {
+                        const ap = am.parameters[j];
+                        const bp = bm.parameters[j];
+                        if (!ap || !bp)
+                            return false;
+                        if (!ap.type || !bp.type)
+                            return false;
+                        if (!areIrTypesEquivalent(ap.type, bp.type, context))
+                            return false;
+                    }
+                    if (!am.returnType || !bm.returnType)
+                        return false;
+                    if (!areIrTypesEquivalent(am.returnType, bm.returnType, context))
+                        return false;
+                    continue;
+                }
+                return false;
+            }
+            return true;
+        }
+    }
+};
+const maybeUpcastDictionaryUnionValueAst = (expr, ast, context, expectedType) => {
+    if (!expectedType || !expr.inferredType)
+        return [ast, context];
+    const expected = normalizeComparableType(expectedType, context);
+    const actual = normalizeComparableType(expr.inferredType, context);
+    if (expected.kind !== "dictionaryType" || actual.kind !== "dictionaryType") {
+        return [ast, context];
+    }
+    if (!areIrTypesEquivalent(expected.keyType, actual.keyType, context)) {
+        return [ast, context];
+    }
+    const expectedValue = normalizeComparableType(expected.valueType, context);
+    if (expectedValue.kind !== "unionType")
+        return [ast, context];
+    const actualValue = normalizeComparableType(actual.valueType, context);
+    if (areIrTypesEquivalent(expectedValue, actualValue, context)) {
+        return [ast, context];
+    }
+    let matchingMemberIndex = -1;
+    for (let i = 0; i < expectedValue.types.length; i++) {
+        const member = expectedValue.types[i];
+        if (!member)
+            continue;
+        if (areIrTypesEquivalent(member, actualValue, context)) {
+            matchingMemberIndex = i + 1;
+            break;
+        }
+    }
+    if (matchingMemberIndex === -1)
+        return [ast, context];
+    const [unionValueTypeAst, ctx1] = emitTypeAst(expected.valueType, context);
+    const unionTypeText = renderTypeAst(unionValueTypeAst);
+    const kvpId = "kvp";
+    const keySelector = {
+        kind: "lambdaExpression",
+        isAsync: false,
+        parameters: [{ name: kvpId }],
+        body: {
+            kind: "memberAccessExpression",
+            expression: { kind: "identifierExpression", identifier: kvpId },
+            memberName: "Key",
+        },
+    };
+    const valueSelector = {
+        kind: "lambdaExpression",
+        isAsync: false,
+        parameters: [{ name: kvpId }],
+        body: {
+            kind: "invocationExpression",
+            expression: {
+                kind: "memberAccessExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: unionTypeText,
+                },
+                memberName: `From${matchingMemberIndex}`,
+            },
+            arguments: [
+                {
+                    kind: "memberAccessExpression",
+                    expression: { kind: "identifierExpression", identifier: kvpId },
+                    memberName: "Value",
+                },
+            ],
+        },
+    };
+    const converted = {
+        kind: "invocationExpression",
+        expression: {
+            kind: "memberAccessExpression",
+            expression: {
+                kind: "identifierExpression",
+                identifier: "global::System.Linq.Enumerable",
+            },
+            memberName: "ToDictionary",
+        },
+        arguments: [ast, keySelector, valueSelector],
+    };
+    return [converted, ctx1];
 };
 /**
- * Emit a numeric narrowing expression.
- *
- * If the inner expression is already proven to produce the target type,
- * emit it directly without a cast. Otherwise, emit with an explicit cast.
- *
- * Key cases:
- * - Literal 10 as int → "10" (no cast, no .0)
- * - Variable x as int (where x is already int) → "x" (no cast)
- * - Expression (x + y) as int (where result is int) → "x + y" (no cast)
+ * Emit a numeric narrowing expression as CSharpExpressionAst.
  */
 const emitNumericNarrowing = (expr, context) => {
-    // If we have a proof that the inner expression already produces the target type,
-    // we don't need a cast - just emit the inner expression
     if (expr.proof !== undefined) {
-        // For literals, pass the target type so they emit without decimal point
         if (expr.proof.source.type === "literal") {
-            const [innerCode, newContext] = emitExpression(expr.expression, context, expr.inferredType // Pass target type for correct literal format
-            );
-            return [innerCode, newContext];
+            const [innerAst, newContext] = emitExpressionAst(expr.expression, context, expr.inferredType);
+            return [innerAst, newContext];
         }
-        // Numeric narrowings represent explicit user intent (`x as int`, `x as long`).
-        // Even when the conversion is proven sound, C# generic inference can become
-        // ambiguous without an explicit cast (e.g., choosing between `int` and `long`).
-        const [innerCode, ctx1] = emitExpression(expr.expression, context);
-        const [typeName, ctx2] = emitType(expr.inferredType, ctx1);
-        const operandText = formatCastOperandText(expr.expression, innerCode.text);
-        return [{ text: `(${typeName})${operandText}` }, ctx2];
+        const [innerAst, ctx1] = emitExpressionAst(expr.expression, context);
+        const [typeAst, ctx2] = emitTypeAst(expr.inferredType, ctx1);
+        return [
+            {
+                kind: "castExpression",
+                type: typeAst,
+                expression: innerAst,
+            },
+            ctx2,
+        ];
     }
-    // HARD GATE: No proof means the proof pass failed to catch an unprovable narrowing.
-    // This is an internal compiler error - the proof pass should have aborted compilation.
-    // We must NOT silently emit a cast, as that would be a soundness violation.
     throw new Error(`Internal error: numericNarrowing without proof reached emitter. ` +
         `Target: ${expr.targetKind}, Expression kind: ${expr.expression.kind}. ` +
         `This indicates a bug in the numeric proof pass - it should have ` +
         `emitted a diagnostic and aborted compilation.`);
 };
 /**
- * Emit a type assertion expression.
+ * Emit a type assertion expression as CSharpExpressionAst.
  *
  * TypeScript `x as T` becomes C# `(T)x` (throwing cast).
- * This is a checked cast that throws InvalidCastException on failure.
  */
 const emitTypeAssertion = (expr, context) => {
-    const [innerCode, ctx1] = emitExpression(expr.expression, context, expr.targetType);
+    const [innerAst, ctx1] = emitExpressionAst(expr.expression, context, expr.targetType);
     const resolveLocalTypeAliases = (target) => {
         if (target.kind === "referenceType" && ctx1.localTypes) {
             const typeInfo = ctx1.localTypes.get(target.name);
@@ -218,15 +432,7 @@ const emitTypeAssertion = (expr, context) => {
         return target;
     };
     const shouldEraseTypeAssertion = (target) => {
-        // tsbindgen `ExtensionMethods<TShape>` is a TYPE-ONLY helper used to surface C#
-        // extension methods as instance-style members in TypeScript. It must never
-        // introduce runtime casts in emitted C# (notably for EF Core query precompilation).
-        //
-        // `x as ExtensionMethods<T>` (or a local alias that expands to it) is a no-op
-        // at runtime; preserve the original expression verbatim.
         const resolved = resolveLocalTypeAliases(target);
-        // TypeScript `as unknown` is also type-only. Casting to `object` in C# is a
-        // semantic no-op and can break analyzers that expect idiomatic syntax.
         if (resolved.kind === "unknownType") {
             return true;
         }
@@ -237,21 +443,15 @@ const emitTypeAssertion = (expr, context) => {
                 return true;
             }
         }
-        // ExtensionMethods_* aliases often normalize to an intersection that includes one
-        // or more `__Ext_*` constituents. Those `__Ext_*` types have no runtime
-        // representation, so the assertion must be erased.
         if (resolved.kind === "intersectionType") {
             return resolved.types.some((t) => t.kind === "referenceType" && t.name.startsWith("__Ext_"));
         }
         return false;
     };
     if (shouldEraseTypeAssertion(expr.targetType)) {
-        return [innerCode, ctx1];
+        return [innerAst, ctx1];
     }
     const resolveRuntimeCastTarget = (target, ctx) => {
-        // 1) Resolve local type aliases for runtime casting.
-        //    TypeScript type aliases have no runtime representation in C#, except for
-        //    object-literal aliases which we synthesize as classes (`Foo__Alias`).
         if (target.kind === "referenceType" && ctx.localTypes) {
             const typeInfo = ctx.localTypes.get(target.name);
             if (typeInfo?.kind === "typeAlias") {
@@ -261,12 +461,9 @@ const emitTypeAssertion = (expr, context) => {
                         : typeInfo.type;
                     return resolveRuntimeCastTarget(substituted, ctx);
                 }
-                // objectType aliases are emitted as `Name__Alias` by emitReferenceType
                 return target;
             }
         }
-        // 2) Erase tsbindgen extension-method wrapper types at runtime:
-        //    ExtensionMethods<TShape> is type-only; values are just TShape.
         if (target.kind === "referenceType" && target.typeArguments?.length) {
             const importBinding = ctx.importBindings?.get(target.name);
             const clrName = importBinding?.kind === "type" ? importBinding.clrName : "";
@@ -276,7 +473,6 @@ const emitTypeAssertion = (expr, context) => {
                     return resolveRuntimeCastTarget(shape, ctx);
             }
         }
-        // 3) Intersection types have no C# cast target; cast to the first runtime-like constituent.
         if (target.kind === "intersectionType") {
             for (const part of target.types) {
                 const resolved = resolveRuntimeCastTarget(part, ctx);
@@ -291,67 +487,83 @@ const emitTypeAssertion = (expr, context) => {
         return target;
     };
     const runtimeTarget = resolveRuntimeCastTarget(expr.targetType, ctx1);
-    const [typeName, ctx2] = emitType(runtimeTarget, ctx1);
-    const operandText = formatCastOperandText(expr.expression, innerCode.text);
-    return [{ text: `(${typeName})${operandText}` }, ctx2];
+    const [typeAst, ctx2] = emitTypeAst(runtimeTarget, ctx1);
+    return [
+        {
+            kind: "castExpression",
+            type: typeAst,
+            expression: innerAst,
+        },
+        ctx2,
+    ];
 };
 /**
- * Emit an asinterface expression.
- *
- * `asinterface<T>(x)` is a compile-time-only intrinsic. It must never emit a runtime
- * cast or function call. Emission relies on contextual typing in C# (typed locals,
- * parameter types, return types) to apply the interface conversion.
+ * Emit an asinterface expression as CSharpExpressionAst.
  */
 const emitAsInterface = (expr, context, expectedType) => {
     const expected = expectedType ?? expr.targetType;
-    return emitExpression(expr.expression, context, expected);
+    return emitExpressionAst(expr.expression, context, expected);
 };
 /**
- * Emit a trycast expression.
+ * Emit a trycast expression as CSharpExpressionAst.
  *
  * TypeScript `trycast<T>(x)` becomes C# `x as T` (safe cast).
- * This returns null if the cast fails instead of throwing.
  */
 const emitTryCast = (expr, context) => {
-    const [innerCode, ctx1] = emitExpression(expr.expression, context);
-    const [typeName, ctx2] = emitType(expr.targetType, ctx1);
-    const operandText = formatCastOperandText(expr.expression, innerCode.text);
-    return [{ text: `${operandText} as ${typeName}` }, ctx2];
+    const [innerAst, ctx1] = emitExpressionAst(expr.expression, context);
+    const [typeAst, ctx2] = emitTypeAst(expr.targetType, ctx1);
+    return [
+        {
+            kind: "asExpression",
+            expression: innerAst,
+            type: typeAst,
+        },
+        ctx2,
+    ];
 };
 /**
- * Emit a stackalloc expression.
- *
- * TypeScript `stackalloc<T>(n)` becomes C# `stackalloc T[n]`.
+ * Emit a stackalloc expression as CSharpExpressionAst.
  */
 const emitStackAlloc = (expr, context) => {
-    const [elementTypeName, ctx1] = emitType(expr.elementType, context);
-    const [sizeFrag, ctx2] = emitExpression(expr.size, ctx1, {
+    const [elementTypeAst, ctx1] = emitTypeAst(expr.elementType, context);
+    const [sizeAst, ctx2] = emitExpressionAst(expr.size, ctx1, {
         kind: "primitiveType",
         name: "int",
     });
-    return [{ text: `stackalloc ${elementTypeName}[${sizeFrag.text}]` }, ctx2];
+    return [
+        {
+            kind: "stackAllocArrayCreationExpression",
+            elementType: elementTypeAst,
+            sizeExpression: sizeAst,
+        },
+        ctx2,
+    ];
 };
 /**
- * Emit a defaultof expression.
- *
- * TypeScript `defaultof<T>()` becomes C# `default(T)`.
+ * Emit a defaultof expression as CSharpExpressionAst.
  */
 const emitDefaultOf = (expr, context) => {
-    const [typeName, ctx1] = emitType(expr.targetType, context);
-    return [{ text: `default(${typeName})` }, ctx1];
+    const [typeAst, ctx1] = emitTypeAst(expr.targetType, context);
+    return [
+        {
+            kind: "defaultExpression",
+            type: typeAst,
+        },
+        ctx1,
+    ];
 };
 /**
- * Emit a C# expression from an IR expression
+ * Emit a C# expression AST from an IR expression.
+ * Primary entry point for expression emission.
+ *
  * @param expr The IR expression to emit
  * @param context The emitter context
- * @param expectedType Optional expected type for contextual typing (e.g., array element type inference)
+ * @param expectedType Optional expected type for contextual typing
  */
-export const emitExpression = (expr, context, expectedType) => {
-    const [fragment, newContext] = (() => {
+export const emitExpressionAst = (expr, context, expectedType) => {
+    const [ast, newContext] = (() => {
         switch (expr.kind) {
             case "literal":
-                // Pass expectedType for null → default conversion in generic contexts
-                // Numeric literals use raw lexeme (no contextual widening under new spec)
                 return emitLiteral(expr, context, expectedType);
             case "identifier":
                 return emitIdentifier(expr, context, expectedType);
@@ -388,7 +600,10 @@ export const emitExpression = (expr, context, expectedType) => {
             case "await":
                 return emitAwait(expr, context);
             case "this":
-                return [{ text: "this" }, context];
+                return [
+                    { kind: "identifierExpression", identifier: "this" },
+                    context,
+                ];
             case "numericNarrowing":
                 return emitNumericNarrowing(expr, context);
             case "asinterface":
@@ -405,9 +620,10 @@ export const emitExpression = (expr, context, expectedType) => {
                 throw new Error(`Unhandled IR expression kind: ${String(expr.kind)}`);
         }
     })();
-    const [castedFrag, castedContext] = maybeCastNullishTypeParam(expr, fragment, newContext, expectedType);
-    return maybeUnwrapNullableValueType(expr, castedFrag, castedContext, expectedType);
+    const [castedAst, castedContext] = maybeCastNullishTypeParamAst(expr, ast, newContext, expectedType);
+    const [dictUpcastAst, dictUpcastContext] = maybeUpcastDictionaryUnionValueAst(expr, castedAst, castedContext, expectedType);
+    return maybeUnwrapNullableValueTypeAst(expr, dictUpcastAst, dictUpcastContext, expectedType);
 };
-// Re-export commonly used functions for backward compatibility
-export { emitTypeArguments, generateSpecializedName, } from "./expressions/identifiers.js";
+// Re-export commonly used functions from barrel
+export { generateSpecializedName } from "./expressions/identifiers.js";
 //# sourceMappingURL=expression-emitter.js.map