@tsonic/emitter 0.0.73 → 0.0.75

package/dist/expressions/expected-type-adaptation.js

@@ -0,0 +1,918 @@
+import { resolveEffectiveExpressionType } from "../core/semantic/narrowed-expression-types.js";
+import { tryResolveRuntimeUnionMemberType } from "../core/semantic/narrowed-expression-types.js";
+import { sameTypeAstSurface } from "../core/format/backend-ast/utils.js";
+import { matchesExpectedEmissionType, requiresValueTypeMaterialization, } from "../core/semantic/expected-type-matching.js";
+import { maybeCastNumericToExpectedIntegralAst, maybeCastNullishTypeParamAst, maybeConvertCharToStringAst, maybeBoxJsNumberAsObjectAst, maybeUnwrapNullableValueTypeAst, isNumericFactoryCreateCheckedAst, simplifyRedundantObjectBridgeCastsAst, } from "./post-emission-adaptation.js";
+import { isExactArrayCreationToType, isExactExpressionToType, tryEmitExactComparisonTargetAst, } from "./exact-comparison.js";
+import { maybeNarrowRuntimeUnionExpressionAst, maybeAdaptDictionaryUnionValueAst, maybeAdaptRuntimeUnionExpressionAst, } from "./runtime-union-adaptation.js";
+import { resolveDirectStorageExpressionType, resolveDirectStorageIrType, resolveExactStorageSurfaceExpressionType, resolveIdentifierRuntimeCarrierType, resolveRuntimeCarrierExpressionAst, resolveRuntimeCarrierIrType, } from "./direct-storage-types.js";
+import { resolveDirectRuntimeCarrierType, resolveDirectValueSurfaceType, } from "../core/semantic/direct-value-surfaces.js";
+import { tryAdaptStructuralExpressionAst } from "./structural-adaptation.js";
+import { hasMatchingRuntimeCarrierElementType } from "./structural-collection-adaptation.js";
+import { matchesEmittedStorageSurface } from "./identifier-storage.js";
+import { resolveRuntimeMaterializationTargetType } from "../core/semantic/runtime-materialization-targets.js";
+import { buildRuntimeUnionLayout, buildRuntimeUnionTypeAst, findExactRuntimeUnionMemberIndices, } from "../core/semantic/runtime-unions.js";
+import { resolveComparableType } from "../core/semantic/comparable-types.js";
+import { isBroadObjectPassThroughType, isBroadObjectSlotType, } from "../core/semantic/js-value-types.js";
+import { willCarryAsRuntimeUnion } from "../core/semantic/union-semantics.js";
+import { getRuntimeUnionAliasReferenceKey, runtimeUnionAliasReferencesMatch, } from "../core/semantic/runtime-union-alias-identity.js";
+import { getMemberAccessNarrowKey } from "../core/semantic/narrowing-keys.js";
+import { isDefinitelyValueType, resolveTypeAlias, splitRuntimeNullishUnionMembers, stripNullish, } from "../core/semantic/type-resolution.js";
+import { emitTypeAst } from "../type-emitter.js";
+import { unwrapTransparentExpression } from "../core/semantic/transparent-expressions.js";
+import { identifierExpression } from "../core/format/backend-ast/builders.js";
+import { escapeCSharpIdentifier } from "../emitter-types/index.js";
+import { referenceTypeHasClrIdentity } from "../core/semantic/clr-type-identity.js";
+import { areIrTypesEquivalent } from "../core/semantic/type-equivalence.js";
+import { tryStripConditionalNullishGuardAst } from "../core/semantic/narrowing-builders.js";
+import { resolveStructuralViewMethodSurface } from "../core/semantic/structural-view-types.js";
+import { getArrayElementType, getDictionaryValueType, } from "./structural-type-shapes.js";
+const JS_NUMERIC_ADAPTATION_CLR_NAMES = new Set([
+    "System.Int32",
+    "global::System.Int32",
+    "System.Double",
+    "global::System.Double",
+]);
+const isNumericTypeParameterType = (type, context) => {
+    if (!type) {
+        return false;
+    }
+    const resolved = resolveTypeAlias(stripNullish(type), context);
+    return (resolved.kind === "typeParameterType" &&
+        (context.typeParamConstraints?.get(resolved.name) ?? "unconstrained") ===
+            "numeric");
+};
+const isJsNumberStorageTarget = (type, context) => {
+    if (!type) {
+        return false;
+    }
+    const resolved = resolveTypeAlias(stripNullish(type), context);
+    return ((resolved.kind === "primitiveType" && resolved.name === "number") ||
+        (resolved.kind === "referenceType" &&
+            (resolved.name === "double" ||
+                referenceTypeHasClrIdentity(resolved, [
+                    "System.Double",
+                    "global::System.Double",
+                ]))));
+};
+const isBroadCarrierPreservingTarget = (type, context) => isBroadObjectSlotType(type, context);
+const isCarrierPreservingExpectedType = (type, context) => !!type &&
+    (isBroadObjectSlotType(type, context) ||
+        willCarryAsRuntimeUnion(type, context) ||
+        (splitRuntimeNullishUnionMembers(type)?.hasRuntimeNullish ?? false));
+const matchesRuntimeUnionCarrierSurface = (actualType, expectedType, context) => {
+    if (!willCarryAsRuntimeUnion(actualType, context) &&
+        !willCarryAsRuntimeUnion(expectedType, context)) {
+        const actualExactSurface = tryEmitExactComparisonTargetAst(actualType, context);
+        if (!actualExactSurface) {
+            return false;
+        }
+        const expectedExactSurface = tryEmitExactComparisonTargetAst(expectedType, actualExactSurface[1]);
+        return (!!expectedExactSurface &&
+            sameTypeAstSurface(actualExactSurface[0], expectedExactSurface[0]));
+    }
+    const [actualLayout, actualLayoutContext] = buildRuntimeUnionLayout(actualType, context, emitTypeAst);
+    const [expectedLayout] = buildRuntimeUnionLayout(expectedType, actualLayoutContext, emitTypeAst);
+    if (!actualLayout || !expectedLayout) {
+        return actualLayout === expectedLayout;
+    }
+    return sameTypeAstSurface(buildRuntimeUnionTypeAst(actualLayout), buildRuntimeUnionTypeAst(expectedLayout));
+};
+const hasMatchingRuntimeCarrierFamily = (actualType, expectedType, context) => {
+    if (!actualType || !expectedType) {
+        return false;
+    }
+    const resolvedActual = resolveTypeAlias(stripNullish(actualType), context);
+    const resolvedExpected = resolveTypeAlias(stripNullish(expectedType), context);
+    if (resolvedActual.kind !== "unionType" ||
+        resolvedExpected.kind !== "unionType") {
+        return false;
+    }
+    return (resolvedActual.runtimeCarrierFamilyKey !== undefined &&
+        resolvedActual.runtimeCarrierFamilyKey ===
+            resolvedExpected.runtimeCarrierFamilyKey);
+};
+export const hasMismatchedCollectionElementCarrier = (sourceType, targetType, context) => {
+    const sourceArrayElementType = getArrayElementType(sourceType, context);
+    const targetArrayElementType = getArrayElementType(targetType, context);
+    if (sourceArrayElementType && targetArrayElementType) {
+        return !hasMatchingRuntimeCarrierElementType(sourceArrayElementType, targetArrayElementType, context);
+    }
+    const sourceDictionaryValueType = getDictionaryValueType(sourceType, context);
+    const targetDictionaryValueType = getDictionaryValueType(targetType, context);
+    if (sourceDictionaryValueType && targetDictionaryValueType) {
+        return !hasMatchingRuntimeCarrierElementType(sourceDictionaryValueType, targetDictionaryValueType, context);
+    }
+    return false;
+};
+export const resolveCarrierPreservingSourceType = (sourceType, carrierTargetType, context) => {
+    if (!sourceType || !carrierTargetType) {
+        return undefined;
+    }
+    const strippedSourceType = stripNullish(sourceType);
+    const strippedCarrierTargetType = stripNullish(carrierTargetType);
+    const sourceHasRuntimeNullish = splitRuntimeNullishUnionMembers(sourceType)?.hasRuntimeNullish ?? false;
+    const targetHasRuntimeNullish = splitRuntimeNullishUnionMembers(carrierTargetType)?.hasRuntimeNullish ??
+        false;
+    if (sourceHasRuntimeNullish && !targetHasRuntimeNullish) {
+        return undefined;
+    }
+    if (isNumericTypeParameterType(strippedSourceType, context) &&
+        isJsNumberStorageTarget(strippedCarrierTargetType, context)) {
+        return undefined;
+    }
+    if (hasMismatchedCollectionElementCarrier(strippedSourceType, strippedCarrierTargetType, context)) {
+        return undefined;
+    }
+    return matchesExpectedEmissionType(strippedSourceType, strippedCarrierTargetType, context) &&
+        matchesRuntimeUnionCarrierSurface(strippedSourceType, strippedCarrierTargetType, context)
+        ? sourceHasRuntimeNullish && targetHasRuntimeNullish
+            ? sourceType
+            : strippedSourceType
+        : undefined;
+};
+const resolveRawRuntimeUnionProjectionSourceType = (sourceType, carrierTargetType, context) => {
+    if (!sourceType || !carrierTargetType) {
+        return undefined;
+    }
+    const strippedSourceType = stripNullish(sourceType);
+    const strippedCarrierTargetType = stripNullish(carrierTargetType);
+    if (!willCarryAsRuntimeUnion(strippedSourceType, context) ||
+        !willCarryAsRuntimeUnion(strippedCarrierTargetType, context)) {
+        return undefined;
+    }
+    if (!matchesExpectedEmissionType(strippedSourceType, strippedCarrierTargetType, context)) {
+        return undefined;
+    }
+    if (matchesRuntimeUnionCarrierSurface(strippedSourceType, strippedCarrierTargetType, context)) {
+        return undefined;
+    }
+    return sourceType;
+};
+const resolveActiveCarrierSourceType = (carrierType, effectiveExpressionType) => {
+    if (!carrierType) {
+        return undefined;
+    }
+    const carrierHasRuntimeNullish = splitRuntimeNullishUnionMembers(carrierType)?.hasRuntimeNullish ?? false;
+    const effectiveHasRuntimeNullish = (effectiveExpressionType
+        ? splitRuntimeNullishUnionMembers(effectiveExpressionType)
+            ?.hasRuntimeNullish
+        : false) ?? false;
+    return carrierHasRuntimeNullish && !effectiveHasRuntimeNullish
+        ? stripNullish(carrierType)
+        : carrierType;
+};
+const stillUsesRawRuntimeProjectionSourceType = (effectiveExpressionType, rawProjectionSourceType, context) => {
+    if (!effectiveExpressionType || !rawProjectionSourceType) {
+        return false;
+    }
+    return (runtimeUnionAliasReferencesMatch(effectiveExpressionType, rawProjectionSourceType, context) ||
+        resolveCarrierPreservingSourceType(effectiveExpressionType, rawProjectionSourceType, context) !== undefined ||
+        resolveCarrierPreservingSourceType(rawProjectionSourceType, effectiveExpressionType, context) !== undefined);
+};
+const unwrapTransparentAst = (ast) => {
+    let current = ast;
+    while (current.kind === "parenthesizedExpression" ||
+        current.kind === "castExpression" ||
+        current.kind === "asExpression") {
+        current = current.expression;
+    }
+    return current;
+};
+const isCurrentInstanceSelfTarget = (expr, ast, expectedType, context) => {
+    if (expr.kind !== "this" || !expectedType || !context.declaringTypeName) {
+        return false;
+    }
+    const unwrappedAst = unwrapTransparentAst(ast);
+    if (unwrappedAst.kind !== "identifierExpression" ||
+        unwrappedAst.identifier !==
+            (context.objectLiteralThisIdentifier ?? "this")) {
+        return false;
+    }
+    const declaringType = {
+        kind: "referenceType",
+        name: context.declaringTypeName,
+        ...(context.declaringTypeParameterNames &&
+            context.declaringTypeParameterNames.length > 0
+            ? {
+                typeArguments: context.declaringTypeParameterNames.map((name) => ({ kind: "typeParameterType", name })),
+            }
+            : {}),
+    };
+    const targetType = stripNullish(expectedType);
+    const candidateThisTypes = [
+        expr.inferredType,
+        declaringType,
+    ].filter((candidate) => candidate !== undefined);
+    return candidateThisTypes.some((candidate) => areIrTypesEquivalent(candidate, targetType, context));
+};
+export const resolveCarrierPreservingRawExpectedType = (opts) => {
+    const { expr, selectedExpectedType, contextualExpectedType, surfaceExpectedType, finalExpectedType, context, } = opts;
+    const transparentExpr = unwrapTransparentExpression(expr);
+    const carrierTargetType = isCarrierPreservingExpectedType(surfaceExpectedType, context)
+        ? surfaceExpectedType
+        : finalExpectedType;
+    if (!isCarrierPreservingExpectedType(carrierTargetType, context)) {
+        return contextualExpectedType;
+    }
+    const narrowKey = transparentExpr.kind === "identifier"
+        ? transparentExpr.name
+        : transparentExpr.kind === "memberAccess"
+            ? getMemberAccessNarrowKey(transparentExpr)
+            : undefined;
+    const narrowed = narrowKey
+        ? context.narrowedBindings?.get(narrowKey)
+        : undefined;
+    const hasProjectedNarrowing = narrowed?.kind === "expr" || narrowed?.kind === "runtimeSubset";
+    const effectiveExpressionType = resolveEffectiveExpressionType(transparentExpr, context) ??
+        transparentExpr.inferredType;
+    const expressionStillCarriesRuntimeUnion = !!effectiveExpressionType &&
+        willCarryAsRuntimeUnion(stripNullish(effectiveExpressionType), context);
+    if (!hasProjectedNarrowing) {
+        const directStorageType = resolveDirectStorageIrType(transparentExpr, context);
+        if (directStorageType &&
+            resolveCarrierPreservingSourceType(directStorageType, carrierTargetType, context)) {
+            return carrierTargetType;
+        }
+        const directRawProjectionSourceType = resolveRawRuntimeUnionProjectionSourceType(directStorageType, carrierTargetType, context);
+        if (directRawProjectionSourceType &&
+            expressionStillCarriesRuntimeUnion &&
+            stillUsesRawRuntimeProjectionSourceType(effectiveExpressionType ?? directStorageType, directRawProjectionSourceType, context)) {
+            return directRawProjectionSourceType;
+        }
+        if (transparentExpr.kind === "identifier") {
+            const storageType = resolveIdentifierRuntimeCarrierType(transparentExpr, context);
+            if (resolveCarrierPreservingSourceType(storageType, carrierTargetType, context)) {
+                return carrierTargetType;
+            }
+            const rawProjectionSourceType = resolveRawRuntimeUnionProjectionSourceType(storageType, carrierTargetType, context);
+            if (rawProjectionSourceType &&
+                expressionStillCarriesRuntimeUnion &&
+                stillUsesRawRuntimeProjectionSourceType(effectiveExpressionType ?? storageType, rawProjectionSourceType, context)) {
+                return rawProjectionSourceType;
+            }
+        }
+    }
+    else if (narrowed?.kind === "expr") {
+        const narrowedCarrierType = resolveActiveCarrierSourceType(resolveRuntimeCarrierIrType(transparentExpr, context) ??
+            narrowed.sourceType ??
+            narrowed.storageType ??
+            narrowed.type, effectiveExpressionType);
+        if (resolveCarrierPreservingSourceType(narrowedCarrierType, carrierTargetType, context)) {
+            return carrierTargetType;
+        }
+        const rawProjectionSourceType = resolveRawRuntimeUnionProjectionSourceType(narrowedCarrierType, carrierTargetType, context);
+        if (rawProjectionSourceType &&
+            expressionStillCarriesRuntimeUnion &&
+            stillUsesRawRuntimeProjectionSourceType(effectiveExpressionType ?? narrowedCarrierType, rawProjectionSourceType, context)) {
+            return rawProjectionSourceType;
+        }
+    }
+    if (selectedExpectedType &&
+        !areIrTypesEquivalent(selectedExpectedType, carrierTargetType, context) &&
+        (() => {
+            const [carrierLayout, layoutContext] = buildRuntimeUnionLayout(carrierTargetType, context, emitTypeAst);
+            if (carrierLayout) {
+                const exactMemberIndices = findExactRuntimeUnionMemberIndices(carrierLayout.members, selectedExpectedType, layoutContext);
+                if (exactMemberIndices.length === 1) {
+                    return true;
+                }
+                const emissionMatchingMembers = carrierLayout.members.filter((member) => matchesExpectedEmissionType(selectedExpectedType, member, layoutContext));
+                if (emissionMatchingMembers.length === 1) {
+                    return true;
+                }
+            }
+            return matchesExpectedEmissionType(selectedExpectedType, carrierTargetType, context);
+        })()) {
+        return selectedExpectedType;
+    }
+    if (carrierTargetType && willCarryAsRuntimeUnion(carrierTargetType, context)) {
+        return undefined;
+    }
+    return contextualExpectedType;
+};
+export const resolveDirectStorageCompatibleExpressionType = (opts) => resolveDirectStorageExpressionType(opts.expr, opts.valueAst, opts.context);
+export const resolveDirectStorageCompatibleIrType = (opts) => resolveDirectStorageIrType(opts.expr, opts.context);
+export const resolveRuntimeCarrierCompatibleExpressionAst = (opts) => resolveRuntimeCarrierExpressionAst(opts.expr, opts.context);
+export const resolveRuntimeCarrierCompatibleIrType = (opts) => resolveRuntimeCarrierIrType(opts.expr, opts.context);
+export const tryEmitCarrierPreservingExpressionAst = (opts) => {
+    const { expr, expectedType, context } = opts;
+    if (!isCarrierPreservingExpectedType(expectedType, context)) {
+        return undefined;
+    }
+    const transparentExpr = unwrapTransparentExpression(expr);
+    const carrierAst = resolveRuntimeCarrierExpressionAst(transparentExpr, context);
+    const effectiveExpressionType = resolveEffectiveExpressionType(transparentExpr, context) ??
+        transparentExpr.inferredType;
+    if (isBroadObjectSlotType(expectedType, context) &&
+        effectiveExpressionType &&
+        willCarryAsRuntimeUnion(stripNullish(effectiveExpressionType), context)) {
+        return undefined;
+    }
+    const carrierType = resolveActiveCarrierSourceType(resolveRuntimeCarrierIrType(transparentExpr, context), effectiveExpressionType);
+    const carrierSourceType = resolveCarrierPreservingSourceType(carrierType, expectedType, context);
+    if (carrierSourceType && carrierAst) {
+        return {
+            ast: carrierAst,
+            context,
+            actualType: carrierSourceType,
+        };
+    }
+    return undefined;
+};
+const isJsNumericAdaptationSource = (type, context, seen = new Set()) => {
+    if (!type || seen.has(type)) {
+        return false;
+    }
+    seen.add(type);
+    const resolved = resolveComparableType(type, context);
+    switch (resolved.kind) {
+        case "literalType":
+            return typeof resolved.value === "number";
+        case "primitiveType":
+            return resolved.name === "number" || resolved.name === "int";
+        case "typeParameterType":
+            return ((context.typeParamConstraints?.get(resolved.name) ??
+                "unconstrained") === "numeric");
+        case "referenceType":
+            return (resolved.name === "double" ||
+                resolved.name === "int" ||
+                referenceTypeHasClrIdentity(resolved, JS_NUMERIC_ADAPTATION_CLR_NAMES));
+        case "unionType":
+            return resolved.types.every((member) => {
+                const comparableMember = resolveComparableType(member, context);
+                return ((comparableMember.kind === "primitiveType" &&
+                    comparableMember.name === "null") ||
+                    (comparableMember.kind === "primitiveType" &&
+                        comparableMember.name === "undefined") ||
+                    isJsNumericAdaptationSource(member, context, seen));
+            });
+        default:
+            return false;
+    }
+};
+const requiresJsNumberBoxingAdaptation = (actualType, expectedType, context) => context.options.surface === "@tsonic/js" &&
+    isBroadObjectSlotType(expectedType, context) &&
+    isJsNumericAdaptationSource(actualType, context);
+const isNumericLiteralAst = (ast) => {
+    if (ast.kind === "numericLiteralExpression") {
+        return true;
+    }
+    return (ast.kind === "prefixUnaryExpression" &&
+        (ast.operatorToken === "-" || ast.operatorToken === "+") &&
+        isNumericLiteralAst(ast.operand));
+};
+const isJsNumberExpectedType = (type, context) => {
+    if (!type) {
+        return false;
+    }
+    const resolved = resolveTypeAlias(stripNullish(type), context);
+    return ((resolved.kind === "primitiveType" && resolved.name === "number") ||
+        (resolved.kind === "referenceType" &&
+            (resolved.name === "double" ||
+                referenceTypeHasClrIdentity(resolved, ["System.Double"]))));
+};
+const maybeCastNumericToExpectedJsNumberAst = (ast, actualType, context, expectedType) => {
+    if (!expectedType ||
+        !isJsNumberExpectedType(expectedType, context) ||
+        !isJsNumericAdaptationSource(actualType, context) ||
+        isNumericLiteralAst(ast) ||
+        isNumericFactoryCreateCheckedAst(ast, expectedType, context) ||
+        (actualType &&
+            areIrTypesEquivalent(stripNullish(actualType), stripNullish(expectedType), context))) {
+        return [ast, context];
+    }
+    const resolvedActual = actualType
+        ? resolveTypeAlias(stripNullish(actualType), context)
+        : undefined;
+    if (resolvedActual?.kind === "typeParameterType" &&
+        (context.typeParamConstraints?.get(resolvedActual.name) ??
+            "unconstrained") === "numeric") {
+        return [
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: identifierExpression("global::System.Double"),
+                    memberName: "CreateChecked",
+                },
+                arguments: [ast],
+            },
+            context,
+        ];
+    }
+    const [expectedTypeAst, expectedTypeContext] = emitTypeAst(expectedType, context);
+    if (ast.kind === "castExpression" &&
+        sameTypeAstSurface(ast.type, expectedTypeAst)) {
+        return [ast, expectedTypeContext];
+    }
+    return [
+        {
+            kind: "castExpression",
+            type: expectedTypeAst,
+            expression: ast,
+        },
+        expectedTypeContext,
+    ];
+};
+const matchesDirectCarrierAst = (left, right) => {
+    if (left.kind !== right.kind) {
+        return false;
+    }
+    switch (left.kind) {
+        case "identifierExpression":
+            return (right.kind === "identifierExpression" &&
+                left.identifier === right.identifier);
+        case "parenthesizedExpression":
+            return (right.kind === "parenthesizedExpression" &&
+                matchesDirectCarrierAst(left.expression, right.expression));
+        case "castExpression":
+            return (right.kind === "castExpression" &&
+                left.type.kind === right.type.kind &&
+                matchesDirectCarrierAst(left.expression, right.expression));
+        case "memberAccessExpression":
+            return (right.kind === "memberAccessExpression" &&
+                left.memberName === right.memberName &&
+                matchesDirectCarrierAst(left.expression, right.expression));
+        default:
+            return false;
+    }
+};
+const getSingleRuntimeNullishBaseType = (type) => {
+    if (!type || type.kind !== "unionType") {
+        return undefined;
+    }
+    const nonNullish = type.types.filter((member) => !(member.kind === "primitiveType" &&
+        (member.name === "null" || member.name === "undefined")));
+    return nonNullish.length === 1 ? (nonNullish[0] ?? undefined) : undefined;
+};
+const hasRuntimeNullishType = (type) => (type ? splitRuntimeNullishUnionMembers(type)?.hasRuntimeNullish : false) ??
+    false;
+const stripDeadRuntimeNullishFallbackAst = (ast) => {
+    const stripped = tryStripConditionalNullishGuardAst(ast);
+    if (stripped) {
+        return stripped;
+    }
+    if (ast.kind === "parenthesizedExpression") {
+        const expression = stripDeadRuntimeNullishFallbackAst(ast.expression);
+        return expression === ast.expression ? ast : { ...ast, expression };
+    }
+    if (ast.kind === "castExpression") {
+        const strippedExpression = tryStripConditionalNullishGuardAst(ast.expression);
+        if (strippedExpression) {
+            return strippedExpression;
+        }
+        const expression = stripDeadRuntimeNullishFallbackAst(ast.expression);
+        return expression === ast.expression ? ast : { ...ast, expression };
+    }
+    return ast;
+};
+const hasExplicitRuntimeUnionCarrierIdentity = (type, context) => {
+    if (!type) {
+        return false;
+    }
+    if (getRuntimeUnionAliasReferenceKey(type, context) !== undefined) {
+        return true;
+    }
+    const resolved = resolveTypeAlias(stripNullish(type), context);
+    return (resolved.kind === "unionType" &&
+        resolved.runtimeCarrierFamilyKey !== undefined);
+};
+const preferNarrowedEffectiveActualType = (directStorageType, effectiveExpressionType, expectedType, context) => {
+    if (!directStorageType) {
+        return effectiveExpressionType;
+    }
+    if (!effectiveExpressionType) {
+        return directStorageType;
+    }
+    const directPreservesExpectedCarrier = expectedType !== undefined &&
+        resolveCarrierPreservingSourceType(directStorageType, expectedType, context) !== undefined;
+    const effectivePreservesExpectedCarrier = expectedType !== undefined &&
+        resolveCarrierPreservingSourceType(effectiveExpressionType, expectedType, context) !== undefined;
+    if (directPreservesExpectedCarrier && !effectivePreservesExpectedCarrier) {
+        return directStorageType;
+    }
+    if (isBroadObjectSlotType(directStorageType, context)) {
+        return directStorageType;
+    }
+    const directNullableBase = getSingleRuntimeNullishBaseType(directStorageType);
+    if (directNullableBase &&
+        areIrTypesEquivalent(directNullableBase, effectiveExpressionType, context) &&
+        isDefinitelyValueType(resolveTypeAlias(directNullableBase, context))) {
+        const expectedRetainsRuntimeNullish = expectedType
+            ? (splitRuntimeNullishUnionMembers(expectedType)?.hasRuntimeNullish ??
+                false)
+            : true;
+        if (!expectedRetainsRuntimeNullish &&
+            expectedType &&
+            matchesExpectedEmissionType(effectiveExpressionType, expectedType, context)) {
+            return effectiveExpressionType;
+        }
+        return directStorageType;
+    }
+    const effectiveHasExplicitCarrierIdentity = hasExplicitRuntimeUnionCarrierIdentity(effectiveExpressionType, context);
+    const directHasExplicitCarrierIdentity = hasExplicitRuntimeUnionCarrierIdentity(directStorageType, context);
+    const effectiveAliasReferenceKey = getRuntimeUnionAliasReferenceKey(effectiveExpressionType, context);
+    const directAliasReferenceKey = getRuntimeUnionAliasReferenceKey(directStorageType, context);
+    const directMatchesEffectiveCarrierSurface = matchesExpectedEmissionType(directStorageType, effectiveExpressionType, context) ||
+        matchesRuntimeUnionCarrierSurface(directStorageType, effectiveExpressionType, context) ||
+        hasMatchingRuntimeCarrierFamily(directStorageType, effectiveExpressionType, context);
+    if (directAliasReferenceKey &&
+        effectiveHasExplicitCarrierIdentity &&
+        directMatchesEffectiveCarrierSurface &&
+        directAliasReferenceKey !== effectiveAliasReferenceKey) {
+        return directStorageType;
+    }
+    if (effectiveHasExplicitCarrierIdentity &&
+        directMatchesEffectiveCarrierSurface &&
+        (!directHasExplicitCarrierIdentity ||
+            runtimeUnionAliasReferencesMatch(directStorageType, effectiveExpressionType, context) ||
+            hasMatchingRuntimeCarrierFamily(directStorageType, effectiveExpressionType, context))) {
+        return effectiveExpressionType;
+    }
+    return !areIrTypesEquivalent(effectiveExpressionType, directStorageType, context) &&
+        matchesExpectedEmissionType(effectiveExpressionType, directStorageType, context) &&
+        !matchesExpectedEmissionType(directStorageType, effectiveExpressionType, context)
+        ? effectiveExpressionType
+        : directStorageType;
+};
+const trySelectExactRuntimeUnionMembers = (actualType, expectedType, context) => {
+    if (!actualType || !expectedType) {
+        return { context };
+    }
+    const [runtimeLayout, layoutContext] = buildRuntimeUnionLayout(expectedType, context, emitTypeAst);
+    if (!runtimeLayout) {
+        return { context: layoutContext };
+    }
+    const exactIndices = findExactRuntimeUnionMemberIndices(runtimeLayout.members, actualType, layoutContext);
+    if (exactIndices.length !== 1) {
+        return { context: layoutContext };
+    }
+    const exactIndex = exactIndices[0];
+    if (exactIndex === undefined) {
+        return { context: layoutContext };
+    }
+    return {
+        context: layoutContext,
+        selectedSourceMemberNs: new Set([exactIndex + 1]),
+    };
+};
+export const adaptValueToExpectedTypeAst = (opts) => {
+    const { valueAst, actualType, context, expectedType, visited = new Set(), allowUnionNarrowing = true, selectedSourceMemberNs, } = opts;
+    if (!actualType || !expectedType) {
+        return undefined;
+    }
+    if (runtimeUnionAliasReferencesMatch(actualType, expectedType, context)) {
+        return [valueAst, context];
+    }
+    const exactExpectedSurface = tryEmitExactComparisonTargetAst(expectedType, context);
+    if (exactExpectedSurface &&
+        (isExactExpressionToType(valueAst, exactExpectedSurface[0]) ||
+            isExactArrayCreationToType(valueAst, exactExpectedSurface[0]))) {
+        return [valueAst, exactExpectedSurface[1]];
+    }
+    const [exactRuntimeUnionLayout, exactRuntimeUnionContext] = buildRuntimeUnionLayout(expectedType, context, emitTypeAst);
+    if (exactRuntimeUnionLayout) {
+        const exactRuntimeUnionTypeAst = buildRuntimeUnionTypeAst(exactRuntimeUnionLayout);
+        if (isExactExpressionToType(valueAst, exactRuntimeUnionTypeAst) ||
+            isExactArrayCreationToType(valueAst, exactRuntimeUnionTypeAst)) {
+            return [valueAst, exactRuntimeUnionContext];
+        }
+    }
+    const narrowedCarrierSourceType = valueAst.kind === "identifierExpression"
+        ? (() => {
+            const narrowed = context.narrowedBindings?.get(valueAst.identifier);
+            if (narrowed?.kind !== "expr") {
+                return undefined;
+            }
+            const narrowedStorageAst = narrowed.storageExprAst ?? narrowed.exprAst;
+            if (!narrowedStorageAst) {
+                return undefined;
+            }
+            if (!matchesDirectCarrierAst(valueAst, narrowedStorageAst)) {
+                return undefined;
+            }
+            if (!isBroadCarrierPreservingTarget(expectedType, context) &&
+                !willCarryAsRuntimeUnion(expectedType, context)) {
+                return undefined;
+            }
+            const carrierSourceType = narrowed.storageType ??
+                (narrowed.storageExprAst ? narrowed.type : undefined);
+            if (!carrierSourceType) {
+                return undefined;
+            }
+            return resolveCarrierPreservingSourceType(carrierSourceType, expectedType, context);
+        })()
+        : undefined;
+    if (narrowedCarrierSourceType) {
+        return [valueAst, context];
+    }
+    const directValueSurfaceType = resolveDirectValueSurfaceType(valueAst, context);
+    const directRuntimeCarrierType = resolveDirectRuntimeCarrierType(valueAst, context);
+    if (directRuntimeCarrierType &&
+        resolveCarrierPreservingSourceType(directRuntimeCarrierType, expectedType, context) &&
+        (!directValueSurfaceType ||
+            resolveCarrierPreservingSourceType(directValueSurfaceType, expectedType, context))) {
+        return [valueAst, context];
+    }
+    if (isBroadCarrierPreservingTarget(expectedType, context) &&
+        isBroadObjectPassThroughType(actualType, context)) {
+        return [stripDeadRuntimeNullishFallbackAst(valueAst), context];
+    }
+    if (isBroadCarrierPreservingTarget(expectedType, context) &&
+        matchesExpectedEmissionType(actualType, expectedType, context) &&
+        !requiresJsNumberBoxingAdaptation(actualType, expectedType, context) &&
+        !requiresValueTypeMaterialization(actualType, expectedType, context) &&
+        !willCarryAsRuntimeUnion(actualType, context)) {
+        return [valueAst, context];
+    }
+    if (directValueSurfaceType &&
+        resolveCarrierPreservingSourceType(directValueSurfaceType, expectedType, context)) {
+        return [valueAst, context];
+    }
+    const unionAdjusted = maybeAdaptRuntimeUnionExpressionAst(valueAst, actualType, context, expectedType, visited, selectedSourceMemberNs);
+    const unionAdjustedAst = unionAdjusted?.[0] ?? valueAst;
+    const unionAdjustedContext = unionAdjusted?.[1] ?? context;
+    const structuralSourceType = unionAdjusted && unionAdjustedAst !== valueAst ? expectedType : actualType;
+    const structuralAdjusted = tryAdaptStructuralExpressionAst(unionAdjustedAst, structuralSourceType, unionAdjustedContext, expectedType, maybeAdaptRuntimeUnionExpressionAst);
+    if (structuralAdjusted) {
+        return structuralAdjusted;
+    }
+    if (unionAdjusted) {
+        return unionAdjusted;
+    }
+    if (!allowUnionNarrowing) {
+        return undefined;
+    }
+    return maybeNarrowRuntimeUnionExpressionAst(valueAst, actualType, context, expectedType, visited, selectedSourceMemberNs);
+};
+export const adaptEmittedExpressionAst = (opts) => {
+    const { expr, valueAst, context, expectedType } = opts;
+    const [castedAst, castedContext] = maybeCastNullishTypeParamAst(expr, valueAst, context, expectedType);
+    const effectiveTypeForDeadNullishFallback = resolveEffectiveExpressionType(expr, castedContext) ?? expr.inferredType;
+    const normalizedCastedAst = effectiveTypeForDeadNullishFallback &&
+        !hasRuntimeNullishType(effectiveTypeForDeadNullishFallback)
+        ? stripDeadRuntimeNullishFallbackAst(castedAst)
+        : castedAst;
+    if (isCurrentInstanceSelfTarget(expr, normalizedCastedAst, expectedType, castedContext)) {
+        return [normalizedCastedAst, castedContext];
+    }
+    const exactExpectedSurface = expectedType
+        ? tryEmitExactComparisonTargetAst(expectedType, castedContext)
+        : undefined;
+    const matchesExactExpectedSurface = !!exactExpectedSurface &&
+        (isExactExpressionToType(normalizedCastedAst, exactExpectedSurface[0]) ||
+            isExactArrayCreationToType(normalizedCastedAst, exactExpectedSurface[0]));
+    const exactAssertedSurface = expr.kind === "typeAssertion"
+        ? tryEmitExactComparisonTargetAst(resolveRuntimeMaterializationTargetType(expr.targetType, castedContext), castedContext)
+        : undefined;
+    if (matchesExactExpectedSurface && expr.kind !== "typeAssertion") {
+        const exactSurfaceAst = expectedType &&
+            effectiveTypeForDeadNullishFallback &&
+            isBroadCarrierPreservingTarget(expectedType, castedContext) &&
+            !requiresJsNumberBoxingAdaptation(effectiveTypeForDeadNullishFallback, expectedType, castedContext)
+            ? stripDeadRuntimeNullishFallbackAst(normalizedCastedAst)
+            : normalizedCastedAst;
+        return [exactSurfaceAst, exactExpectedSurface[1]];
+    }
+    const preservesExpectedSurface = expr.kind === "typeAssertion" && matchesExactExpectedSurface;
+    const preservesAssertedSurface = expr.kind === "typeAssertion" &&
+        !!exactAssertedSurface &&
+        (isExactExpressionToType(normalizedCastedAst, exactAssertedSurface[0]) ||
+            isExactArrayCreationToType(normalizedCastedAst, exactAssertedSurface[0]));
+    const preservedTypeForAdaptation = expr.kind === "typeAssertion"
+        ? preservesAssertedSurface
+            ? expr.targetType
+            : preservesExpectedSurface
+                ? expectedType
+                : undefined
+        : undefined;
+    const adaptationSourceExpr = expr.kind === "typeAssertion" &&
+        normalizedCastedAst.kind !== "castExpression" &&
+        !preservedTypeForAdaptation
+        ? expr.expression
+        : expr;
+    const broadPassThroughSourceIdentifier = (() => {
+        if (!expectedType ||
+            !isBroadCarrierPreservingTarget(expectedType, castedContext) ||
+            adaptationSourceExpr.kind !== "identifier") {
+            return undefined;
+        }
+        const unwrappedCastedAst = unwrapTransparentAst(normalizedCastedAst);
+        const identifierName = castedContext.localNameMap?.get(adaptationSourceExpr.name) ??
+            escapeCSharpIdentifier(adaptationSourceExpr.name);
+        if (unwrappedCastedAst.kind !== "identifierExpression" ||
+            unwrappedCastedAst.identifier !== identifierName) {
+            return undefined;
+        }
+        const originalCarrierType = context.localValueTypes?.get(adaptationSourceExpr.name) ??
+            context.localSemanticTypes?.get(adaptationSourceExpr.name) ??
+            adaptationSourceExpr.inferredType;
+        if (!originalCarrierType ||
+            willCarryAsRuntimeUnion(originalCarrierType, castedContext)) {
+            return undefined;
+        }
+        if (!matchesExpectedEmissionType(originalCarrierType, expectedType, castedContext) &&
+            !isBroadObjectPassThroughType(originalCarrierType, castedContext)) {
+            return undefined;
+        }
+        return [identifierExpression(identifierName), castedContext];
+    })();
+    if (broadPassThroughSourceIdentifier) {
+        return broadPassThroughSourceIdentifier;
+    }
+    const directStorageType = expectedType &&
+        (isBroadCarrierPreservingTarget(expectedType, castedContext) ||
+            willCarryAsRuntimeUnion(expectedType, castedContext) ||
+            (splitRuntimeNullishUnionMembers(expectedType)?.hasRuntimeNullish ??
+                false))
+        ? resolveDirectStorageExpressionType(adaptationSourceExpr, normalizedCastedAst, castedContext)
+        : undefined;
+    const narrowKey = adaptationSourceExpr.kind === "identifier"
+        ? adaptationSourceExpr.name
+        : adaptationSourceExpr.kind === "memberAccess"
+            ? getMemberAccessNarrowKey(adaptationSourceExpr)
+            : undefined;
+    const directCarrierNarrowed = narrowKey && castedContext.narrowedBindings
+        ? castedContext.narrowedBindings.get(narrowKey)
+        : undefined;
+    const recoveredNarrowedCarrier = (() => {
+        if (!expectedType || directCarrierNarrowed?.kind !== "expr") {
+            return undefined;
+        }
+        const narrowedType = directCarrierNarrowed.type;
+        if (!narrowedType ||
+            !matchesExpectedEmissionType(narrowedType, expectedType, castedContext) ||
+            matchesExpectedEmissionType(expectedType, narrowedType, castedContext)) {
+            return undefined;
+        }
+        if (!matchesDirectCarrierAst(normalizedCastedAst, directCarrierNarrowed.exprAst)) {
+            return undefined;
+        }
+        const carrierAst = directCarrierNarrowed.carrierExprAst ??
+            directCarrierNarrowed.storageExprAst;
+        const carrierSourceType = directCarrierNarrowed.carrierType ??
+            directCarrierNarrowed.sourceType ??
+            directCarrierNarrowed.storageType;
+        if (!carrierAst || !carrierSourceType) {
+            return undefined;
+        }
+        return resolveCarrierPreservingSourceType(carrierSourceType, expectedType, castedContext)
+            ? [carrierAst, castedContext]
+            : undefined;
+    })();
+    if (recoveredNarrowedCarrier) {
+        return recoveredNarrowedCarrier;
+    }
+    const recoveredBroadPassThroughCarrier = (() => {
+        if (!expectedType || directCarrierNarrowed?.kind !== "expr") {
+            return undefined;
+        }
+        if (!isBroadCarrierPreservingTarget(expectedType, castedContext) ||
+            !matchesDirectCarrierAst(normalizedCastedAst, directCarrierNarrowed.exprAst)) {
+            return undefined;
+        }
+        if (adaptationSourceExpr.kind !== "identifier") {
+            return undefined;
+        }
+        const originalCarrierType = directCarrierNarrowed.carrierType ??
+            directCarrierNarrowed.sourceType ??
+            castedContext.localValueTypes?.get(adaptationSourceExpr.name);
+        if (!originalCarrierType ||
+            willCarryAsRuntimeUnion(originalCarrierType, castedContext)) {
+            return undefined;
+        }
+        if (!matchesExpectedEmissionType(originalCarrierType, expectedType, castedContext) &&
+            !isBroadObjectPassThroughType(originalCarrierType, castedContext)) {
+            return undefined;
+        }
+        return [
+            identifierExpression(castedContext.localNameMap?.get(adaptationSourceExpr.name) ??
+                escapeCSharpIdentifier(adaptationSourceExpr.name)),
+            castedContext,
+        ];
+    })();
+    if (recoveredBroadPassThroughCarrier) {
+        return recoveredBroadPassThroughCarrier;
+    }
+    const narrowedCarrierSourceType = (() => {
+        if (!expectedType) {
+            return undefined;
+        }
+        if (directCarrierNarrowed?.kind !== "expr") {
+            return undefined;
+        }
+        if (!directCarrierNarrowed.carrierExprAst ||
+            !matchesDirectCarrierAst(normalizedCastedAst, directCarrierNarrowed.carrierExprAst)) {
+            return undefined;
+        }
+        if (!isBroadCarrierPreservingTarget(expectedType, castedContext) &&
+            !willCarryAsRuntimeUnion(expectedType, castedContext)) {
+            return undefined;
+        }
+        const carrierSourceType = directCarrierNarrowed.carrierType ??
+            directCarrierNarrowed.sourceType ??
+            directStorageType;
+        return carrierSourceType
+            ? resolveCarrierPreservingSourceType(carrierSourceType, expectedType, castedContext)
+            : undefined;
+    })();
+    if (narrowedCarrierSourceType) {
+        return [normalizedCastedAst, castedContext];
+    }
+    const directRuntimeCarrierType = expectedType
+        ? resolveDirectRuntimeCarrierType(normalizedCastedAst, castedContext)
+        : undefined;
+    if (expectedType &&
+        directRuntimeCarrierType &&
+        resolveCarrierPreservingSourceType(directRuntimeCarrierType, expectedType, castedContext)) {
+        return [normalizedCastedAst, castedContext];
+    }
+    const directStorageExpressionType = resolveDirectStorageExpressionType(adaptationSourceExpr, normalizedCastedAst, castedContext);
+    const exactStorageSurfaceType = expectedType
+        ? resolveExactStorageSurfaceExpressionType(normalizedCastedAst)
+        : undefined;
+    if (expectedType && exactStorageSurfaceType) {
+        const [sameStorageSurface, storageSurfaceContext] = matchesEmittedStorageSurface(exactStorageSurfaceType, expectedType, castedContext);
+        if (sameStorageSurface) {
+            return [normalizedCastedAst, storageSurfaceContext];
+        }
+    }
+    if (expectedType &&
+        directStorageExpressionType &&
+        resolveCarrierPreservingSourceType(directStorageExpressionType, expectedType, castedContext)) {
+        return [normalizedCastedAst, castedContext];
+    }
+    if (expectedType &&
+        directStorageExpressionType &&
+        isBroadCarrierPreservingTarget(expectedType, castedContext) &&
+        isBroadObjectPassThroughType(directStorageExpressionType, castedContext) &&
+        !requiresJsNumberBoxingAdaptation(directStorageExpressionType, expectedType, castedContext) &&
+        !requiresValueTypeMaterialization(directStorageExpressionType, expectedType, castedContext) &&
+        !willCarryAsRuntimeUnion(directStorageExpressionType, castedContext)) {
+        return [
+            stripDeadRuntimeNullishFallbackAst(normalizedCastedAst),
+            castedContext,
+        ];
+    }
+    const effectiveExpressionType = resolveEffectiveExpressionType(adaptationSourceExpr, castedContext);
+    const structuralViewReturnType = expr.kind === "call"
+        ? resolveStructuralViewMethodSurface(expr.callee, castedContext)
+            ?.returnType
+        : undefined;
+    const actualType = preservedTypeForAdaptation ??
+        (expr.kind === "typeAssertion" ? expr.targetType : undefined) ??
+        structuralViewReturnType ??
+        (expr.kind === "call" || expr.kind === "new"
+            ? expr.sourceBackedReturnType
+            : undefined) ??
+        preferNarrowedEffectiveActualType(directStorageExpressionType, effectiveExpressionType, expectedType, castedContext) ??
+        tryResolveRuntimeUnionMemberType(effectiveExpressionType, normalizedCastedAst, castedContext) ??
+        effectiveExpressionType ??
+        adaptationSourceExpr.inferredType;
+    if (expectedType &&
+        actualType &&
+        isBroadCarrierPreservingTarget(expectedType, castedContext) &&
+        isBroadObjectPassThroughType(actualType, castedContext) &&
+        !requiresJsNumberBoxingAdaptation(actualType, expectedType, castedContext) &&
+        !requiresValueTypeMaterialization(actualType, expectedType, castedContext) &&
+        !willCarryAsRuntimeUnion(stripNullish(actualType), castedContext)) {
+        return [
+            stripDeadRuntimeNullishFallbackAst(normalizedCastedAst),
+            castedContext,
+        ];
+    }
+    const [dictionaryAdjustedAst, dictionaryAdjustedContext] = maybeAdaptDictionaryUnionValueAst(expr, normalizedCastedAst, castedContext, expectedType);
+    if (actualType &&
+        expectedType &&
+        runtimeUnionAliasReferencesMatch(actualType, expectedType, dictionaryAdjustedContext)) {
+        return [dictionaryAdjustedAst, dictionaryAdjustedContext];
+    }
+    const exactRuntimeUnionSelection = trySelectExactRuntimeUnionMembers(actualType, expectedType, dictionaryAdjustedContext);
+    const [expectedAdjustedAst, expectedAdjustedContext] = adaptValueToExpectedTypeAst({
+        valueAst: dictionaryAdjustedAst,
+        actualType,
+        context: exactRuntimeUnionSelection.context,
+        expectedType,
+        allowUnionNarrowing: false,
+        selectedSourceMemberNs: exactRuntimeUnionSelection.selectedSourceMemberNs,
+    }) ?? [dictionaryAdjustedAst, dictionaryAdjustedContext];
+    const broadNullishStrippedAst = expectedType &&
+        actualType &&
+        isBroadCarrierPreservingTarget(expectedType, expectedAdjustedContext) &&
+        !requiresJsNumberBoxingAdaptation(actualType, expectedType, expectedAdjustedContext) &&
+        !requiresValueTypeMaterialization(actualType, expectedType, expectedAdjustedContext) &&
+        !willCarryAsRuntimeUnion(stripNullish(actualType), expectedAdjustedContext)
+        ? stripDeadRuntimeNullishFallbackAst(expectedAdjustedAst)
+        : expectedAdjustedAst;
+    const [integralAdjustedAst, integralAdjustedContext] = maybeCastNumericToExpectedIntegralAst(broadNullishStrippedAst, actualType, expectedAdjustedContext, expectedType);
+    const [numericAdjustedAst, numericAdjustedContext] = maybeCastNumericToExpectedJsNumberAst(integralAdjustedAst, actualType, integralAdjustedContext, expectedType);
+    const [boxedNumericAst, boxedNumericContext] = maybeBoxJsNumberAsObjectAst(numericAdjustedAst, expr, actualType, numericAdjustedContext, expectedType);
+    const [stringAdjustedAst, stringAdjustedContext] = maybeConvertCharToStringAst(expr, boxedNumericAst, boxedNumericContext, expectedType);
+    const [unwrappedAst, unwrappedContext] = maybeUnwrapNullableValueTypeAst(expr, stringAdjustedAst, stringAdjustedContext, expectedType);
+    return [
+        simplifyRedundantObjectBridgeCastsAst(unwrappedAst, actualType, unwrappedContext, expectedType),
+        unwrappedContext,
+    ];
+};
+//# sourceMappingURL=expected-type-adaptation.js.map