@tsonic/emitter 0.0.76 → 0.0.78

package/dist/expressions/calls/call-arguments-emit.js

@@ -7,7 +7,7 @@ import { emitTypeAst } from "../../type-emitter.js";
 import { escapeCSharpIdentifier } from "../../emitter-types/index.js";
 import { emitCSharpName } from "../../naming-policy.js";
 import { identifierExpression } from "../../core/format/backend-ast/builders.js";
-import { extractCalleeNameFromAst } from "../../core/format/backend-ast/utils.js";
+import { extractCalleeNameFromAst, sameTypeAstSurface, } from "../../core/format/backend-ast/utils.js";
 import { resolveEffectiveExpressionType, resolveRuntimeSubsetMemberNs, } from "../../core/semantic/narrowed-expression-types.js";
 import { containsTypeParameter, getArrayLikeElementType, } from "../../core/semantic/type-resolution.js";
 import { matchesExpectedEmissionType } from "../../core/semantic/expected-type-matching.js";
@@ -17,16 +17,19 @@ import { resolveTypeAlias, splitRuntimeNullishUnionMembers, stripNullish, } from
 import { resolveComparableType } from "../../core/semantic/comparable-types.js";
 import { resolveArrayLiteralContextType, resolveEmptyArrayLiteralContextType, } from "../../core/semantic/array-expected-types.js";
 import { resolveRuntimeMaterializationTargetType } from "../../core/semantic/runtime-materialization-targets.js";
-import { isBroadObjectSlotType } from "../../core/semantic/js-value-types.js";
+import { isBroadObjectSlotType } from "../../core/semantic/broad-object-types.js";
 import { referenceTypeHasClrIdentity } from "../../core/semantic/clr-type-identity.js";
 import { runtimeUnionMemberCanAcceptValue } from "../../core/semantic/runtime-union-matching.js";
 import { willCarryAsRuntimeUnion } from "../../core/semantic/union-semantics.js";
 import { getContextualTypeVisitKey, tryContextualTypeIdentityKey, } from "../../core/semantic/deterministic-type-keys.js";
 import { unwrapTransparentExpression } from "../../core/semantic/transparent-expressions.js";
-import { buildRuntimeUnionLayout } from "../../core/semantic/runtime-unions.js";
+import { buildRuntimeUnionLayout, buildRuntimeUnionTypeAst, } from "../../core/semantic/runtime-unions.js";
+import { tryBuildRuntimeMaterializationAst } from "../../core/semantic/runtime-reification.js";
 import { runtimeUnionAliasReferencesMatch } from "../../core/semantic/runtime-union-alias-identity.js";
 import { getPassingModifierFromCast, isLValue } from "./call-analysis.js";
 import { adaptValueToExpectedTypeAst, resolveDirectStorageCompatibleExpressionType, resolveDirectStorageCompatibleIrType, resolveCarrierPreservingRawExpectedType, resolveCarrierPreservingSourceType, resolveRuntimeCarrierCompatibleExpressionAst, resolveRuntimeCarrierCompatibleIrType, tryEmitCarrierPreservingExpressionAst, hasMismatchedCollectionElementCarrier, } from "../expected-type-adaptation.js";
+import { tryAdaptAwaitableValueAst } from "../awaitable-adaptation.js";
+import { maybeAdaptRuntimeUnionExpressionAst } from "../runtime-union-adaptation.js";
 import { isExactArrayCreationToType, isExactExpressionToType, tryEmitExactComparisonTargetAst, } from "../exact-comparison.js";
 import { getDirectIterableElementType } from "../structural-type-shapes.js";
 import { normalizeCallArgumentExpectedType, expandTupleLikeSpreadArguments, getTransparentRestSpreadPassthroughExpression, wrapArgModifier, emitFlattenedRestArguments, } from "./call-arguments-helpers.js";
@@ -63,8 +66,7 @@ const NUMERIC_BINDING_CLR_NAMES = new Set([
 ]);
 const getFunctionValueSignature = (expr, context) => {
     if (expr.callee.kind === "identifier") {
-        const localType = context.localSemanticTypes?.get(expr.callee.name) ??
-            context.localValueTypes?.get(expr.callee.name);
+        const localType = context.localSemanticTypes?.get(expr.callee.name);
         const resolvedLocalType = resolveFunctionType(localType, context);
         if (resolvedLocalType) {
             return resolvedLocalType;
@@ -187,6 +189,36 @@ const resolveCarrierPassThroughArgumentType = (arg, valueAst, expectedType, cont
     }
     return resolveCarrierPreservingSourceType(carrierType, expectedType, context);
 };
+const tryEmitSelectedRuntimeCarrierSourceAst = (opts) => {
+    const { arg, expectedType, selectedSourceMemberNs, context } = opts;
+    if (!expectedType ||
+        !selectedSourceMemberNs ||
+        selectedSourceMemberNs.size === 0 ||
+        !willCarryAsRuntimeUnion(expectedType, context)) {
+        return undefined;
+    }
+    const narrowedMemberNs = resolveRuntimeSubsetMemberNs(arg, context);
+    if (!narrowedMemberNs ||
+        !intersectSelectedSourceMemberNs(narrowedMemberNs, selectedSourceMemberNs)) {
+        return undefined;
+    }
+    const carrierAst = resolveRuntimeCarrierCompatibleExpressionAst({
+        expr: arg,
+        context,
+    });
+    const carrierType = resolveRuntimeCarrierCompatibleIrType({ expr: arg, context }) ??
+        resolveDirectStorageCompatibleIrType({ expr: arg, context });
+    if (!carrierAst ||
+        !carrierType ||
+        !willCarryAsRuntimeUnion(stripNullish(carrierType), context)) {
+        return undefined;
+    }
+    return {
+        ast: carrierAst,
+        context,
+        actualType: carrierType,
+    };
+};
 const resolveContextualAdaptedArgumentType = (valueAst, contextualExpectedType, context) => {
     if (!contextualExpectedType) {
         return undefined;
@@ -410,6 +442,43 @@ const intersectSelectedSourceMemberNs = (left, right) => {
     const intersection = new Set(Array.from(left).filter((memberN) => right.has(memberN)));
     return intersection.size > 0 ? intersection : undefined;
 };
+const runtimeUnionCarrierSurfacesDiffer = (actualType, expectedType, context) => {
+    if (!actualType || !expectedType) {
+        return false;
+    }
+    const [actualLayout, actualLayoutContext] = buildRuntimeUnionLayout(stripNullish(actualType), context, emitTypeAst);
+    const [expectedLayout] = buildRuntimeUnionLayout(stripNullish(expectedType), actualLayoutContext, emitTypeAst);
+    if (!actualLayout || !expectedLayout) {
+        return false;
+    }
+    return !sameTypeAstSurface(buildRuntimeUnionTypeAst(actualLayout), buildRuntimeUnionTypeAst(expectedLayout));
+};
+const hasErasedStructuralViewReceiver = (callee) => callee.kind === "memberAccess" && callee.object.kind === "asinterface";
+const mustMaterializeSourceBackedStructuralSurface = (opts) => {
+    const { expr, surfaceExpectedType, context } = opts;
+    if (!surfaceExpectedType ||
+        !expr.sourceBackedSurfaceParameterTypes ||
+        !hasErasedStructuralViewReceiver(expr.callee)) {
+        return false;
+    }
+    const resolvedSurface = resolveTypeAlias(stripNullish(surfaceExpectedType), context);
+    return (resolvedSurface.kind === "unionType" ||
+        willCarryAsRuntimeUnion(resolvedSurface, context));
+};
+const shouldSkipRuntimeUnionArgumentMaterialization = (opts) => {
+    const { forceRuntimeUnionArgumentMaterialization, carrierPassThroughArgumentType, carrierPassThroughType, exactFinalExpectedArgumentType, materializationActualArgumentType, adaptationExpectedType, context, } = opts;
+    if (forceRuntimeUnionArgumentMaterialization) {
+        return false;
+    }
+    if (exactFinalExpectedArgumentType) {
+        return !runtimeUnionCarrierSurfacesDiffer(materializationActualArgumentType, adaptationExpectedType, context);
+    }
+    const passThroughType = carrierPassThroughArgumentType ?? carrierPassThroughType;
+    if (!passThroughType) {
+        return false;
+    }
+    return !runtimeUnionCarrierSurfacesDiffer(passThroughType, adaptationExpectedType, context);
+};
 const resolveSelectedSourceMemberNs = (arg, selectedExpectedType, finalExpectedType, surfaceExpectedType, context) => intersectSelectedSourceMemberNs(resolveRuntimeSubsetMemberNs(arg, context), resolveSurfaceSelectedSourceMemberNs(selectedExpectedType, finalExpectedType, surfaceExpectedType, context));
 const resolveAdaptationExpectedType = (selectedExpectedType, finalExpectedType, surfaceExpectedType, context) => {
     if (!finalExpectedType) {
@@ -569,13 +638,18 @@ const shouldDeferStructuralObjectArgumentMaterialization = (opts) => {
         expectedProps.length > 0);
 };
 const selectAdaptationActualArgumentType = (opts) => {
-    const { carrierPassThroughType, exactFinalExpectedArgumentType, directStorageArgumentType, contextualAdaptedActualType, resolvedFunctionArgumentType, effectiveArgumentType, inferredArgumentType, selectedSourceMemberNs, context, } = opts;
+    const { carrierPassThroughType, exactFinalExpectedArgumentType, directStorageArgumentType, contextualAdaptedActualType, resolvedFunctionArgumentType, effectiveArgumentType, inferredArgumentType, expectedType, selectedSourceMemberNs, context, } = opts;
     if (carrierPassThroughType) {
         return carrierPassThroughType;
     }
     if (exactFinalExpectedArgumentType) {
         return exactFinalExpectedArgumentType;
     }
+    if (effectiveArgumentType &&
+        expectedType &&
+        areIrTypesEquivalent(stripNullish(effectiveArgumentType), stripNullish(expectedType), context)) {
+        return effectiveArgumentType;
+    }
     if (selectedSourceMemberNs &&
         selectedSourceMemberNs.size > 0 &&
         effectiveArgumentType &&
@@ -609,6 +683,11 @@ const selectCollectionMaterializationActualArgumentType = (opts) => {
     if (!expectedType) {
         return selectedActualType;
     }
+    if (selectedActualType &&
+        (runtimeUnionAliasReferencesMatch(selectedActualType, expectedType, context) ||
+            resolveCarrierPreservingSourceType(selectedActualType, expectedType, context))) {
+        return selectedActualType;
+    }
     const sourceBackedReturnType = arg.kind === "call" || arg.kind === "new"
         ? arg.sourceBackedReturnType
         : undefined;
@@ -960,7 +1039,6 @@ const resolveActualFunctionTypeForArgument = (arg, context) => {
     };
     if (arg.kind === "identifier") {
         return trimToDeclaredArity(resolveFunctionType(context.localSemanticTypes?.get(arg.name) ??
-            context.localValueTypes?.get(arg.name) ??
             context.valueSymbols?.get(arg.name)?.type ??
             arg.inferredType, context));
     }
@@ -1202,18 +1280,33 @@ const emitFunctionValueCallArguments = (args, signature, expr, context) => {
                             finalExpectedType: adaptationExpectedType,
                             context: currentContext,
                         }));
+            const contextualRawEmitExpectedTypeCandidate = arg.kind === "arrowFunction" || arg.kind === "functionExpression"
+                ? (surfaceParameterType ??
+                    selectedParameterType ??
+                    rawEmitExpectedTypeCandidate ??
+                    contextualExpectedType ??
+                    adaptationExpectedType ??
+                    finalExpectedType ??
+                    selectedExpectedType)
+                : rawEmitExpectedTypeCandidate;
             const rawEmitExpectedType = shouldDeferStructuralObjectArgumentMaterialization({
                 arg,
-                rawExpectedType: rawEmitExpectedTypeCandidate,
+                rawExpectedType: contextualRawEmitExpectedTypeCandidate,
                 context: currentContext,
             })
                 ? undefined
-                : rawEmitExpectedTypeCandidate;
+                : contextualRawEmitExpectedTypeCandidate;
             const carrierPassThroughArgument = tryEmitCarrierPreservingExpressionAst({
                 expr: arg,
                 expectedType: adaptationExpectedType,
                 context: currentContext,
             });
+            const selectedCarrierSourceArgument = tryEmitSelectedRuntimeCarrierSourceAst({
+                arg,
+                expectedType: adaptationExpectedType,
+                selectedSourceMemberNs,
+                context: currentContext,
+            });
             const concreteArrayLiteralRawExpectedType = arg.kind === "array"
                 ? resolveConcreteArrayLiteralContextType(rawEmitExpectedType ??
                     adaptationExpectedType ??
@@ -1224,7 +1317,12 @@ const emitFunctionValueCallArguments = (args, signature, expr, context) => {
                 : undefined;
             const [rawArgAst, rawArgCtx] = carrierPassThroughArgument
                 ? [carrierPassThroughArgument.ast, carrierPassThroughArgument.context]
-                : emitExpressionAst(arg, currentContext, concreteArrayLiteralRawExpectedType ?? rawEmitExpectedType);
+                : selectedCarrierSourceArgument
+                    ? [
+                        selectedCarrierSourceArgument.ast,
+                        selectedCarrierSourceArgument.context,
+                    ]
+                    : emitExpressionAst(arg, currentContext, concreteArrayLiteralRawExpectedType ?? rawEmitExpectedType);
             const carrierPassThroughType = resolveCarrierPassThroughArgumentType(arg, rawArgAst, adaptationExpectedType, rawArgCtx);
             const directStorageArgumentType = resolveDirectStorageCompatibleExpressionType({
                 expr: arg,
@@ -1243,6 +1341,7 @@ const emitFunctionValueCallArguments = (args, signature, expr, context) => {
             const postEmitEffectiveArgumentType = resolveEffectiveExpressionType(arg, rawArgCtx);
             const effectiveArgumentType = postEmitEffectiveArgumentType ?? preEmitActualArgumentType;
             const actualArgumentType = carrierPassThroughArgument?.actualType ??
+                selectedCarrierSourceArgument?.actualType ??
                 selectAdaptationActualArgumentType({
                     carrierPassThroughType,
                     exactFinalExpectedArgumentType,
@@ -1251,6 +1350,7 @@ const emitFunctionValueCallArguments = (args, signature, expr, context) => {
                     resolvedFunctionArgumentType: resolveActualFunctionTypeForArgument(arg, rawArgCtx),
                     effectiveArgumentType,
                     inferredArgumentType: arg.inferredType,
+                    expectedType: adaptationExpectedType,
                     selectedSourceMemberNs,
                     context: rawArgCtx,
                 });
@@ -1261,17 +1361,44 @@ const emitFunctionValueCallArguments = (args, signature, expr, context) => {
                 expectedType: adaptationExpectedType,
                 context: rawArgCtx,
             });
-            const [materializedArgAst, materializedArgCtx] = carrierPassThroughArgument ||
-                carrierPassThroughType ||
-                exactFinalExpectedArgumentType
-                ? [rawArgAst, rawArgCtx]
-                : (adaptValueToExpectedTypeAst({
-                    valueAst: rawArgAst,
-                    actualType: materializationActualArgumentType,
-                    context: rawArgCtx,
-                    expectedType: adaptationExpectedType,
-                    selectedSourceMemberNs,
-                }) ?? [rawArgAst, rawArgCtx]);
+            const forceRuntimeUnionArgumentMaterialization = mustMaterializeSourceBackedStructuralSurface({
+                expr,
+                surfaceExpectedType: surfaceParameterType,
+                context: rawArgCtx,
+            });
+            const forcedRuntimeUnionSourceType = effectiveArgumentType ??
+                preEmitStorageAwareArgumentType ??
+                preEmitActualArgumentType ??
+                arg.inferredType ??
+                materializationActualArgumentType;
+            const skipRuntimeUnionArgumentMaterialization = shouldSkipRuntimeUnionArgumentMaterialization({
+                forceRuntimeUnionArgumentMaterialization,
+                carrierPassThroughArgumentType: carrierPassThroughArgument?.actualType,
+                carrierPassThroughType,
+                exactFinalExpectedArgumentType,
+                materializationActualArgumentType,
+                adaptationExpectedType,
+                context: rawArgCtx,
+            });
+            const forcedRuntimeUnionArgument = forceRuntimeUnionArgumentMaterialization &&
+                adaptationExpectedType &&
+                forcedRuntimeUnionSourceType
+                ? tryBuildRuntimeMaterializationAst(rawArgAst, forcedRuntimeUnionSourceType, adaptationExpectedType, rawArgCtx, emitTypeAst, selectedSourceMemberNs)
+                : undefined;
+            if (forceRuntimeUnionArgumentMaterialization &&
+                !forcedRuntimeUnionArgument) {
+                throw new Error("Internal Compiler Error: source-backed structural call argument could not be materialized to its runtime surface.");
+            }
+            const [materializedArgAst, materializedArgCtx] = forcedRuntimeUnionArgument ??
+                (skipRuntimeUnionArgumentMaterialization
+                    ? [rawArgAst, rawArgCtx]
+                    : (adaptValueToExpectedTypeAst({
+                        valueAst: rawArgAst,
+                        actualType: materializationActualArgumentType,
+                        context: rawArgCtx,
+                        expectedType: adaptationExpectedType,
+                        selectedSourceMemberNs,
+                    }) ?? [rawArgAst, rawArgCtx]));
             const numericActualArgumentType = selectPostMaterializationNumericCastArgumentType({
                 rawArgAst,
                 materializedArgAst,
@@ -1391,6 +1518,16 @@ const selectDeterministicUnionParameterMember = (expectedType, arg, context) =>
     if (!actualType) {
         return expectedType;
     }
+    if (runtimeUnionAliasReferencesMatch(actualType, expectedType, context) ||
+        (arg.kind === "identifier" &&
+            (() => {
+                const narrowed = context.narrowedBindings?.get(arg.name);
+                return (narrowed?.kind === "expr" &&
+                    narrowed.type !== undefined &&
+                    runtimeUnionAliasReferencesMatch(narrowed.type, expectedType, context));
+            })())) {
+        return expectedType;
+    }
     const expectedNullishSplit = splitRuntimeNullishUnionMembers(expectedType);
     const actualIsExplicitRuntimeNullish = actualType.kind === "primitiveType" &&
         (actualType.name === "undefined" || actualType.name === "null");
@@ -1657,7 +1794,7 @@ const emitCallArguments = (args, expr, context, parameterTypeOverrides) => {
             resolveFinalCallArgumentExpectedType(expectedType, normalizedRuntime, preEmitStorageAwareArgumentType, currentContext) ??
             contextualExpectedType;
         const adaptationExpectedType = resolveAdaptationExpectedType(expectedType, finalExpectedType, surfaceParameterType, currentContext);
-        const selectedSourceMemberNs = resolveSurfaceSelectedSourceMemberNs(expectedType, finalExpectedType, surfaceParameterType, currentContext);
+        const selectedSourceMemberNs = resolveSelectedSourceMemberNs(arg, expectedType, finalExpectedType, surfaceParameterType, currentContext);
         const rawEmitExpectedTypeCandidate = explicitNullishSurfaceExpectedType ??
             (shouldPreserveOptionalSurfaceRawEmission({
                 arg,
@@ -1681,13 +1818,22 @@ const emitCallArguments = (args, expr, context, parameterTypeOverrides) => {
                         finalExpectedType: adaptationExpectedType,
                         context: currentContext,
                     }));
+        const contextualRawEmitExpectedTypeCandidate = arg.kind === "arrowFunction" || arg.kind === "functionExpression"
+            ? (surfaceParameterType ??
+                selectedParameterTypes[i] ??
+                rawEmitExpectedTypeCandidate ??
+                contextualExpectedType ??
+                adaptationExpectedType ??
+                finalExpectedType ??
+                expectedType)
+            : rawEmitExpectedTypeCandidate;
         const rawEmitExpectedType = shouldDeferStructuralObjectArgumentMaterialization({
             arg,
-            rawExpectedType: rawEmitExpectedTypeCandidate,
+            rawExpectedType: contextualRawEmitExpectedTypeCandidate,
             context: currentContext,
         })
             ? undefined
-            : rawEmitExpectedTypeCandidate;
+            : contextualRawEmitExpectedTypeCandidate;
         if (arg.kind === "spread") {
             const [spreadAst, ctx] = emitExpressionAst(arg.expression, currentContext);
             argAsts.push(spreadAst);
@@ -1721,6 +1867,12 @@ const emitCallArguments = (args, expr, context, parameterTypeOverrides) => {
                     expectedType: adaptationExpectedType,
                     context: currentContext,
                 });
+                const selectedCarrierSourceArgument = tryEmitSelectedRuntimeCarrierSourceAst({
+                    arg,
+                    expectedType: adaptationExpectedType,
+                    selectedSourceMemberNs,
+                    context: currentContext,
+                });
                 const concreteArrayLiteralRawExpectedType = arg.kind === "array"
                     ? resolveConcreteArrayLiteralContextType(rawEmitExpectedType ??
                         adaptationExpectedType ??
@@ -1731,7 +1883,12 @@ const emitCallArguments = (args, expr, context, parameterTypeOverrides) => {
                     : undefined;
                 const [rawArgAst, emittedContext] = carrierPassThroughArgument
                     ? [carrierPassThroughArgument.ast, carrierPassThroughArgument.context]
-                    : emitExpressionAst(arg, currentContext, concreteArrayLiteralRawExpectedType ?? rawEmitExpectedType);
+                    : selectedCarrierSourceArgument
+                        ? [
+                            selectedCarrierSourceArgument.ast,
+                            selectedCarrierSourceArgument.context,
+                        ]
+                        : emitExpressionAst(arg, currentContext, concreteArrayLiteralRawExpectedType ?? rawEmitExpectedType);
                 const carrierPassThroughType = resolveCarrierPassThroughArgumentType(arg, rawArgAst, adaptationExpectedType, emittedContext);
                 const directStorageArgumentType = resolveDirectStorageCompatibleExpressionType({
                     expr: arg,
@@ -1750,6 +1907,7 @@ const emitCallArguments = (args, expr, context, parameterTypeOverrides) => {
                 const postEmitEffectiveArgumentType = resolveEffectiveExpressionType(arg, emittedContext);
                 const effectiveArgumentType = postEmitEffectiveArgumentType ?? preEmitEffectiveArgumentType;
                 const actualArgumentType = carrierPassThroughArgument?.actualType ??
+                    selectedCarrierSourceArgument?.actualType ??
                     selectAdaptationActualArgumentType({
                         carrierPassThroughType,
                         exactFinalExpectedArgumentType,
@@ -1758,6 +1916,8 @@ const emitCallArguments = (args, expr, context, parameterTypeOverrides) => {
                         resolvedFunctionArgumentType: resolveActualFunctionTypeForArgument(arg, emittedContext),
                         effectiveArgumentType,
                         inferredArgumentType: arg.inferredType,
+                        expectedType: adaptationExpectedType,
+                        selectedSourceMemberNs,
                         context: emittedContext,
                     });
                 const materializationActualArgumentType = selectCollectionMaterializationActualArgumentType({
@@ -1767,17 +1927,58 @@ const emitCallArguments = (args, expr, context, parameterTypeOverrides) => {
                     expectedType: adaptationExpectedType,
                     context: emittedContext,
                 });
-                const [materializedArgAst, materializedContext] = carrierPassThroughArgument ||
-                    carrierPassThroughType ||
-                    exactFinalExpectedArgumentType
-                    ? [rawArgAst, emittedContext]
-                    : (adaptValueToExpectedTypeAst({
-                        valueAst: rawArgAst,
-                        actualType: materializationActualArgumentType,
-                        context: emittedContext,
+                const forceRuntimeUnionArgumentMaterialization = mustMaterializeSourceBackedStructuralSurface({
+                    expr,
+                    surfaceExpectedType: surfaceParameterType,
+                    context: emittedContext,
+                });
+                const forcedRuntimeUnionSourceType = effectiveArgumentType ??
+                    preEmitStorageAwareArgumentType ??
+                    preEmitEffectiveArgumentType ??
+                    arg.inferredType ??
+                    materializationActualArgumentType;
+                const skipRuntimeUnionArgumentMaterialization = shouldSkipRuntimeUnionArgumentMaterialization({
+                    forceRuntimeUnionArgumentMaterialization,
+                    carrierPassThroughArgumentType: carrierPassThroughArgument?.actualType,
+                    carrierPassThroughType,
+                    exactFinalExpectedArgumentType,
+                    materializationActualArgumentType,
+                    adaptationExpectedType,
+                    context: emittedContext,
+                });
+                const forcedRuntimeUnionArgument = forceRuntimeUnionArgumentMaterialization &&
+                    adaptationExpectedType &&
+                    forcedRuntimeUnionSourceType
+                    ? tryBuildRuntimeMaterializationAst(rawArgAst, forcedRuntimeUnionSourceType, adaptationExpectedType, emittedContext, emitTypeAst, selectedSourceMemberNs)
+                    : undefined;
+                if (forceRuntimeUnionArgumentMaterialization &&
+                    !forcedRuntimeUnionArgument) {
+                    throw new Error("Internal Compiler Error: source-backed structural call argument could not be materialized to its runtime surface.");
+                }
+                const awaitableArgumentSourceType = preEmitStorageAwareArgumentType ??
+                    preEmitEffectiveArgumentType ??
+                    effectiveArgumentType ??
+                    arg.inferredType;
+                const awaitableArgument = adaptationExpectedType && awaitableArgumentSourceType
+                    ? tryAdaptAwaitableValueAst({
+                        ast: rawArgAst,
+                        actualType: awaitableArgumentSourceType,
                         expectedType: adaptationExpectedType,
-                        selectedSourceMemberNs,
-                    }) ?? [rawArgAst, emittedContext]);
+                        context: emittedContext,
+                        adaptAwaitedValueAst: maybeAdaptRuntimeUnionExpressionAst,
+                    })
+                    : undefined;
+                const [materializedArgAst, materializedContext] = forcedRuntimeUnionArgument ??
+                    awaitableArgument ??
+                    (skipRuntimeUnionArgumentMaterialization
+                        ? [rawArgAst, emittedContext]
+                        : (adaptValueToExpectedTypeAst({
+                            valueAst: rawArgAst,
+                            actualType: materializationActualArgumentType,
+                            context: emittedContext,
+                            expectedType: adaptationExpectedType,
+                            selectedSourceMemberNs,
+                        }) ?? [rawArgAst, emittedContext]));
                 const numericActualArgumentType = selectPostMaterializationNumericCastArgumentType({
                     rawArgAst,
                     materializedArgAst,