@tsonic/emitter 0.0.73 → 0.0.75

package/dist/expressions/calls/call-emitter.js

@@ -1,1941 +1,239 @@
 /**
- * Call expression emitter
+ * Call expression emitter — main dispatch and orchestration.
+ *
+ * Routes call expressions to specialized emitters (promise, array interop,
+ * dynamic import, JSON, extension methods) and handles the default regular-call path.
+ *
+ * Extension method lowering lives in:
+ *   - call-extension-methods.ts
  */
-import { getAwaitedIrType, isAwaitableIrType, } from "@tsonic/frontend";
 import { emitExpressionAst } from "../../expression-emitter.js";
 import { emitTypeArgumentsAst, generateSpecializedName, } from "../identifiers.js";
 import { emitTypeAst } from "../../type-emitter.js";
 import { emitMemberAccess } from "../access.js";
-import { isLValue, getPassingModifierFromCast, isJsonSerializerCall, isGlobalJsonCall, isInstanceMemberAccess, shouldEmitFluentExtensionCall, getTypeNamespace, registerJsonAotExpressionTypes, registerJsonAotType, needsIntCast, isPromiseChainMethod, isAsyncWrapperType, } from "./call-analysis.js";
+import { isJsonSerializerCall, isGlobalJsonCall, isInstanceMemberAccess, needsIntCast, } from "./call-analysis.js";
 import { extractCalleeNameFromAst } from "../../core/format/backend-ast/utils.js";
-import { resolveImportPath } from "../../core/semantic/index.js";
-import { containsTypeParameter } from "../../core/semantic/type-resolution.js";
-import { allocateLocalName } from "../../core/format/local-names.js";
-/**
- * Wrap an expression AST with an optional argument modifier (ref/out/in).
- */
-const wrapArgModifier = (modifier, expr) => modifier
-    ? { kind: "argumentModifierExpression", modifier, expression: expr }
-    : expr;
-/**
- * Wrap an invocation AST with an optional (int) cast.
- */
-const wrapIntCast = (needsCast, expr) => needsCast
-    ? {
-        kind: "castExpression",
-        type: { kind: "predefinedType", keyword: "int" },
-        expression: expr,
-    }
-    : expr;
-const stripClrGenericArity = (typeName) => typeName.replace(/`\d+$/, "");
-const nativeArrayMutationMembers = new Set([
-    "push",
-    "pop",
-    "shift",
-    "unshift",
-    "splice",
-    "sort",
-    "reverse",
-    "fill",
-    "copyWithin",
-]);
-const returnsMutatedArrayMember = (memberName) => memberName === "sort" ||
-    memberName === "reverse" ||
-    memberName === "fill" ||
-    memberName === "copyWithin";
-const createVarLocal = (name, initializer) => ({
-    kind: "localDeclarationStatement",
-    modifiers: [],
-    type: { kind: "varType" },
-    declarators: [{ name, initializer }],
-});
-const captureAssignableArrayTarget = (expr, context) => {
-    const [receiverAst, receiverContext] = emitExpressionAst(expr, context);
-    if (receiverAst.kind === "identifierExpression") {
-        return {
-            readExpression: receiverAst,
-            writeExpression: receiverAst,
-            setupStatements: [],
-            context: receiverContext,
-        };
-    }
-    if (receiverAst.kind === "memberAccessExpression") {
-        const objectTemp = allocateLocalName("__tsonic_arrayTarget", receiverContext);
-        const objectIdentifier = {
-            kind: "identifierExpression",
-            identifier: objectTemp.emittedName,
-        };
-        return {
-            readExpression: {
-                kind: "memberAccessExpression",
-                expression: objectIdentifier,
-                memberName: receiverAst.memberName,
-            },
-            writeExpression: {
-                kind: "memberAccessExpression",
-                expression: objectIdentifier,
-                memberName: receiverAst.memberName,
-            },
-            setupStatements: [
-                createVarLocal(objectTemp.emittedName, receiverAst.expression),
-            ],
-            context: objectTemp.context,
-        };
-    }
-    if (receiverAst.kind === "elementAccessExpression" &&
-        receiverAst.arguments.length === 1) {
-        const objectTemp = allocateLocalName("__tsonic_arrayTarget", receiverContext);
-        const indexTemp = allocateLocalName("__tsonic_arrayIndex", objectTemp.context);
-        const objectIdentifier = {
-            kind: "identifierExpression",
-            identifier: objectTemp.emittedName,
-        };
-        const indexIdentifier = {
-            kind: "identifierExpression",
-            identifier: indexTemp.emittedName,
-        };
-        return {
-            readExpression: {
-                kind: "elementAccessExpression",
-                expression: objectIdentifier,
-                arguments: [indexIdentifier],
-            },
-            writeExpression: {
-                kind: "elementAccessExpression",
-                expression: objectIdentifier,
-                arguments: [indexIdentifier],
-            },
-            setupStatements: [
-                createVarLocal(objectTemp.emittedName, receiverAst.expression),
-                createVarLocal(indexTemp.emittedName, receiverAst.arguments[0]),
-            ],
-            context: indexTemp.context,
-        };
-    }
-    return undefined;
-};
-const emitArrayMutationInteropCall = (expr, context) => {
-    if (expr.isOptional)
-        return undefined;
-    if (expr.callee.kind !== "memberAccess")
-        return undefined;
-    if (expr.callee.isComputed)
-        return undefined;
-    if (typeof expr.callee.property !== "string")
-        return undefined;
-    if (!nativeArrayMutationMembers.has(expr.callee.property))
-        return undefined;
-    if (!isLValue(expr.callee.object))
-        return undefined;
-    const binding = expr.callee.memberBinding;
-    if (!binding || binding.isExtensionMethod)
-        return undefined;
-    const receiverType = expr.callee.object.inferredType;
-    if (!receiverType || receiverType.kind !== "arrayType")
-        return undefined;
-    const captured = captureAssignableArrayTarget(expr.callee.object, context);
-    if (!captured)
-        return undefined;
-    let currentContext = captured.context;
-    const [elementTypeAst, elementTypeContext] = emitTypeAst(receiverType.elementType, currentContext);
-    currentContext = elementTypeContext;
-    const wrapperTemp = allocateLocalName("__tsonic_arrayWrapper", currentContext);
-    currentContext = wrapperTemp.context;
-    const resultTemp = allocateLocalName("__tsonic_arrayResult", currentContext);
-    currentContext = resultTemp.context;
-    const wrapperIdentifier = {
-        kind: "identifierExpression",
-        identifier: wrapperTemp.emittedName,
-    };
-    const resultIdentifier = {
-        kind: "identifierExpression",
-        identifier: resultTemp.emittedName,
-    };
-    const [argAsts, argContext] = emitCallArguments(expr.arguments, expr, currentContext);
-    currentContext = argContext;
-    const mutationCall = {
-        kind: "invocationExpression",
-        expression: {
-            kind: "memberAccessExpression",
-            expression: wrapperIdentifier,
-            memberName: binding.member,
-        },
-        arguments: argAsts,
-    };
-    const mutatedArrayAst = {
-        kind: "invocationExpression",
-        expression: {
-            kind: "memberAccessExpression",
-            expression: wrapperIdentifier,
-            memberName: "toArray",
-        },
-        arguments: [],
-    };
-    let returnExpression = resultIdentifier;
-    if (expr.callee.property === "splice") {
-        returnExpression = {
-            kind: "invocationExpression",
-            expression: {
-                kind: "memberAccessExpression",
-                expression: resultIdentifier,
-                memberName: "toArray",
-            },
-            arguments: [],
-        };
-    }
-    else if (returnsMutatedArrayMember(expr.callee.property)) {
-        returnExpression = mutatedArrayAst;
-    }
-    const returnType = expr.inferredType ?? receiverType;
-    const [returnTypeAst, returnTypeContext] = emitTypeAst(returnType, currentContext);
-    currentContext = returnTypeContext;
-    const lambdaAst = {
-        kind: "lambdaExpression",
-        isAsync: false,
-        parameters: [],
-        body: {
-            kind: "blockStatement",
-            statements: [
-                ...captured.setupStatements,
-                createVarLocal(wrapperTemp.emittedName, {
-                    kind: "objectCreationExpression",
-                    type: {
-                        kind: "identifierType",
-                        name: "global::Tsonic.JSRuntime.JSArray",
-                        typeArguments: [elementTypeAst],
-                    },
-                    arguments: [captured.readExpression],
-                }),
-                createVarLocal(resultTemp.emittedName, mutationCall),
-                {
-                    kind: "expressionStatement",
-                    expression: {
-                        kind: "assignmentExpression",
-                        operatorToken: "=",
-                        left: captured.writeExpression,
-                        right: mutatedArrayAst,
-                    },
-                },
-                {
-                    kind: "returnStatement",
-                    expression: returnExpression,
-                },
-            ],
-        },
-    };
-    const delegateCastAst = {
-        kind: "castExpression",
-        type: buildDelegateType([], returnTypeAst),
-        expression: {
-            kind: "parenthesizedExpression",
-            expression: lambdaAst,
-        },
-    };
-    return [
-        wrapIntCast(needsIntCast(expr, expr.callee.property), {
-            kind: "invocationExpression",
-            expression: {
-                kind: "parenthesizedExpression",
-                expression: delegateCastAst,
-            },
-            arguments: [],
-        }),
-        currentContext,
-    ];
-};
-const emitArrayWrapperInteropCall = (expr, context) => {
-    if (expr.isOptional)
-        return undefined;
-    if (expr.callee.kind !== "memberAccess")
-        return undefined;
-    if (expr.callee.isComputed)
-        return undefined;
-    if (typeof expr.callee.property !== "string")
-        return undefined;
-    const binding = expr.callee.memberBinding;
-    if (!binding || binding.isExtensionMethod)
-        return undefined;
-    const receiverType = expr.callee.object.inferredType;
-    if (!receiverType || receiverType.kind !== "arrayType")
-        return undefined;
-    const bindingType = binding.type;
-    if (bindingType === "System.Array" ||
-        bindingType === "global::System.Array" ||
-        bindingType.startsWith("System.Array`") ||
-        bindingType.startsWith("global::System.Array`")) {
-        return undefined;
+import { identifierExpression, identifierType, } from "../../core/format/backend-ast/builders.js";
+import { normalizeClrQualifiedName } from "../../core/format/backend-ast/utils.js";
+import { resolveStructuralViewMethodSurface } from "../../core/semantic/structural-view-types.js";
+// Import from split modules
+import { emitDynamicImportCall } from "./call-dynamic-import.js";
+import { emitJsonSerializerCall, emitGlobalJsonCall } from "./call-json.js";
+import { emitGlobalSymbolCall } from "./call-symbol.js";
+import { emitPromiseStaticCall, emitPromiseThenCatchFinally, buildDelegateType, } from "./call-promise.js";
+import { emitArrayMutationInteropCall, emitArrayWrapperInteropCall, } from "./call-array-interop.js";
+import { emitRuntimeUnionArrayIsArrayCall } from "./call-runtime-union-guards.js";
+import { emitCallArguments, wrapIntCast } from "./call-arguments.js";
+import { tryEmitExtensionMethodCall } from "./call-extension-methods.js";
+import { stripClrGenericArity } from "../access-resolution.js";
+const buildCallTargetExpectedType = (expr, preferParameterTypes = false) => {
+    const calleeType = expr.callee.inferredType;
+    if (!preferParameterTypes && calleeType?.kind === "functionType") {
+        return calleeType;
     }
-    const arityText = bindingType.match(/`(\d+)$/)?.[1];
-    const genericArity = arityText ? Number.parseInt(arityText, 10) : 0;
-    if (genericArity > 1)
+    const parameterTypes = expr.parameterTypes ?? expr.surfaceParameterTypes;
+    const restParameter = expr.restParameter ?? expr.surfaceRestParameter;
+    if (!parameterTypes || !expr.inferredType) {
         return undefined;
-    let currentContext = context;
-    const [receiverAst, receiverContext] = emitExpressionAst(expr.callee.object, currentContext);
-    currentContext = receiverContext;
-    let typeArguments;
-    if (genericArity === 1) {
-        const [elementTypeAst, elementTypeContext] = emitTypeAst(receiverType.elementType, currentContext);
-        currentContext = elementTypeContext;
-        typeArguments = [elementTypeAst];
     }
-    const wrapperAst = {
-        kind: "objectCreationExpression",
-        type: {
-            kind: "identifierType",
-            name: `global::${stripClrGenericArity(bindingType)}`,
-            typeArguments,
-        },
-        arguments: [receiverAst],
-    };
-    const [argAsts, argContext] = emitCallArguments(expr.arguments, expr, currentContext);
-    currentContext = argContext;
-    const invocation = {
-        kind: "invocationExpression",
-        expression: {
-            kind: "memberAccessExpression",
-            expression: wrapperAst,
-            memberName: binding.member,
-        },
-        arguments: argAsts,
-    };
-    const resultAst = expr.inferredType?.kind === "arrayType"
-        ? {
-            kind: "invocationExpression",
-            expression: {
-                kind: "memberAccessExpression",
-                expression: invocation,
-                memberName: "toArray",
+    return {
+        kind: "functionType",
+        parameters: parameterTypes.map((parameterType, index) => ({
+            kind: "parameter",
+            pattern: {
+                kind: "identifierPattern",
+                name: `__tsonic_arg_${index}`,
             },
-            arguments: [],
-        }
-        : invocation;
-    return [
-        wrapIntCast(needsIntCast(expr, expr.callee.property), resultAst),
-        currentContext,
-    ];
-};
-const isTaskTypeAst = (typeAst) => {
-    if (typeAst.kind !== "identifierType")
-        return false;
-    const simple = typeAst.name.includes(".")
-        ? typeAst.name.slice(typeAst.name.lastIndexOf(".") + 1)
-        : typeAst.name;
-    return simple === "Task";
-};
-const containsVoidTypeAst = (typeAst) => {
-    if (typeAst.kind === "predefinedType" && typeAst.keyword === "void") {
-        return true;
-    }
-    if (typeAst.kind === "identifierType") {
-        if (typeAst.name === "void" || typeAst.name.endsWith(".void")) {
-            return true;
-        }
-        return (typeAst.typeArguments ?? []).some((t) => containsVoidTypeAst(t));
-    }
-    if (typeAst.kind === "arrayType") {
-        return containsVoidTypeAst(typeAst.elementType);
-    }
-    if (typeAst.kind === "nullableType") {
-        return containsVoidTypeAst(typeAst.underlyingType);
-    }
-    if (typeAst.kind === "pointerType") {
-        return containsVoidTypeAst(typeAst.elementType);
-    }
-    if (typeAst.kind === "tupleType") {
-        return typeAst.elements.some((e) => containsVoidTypeAst(e.type));
-    }
-    return false;
-};
-const getTaskResultType = (typeAst) => isTaskTypeAst(typeAst) && typeAst.typeArguments?.length === 1
-    ? typeAst.typeArguments[0]
-    : undefined;
-const callbackParameterCount = (callbackExpr) => {
-    if (callbackExpr.kind === "arrowFunction" ||
-        callbackExpr.kind === "functionExpression") {
-        return callbackExpr.parameters.length;
-    }
-    const callbackType = callbackExpr.inferredType;
-    if (callbackType?.kind === "functionType") {
-        return callbackType.parameters.length;
-    }
-    return 1;
-};
-const collectBlockReturnTypes = (block) => {
-    const collectFromStatement = (statement) => {
-        switch (statement.kind) {
-            case "returnStatement":
-                return statement.expression?.inferredType
-                    ? [statement.expression.inferredType]
-                    : [];
-            case "blockStatement":
-                return statement.statements.flatMap(collectFromStatement);
-            case "ifStatement":
-                return [
-                    ...collectFromStatement(statement.thenStatement),
-                    ...(statement.elseStatement
-                        ? collectFromStatement(statement.elseStatement)
-                        : []),
-                ];
-            case "whileStatement":
-            case "forStatement":
-            case "forOfStatement":
-            case "forInStatement":
-                return collectFromStatement(statement.body);
-            case "switchStatement":
-                return statement.cases.flatMap((switchCase) => switchCase.statements.flatMap(collectFromStatement));
-            case "tryStatement":
-                return [
-                    ...statement.tryBlock.statements.flatMap(collectFromStatement),
-                    ...(statement.catchClause
-                        ? statement.catchClause.body.statements.flatMap(collectFromStatement)
-                        : []),
-                    ...(statement.finallyBlock
-                        ? statement.finallyBlock.statements.flatMap(collectFromStatement)
-                        : []),
-                ];
-            case "functionDeclaration":
-            case "classDeclaration":
-            case "interfaceDeclaration":
-            case "enumDeclaration":
-            case "typeAliasDeclaration":
-                return [];
-            default:
-                return [];
-        }
+            type: restParameter && restParameter.index === index
+                ? (restParameter.arrayType ?? parameterType)
+                : parameterType,
+            initializer: undefined,
+            isOptional: false,
+            isRest: restParameter?.index === index,
+            passing: expr.argumentPassing?.[index] ?? "value",
+        })),
+        returnType: expr.inferredType,
     };
-    return block.statements.flatMap(collectFromStatement);
 };
-const getCallbackDelegateReturnType = (callbackExpr) => {
-    if ((callbackExpr.kind === "arrowFunction" ||
-        callbackExpr.kind === "functionExpression") &&
-        callbackExpr.body.kind === "blockStatement") {
-        const returnTypes = collectBlockReturnTypes(callbackExpr.body);
-        const concreteReturnTypes = returnTypes.filter((type) => !isVoidOrUnknownIrType(type));
-        if (concreteReturnTypes.length === 0) {
-            return undefined;
-        }
-        const deduped = concreteReturnTypes.filter((type, index, all) => all.findIndex((candidate) => stableIrTypeKey(candidate) === stableIrTypeKey(type)) === index);
-        if (deduped.length === 1) {
-            return deduped[0];
-        }
-        return {
-            kind: "unionType",
-            types: deduped,
-        };
+const resolveStructuralViewCallParameterTypes = (callee, context) => resolveStructuralViewMethodSurface(callee, context)?.parameterTypes;
+const extractTransparentIdentifier = (expr) => {
+    let current = expr;
+    while (current.kind === "typeAssertion" ||
+        current.kind === "numericNarrowing") {
+        current = current.expression;
     }
-    return getCallbackReturnType(callbackExpr);
+    return current.kind === "identifier" ? current : undefined;
 };
-const callbackReturnsAsyncWrapper = (callbackExpr) => {
-    const delegateReturnType = getCallbackDelegateReturnType(callbackExpr);
-    return delegateReturnType ? isAsyncWrapperType(delegateReturnType) : false;
-};
-const buildInvocation = (expression, args) => ({
-    kind: "invocationExpression",
-    expression,
-    arguments: args,
-});
-const buildAwait = (expression) => ({
-    kind: "awaitExpression",
-    expression,
-});
-const buildDelegateType = (parameterTypes, returnType) => {
-    const isVoidReturn = returnType?.kind === "predefinedType" && returnType.keyword === "void";
-    if (returnType === undefined) {
-        return parameterTypes.length === 0
-            ? { kind: "identifierType", name: "global::System.Action" }
-            : {
-                kind: "identifierType",
-                name: "global::System.Action",
-                typeArguments: parameterTypes,
-            };
+const normalizePromiseResolveCall = (expr, context) => {
+    const transparentCalleeIdentifier = extractTransparentIdentifier(expr.callee);
+    if (!transparentCalleeIdentifier) {
+        return expr;
     }
-    if (isVoidReturn ||
-        (returnType.kind === "identifierType" && returnType.name === "void")) {
-        return parameterTypes.length === 0
-            ? { kind: "identifierType", name: "global::System.Action" }
-            : {
-                kind: "identifierType",
-                name: "global::System.Action",
-                typeArguments: parameterTypes,
-            };
+    const promisedValueType = context.promiseResolveValueTypes?.get(transparentCalleeIdentifier.name);
+    if (!promisedValueType) {
+        return expr;
     }
     return {
-        kind: "identifierType",
-        name: "global::System.Func",
-        typeArguments: [...parameterTypes, returnType],
+        ...expr,
+        callee: transparentCalleeIdentifier,
+        parameterTypes: [promisedValueType],
+        surfaceParameterTypes: [promisedValueType],
+        restParameter: undefined,
+        surfaceRestParameter: undefined,
     };
 };
-const isVoidOrUnknownIrType = (type) => type === undefined ||
-    type.kind === "voidType" ||
-    type.kind === "unknownType" ||
-    (type.kind === "primitiveType" && type.name === "undefined");
-const getCallbackReturnType = (callbackExpr) => {
-    if (callbackExpr.kind === "arrowFunction" &&
-        callbackExpr.body.kind !== "blockStatement" &&
-        !isVoidOrUnknownIrType(callbackExpr.body.inferredType)) {
-        return callbackExpr.body.inferredType;
-    }
-    const declared = callbackExpr.inferredType?.kind === "functionType"
-        ? callbackExpr.inferredType.returnType
-        : undefined;
-    if (!isVoidOrUnknownIrType(declared)) {
-        return declared;
-    }
-    if (callbackExpr.kind === "arrowFunction" &&
-        callbackExpr.body.kind !== "blockStatement") {
-        return callbackExpr.body.inferredType;
-    }
-    return undefined;
-};
-const getFunctionValueSignature = (expr) => {
-    const calleeType = expr.callee.inferredType;
-    if (!calleeType || calleeType.kind !== "functionType")
-        return undefined;
-    if (expr.callee.kind === "identifier" && expr.callee.resolvedClrType) {
+const tryGetCallableStaticAccessorCall = (expr) => {
+    if (expr.callee.kind !== "memberAccess") {
         return undefined;
     }
-    if (expr.callee.kind === "memberAccess" && expr.callee.memberBinding) {
+    const memberBinding = expr.callee.memberBinding;
+    const kind = memberBinding?.emitSemantics?.callableStaticAccessorKind;
+    if (!memberBinding || !kind) {
         return undefined;
     }
-    return calleeType;
-};
-const emitFunctionValueCallArguments = (args, signature, expr, context) => {
-    let currentContext = context;
-    const argAsts = [];
-    const parameters = signature.parameters;
-    const extractTupleRestCandidates = (type) => {
-        if (!type)
-            return undefined;
-        if (type.kind === "tupleType") {
-            return [type.elementTypes];
-        }
-        if (type.kind !== "unionType") {
-            return undefined;
-        }
-        const candidates = [];
-        for (const member of type.types) {
-            if (!member || member.kind !== "tupleType") {
-                return undefined;
-            }
-            candidates.push(member.elementTypes);
-        }
-        return candidates;
-    };
-    const tryEmitTupleRestArguments = (startIndex, parameterType) => {
-        const remainingArgs = args.slice(startIndex);
-        if (remainingArgs.some((arg) => arg?.kind === "spread")) {
-            return undefined;
-        }
-        const tupleCandidates = extractTupleRestCandidates(parameterType);
-        if (!tupleCandidates || tupleCandidates.length === 0) {
-            return undefined;
-        }
-        const matchingCandidates = tupleCandidates.filter((candidate) => candidate.length === remainingArgs.length);
-        if (matchingCandidates.length !== 1) {
-            return undefined;
-        }
-        const tupleElements = matchingCandidates[0] ?? [];
-        const emittedArgs = [];
-        let tupleContext = currentContext;
-        for (let index = 0; index < remainingArgs.length; index++) {
-            const arg = remainingArgs[index];
-            const expectedType = tupleElements[index];
-            if (!arg)
-                continue;
-            const [argAst, argContext] = emitExpressionAst(arg, tupleContext, expectedType);
-            emittedArgs.push(argAst);
-            tupleContext = argContext;
-        }
-        return [emittedArgs, tupleContext];
-    };
-    for (let i = 0; i < parameters.length; i++) {
-        const parameter = parameters[i];
-        if (!parameter)
-            continue;
-        if (parameter.isRest) {
-            const tupleRestResult = tryEmitTupleRestArguments(i, parameter.type);
-            if (tupleRestResult) {
-                const [tupleArgs, tupleContext] = tupleRestResult;
-                argAsts.push(...tupleArgs);
-                currentContext = tupleContext;
-                break;
-            }
-            const spreadArg = args[i];
-            if (args.length === i + 1 && spreadArg && spreadArg.kind === "spread") {
-                const [spreadAst, spreadCtx] = emitExpressionAst(spreadArg.expression, currentContext);
-                argAsts.push(spreadAst);
-                currentContext = spreadCtx;
-                break;
-            }
-            const restElementType = parameter.type?.kind === "arrayType"
-                ? parameter.type.elementType
-                : undefined;
-            let elementTypeAst = {
-                kind: "identifierType",
-                name: "object",
-            };
-            if (restElementType) {
-                const [emittedType, typeCtx] = emitTypeAst(restElementType, currentContext);
-                elementTypeAst = emittedType;
-                currentContext = typeCtx;
-            }
-            const restItems = [];
-            for (let j = i; j < args.length; j++) {
-                const arg = args[j];
-                if (!arg)
-                    continue;
-                if (arg.kind === "spread") {
-                    const [spreadAst, spreadCtx] = emitExpressionAst(arg.expression, currentContext);
-                    argAsts.push(spreadAst);
-                    currentContext = spreadCtx;
-                    return [argAsts, currentContext];
-                }
-                const [argAst, argCtx] = emitExpressionAst(arg, currentContext, restElementType);
-                restItems.push(argAst);
-                currentContext = argCtx;
-            }
-            argAsts.push({
-                kind: "arrayCreationExpression",
-                elementType: elementTypeAst,
-                initializer: restItems,
-            });
-            break;
-        }
-        const arg = args[i];
-        if (arg) {
-            const [argAst, argCtx] = emitExpressionAst(arg, currentContext, parameter.type);
-            const modifier = expr.argumentPassing?.[i] &&
-                expr.argumentPassing[i] !== "value" &&
-                isLValue(arg)
-                ? expr.argumentPassing[i]
-                : undefined;
-            argAsts.push(wrapArgModifier(modifier, argAst));
-            currentContext = argCtx;
-            continue;
-        }
-        if (parameter.isOptional || parameter.initializer) {
-            let defaultType;
-            if (parameter.type) {
-                const [emittedType, typeCtx] = emitTypeAst(parameter.type, currentContext);
-                currentContext = typeCtx;
-                defaultType =
-                    parameter.isOptional || parameter.initializer
-                        ? emittedType.kind === "nullableType"
-                            ? emittedType
-                            : { kind: "nullableType", underlyingType: emittedType }
-                        : emittedType;
-            }
-            argAsts.push({ kind: "defaultExpression", type: defaultType });
-        }
-    }
-    return [argAsts, currentContext];
+    return { kind, binding: memberBinding };
 };
-const isArrayLikeIrType = (type) => {
-    if (!type)
-        return false;
-    if (type.kind === "arrayType" || type.kind === "tupleType") {
-        return true;
+const getCallableStaticAccessorOwnerTypeArgs = (expr, expectedArity) => {
+    if (expectedArity === 0) {
+        return [];
     }
-    if (type.kind === "unionType") {
-        return type.types.every((member) => isArrayLikeIrType(member));
+    if (expr.typeArguments?.length === expectedArity) {
+        return expr.typeArguments;
     }
-    if (type.kind !== "referenceType") {
-        return false;
+    const inferredResult = expr.inferredType;
+    if (inferredResult?.kind === "referenceType" &&
+        inferredResult.typeArguments?.length === expectedArity) {
+        return inferredResult.typeArguments;
     }
-    const simpleName = type.name.split(".").pop() ?? type.name;
-    return (simpleName === "Array" ||
-        simpleName === "ReadonlyArray" ||
-        simpleName === "JSArray" ||
-        simpleName === "Iterable" ||
-        simpleName === "IterableIterator" ||
-        simpleName === "IEnumerable" ||
-        simpleName === "IReadOnlyList" ||
-        simpleName === "List");
+    throw new Error(`Internal Compiler Error: callable static accessor call '${expectedArity}' generic arity could not be specialized from call-site type arguments.`);
 };
-const detectRestParameterInfo = (args, parameterTypes) => {
-    if (parameterTypes.length === 0) {
-        return undefined;
-    }
-    const index = parameterTypes.length - 1;
-    const lastParamType = parameterTypes[index];
-    if (!lastParamType || lastParamType.kind !== "arrayType") {
-        return undefined;
-    }
-    if (args.length > parameterTypes.length) {
-        return {
-            index,
-            arrayType: lastParamType,
-            elementType: lastParamType.elementType,
-        };
-    }
-    const restArgs = args.slice(index);
-    if (restArgs.some((arg) => arg?.kind === "spread")) {
-        return {
-            index,
-            arrayType: lastParamType,
-            elementType: lastParamType.elementType,
-        };
-    }
-    const lastArg = args[index];
-    if (!lastArg) {
-        return undefined;
+const emitCallableStaticAccessorCall = (expr, binding, context) => {
+    if (expr.arguments.length !== 0) {
+        throw new Error(`Internal Compiler Error: callable static accessor '${binding.type}.${binding.member}' was invoked with arguments.`);
     }
-    const lastArgType = lastArg.kind === "spread"
-        ? lastArg.expression.inferredType
-        : lastArg.inferredType;
-    if (!isArrayLikeIrType(lastArgType)) {
-        return {
-            index,
-            arrayType: lastParamType,
-            elementType: lastParamType.elementType,
-        };
+    if (expr.isOptional) {
+        throw new Error(`Internal Compiler Error: callable static accessor '${binding.type}.${binding.member}' cannot be optional.`);
     }
-    return undefined;
-};
-const emitFlattenedRestArguments = (restArgs, restElementType, context) => {
+    const arityText = binding.type.match(/`(\d+)$/)?.[1];
+    const genericArity = arityText ? Number.parseInt(arityText, 10) : 0;
+    const ownerTypeArgs = getCallableStaticAccessorOwnerTypeArgs(expr, genericArity);
     let currentContext = context;
-    const [elementTypeAst, typeContext] = emitTypeAst(restElementType, currentContext);
-    currentContext = typeContext;
-    const segments = [];
-    let inlineElements = [];
-    const flushInlineElements = () => {
-        if (inlineElements.length === 0)
-            return;
-        segments.push({
-            kind: "arrayCreationExpression",
-            elementType: elementTypeAst,
-            initializer: inlineElements,
-        });
-        inlineElements = [];
-    };
-    for (const arg of restArgs) {
-        if (!arg)
-            continue;
-        if (arg.kind === "spread") {
-            flushInlineElements();
-            const [spreadAst, spreadContext] = emitExpressionAst(arg.expression, currentContext);
-            segments.push(spreadAst);
-            currentContext = spreadContext;
-            continue;
-        }
-        const [argAst, argContext] = emitExpressionAst(arg, currentContext, restElementType);
-        inlineElements.push(argAst);
-        currentContext = argContext;
-    }
-    flushInlineElements();
-    if (segments.length === 0) {
-        return [
-            [
-                {
-                    kind: "invocationExpression",
-                    expression: {
-                        kind: "identifierExpression",
-                        identifier: "global::System.Array.Empty",
-                    },
-                    typeArguments: [elementTypeAst],
-                    arguments: [],
-                },
-            ],
-            currentContext,
-        ];
-    }
-    let concatAst = segments[0];
-    for (let index = 1; index < segments.length; index++) {
-        concatAst = {
-            kind: "invocationExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Linq.Enumerable.Concat",
-            },
-            arguments: [concatAst, segments[index]],
-        };
+    const ownerTypeArgAsts = [];
+    for (const typeArgument of ownerTypeArgs) {
+        const [typeArgAst, typeArgContext] = emitTypeAst(typeArgument, currentContext);
+        ownerTypeArgAsts.push(typeArgAst);
+        currentContext = typeArgContext;
     }
+    const ownerTypeAst = identifierType(normalizeClrQualifiedName(stripClrGenericArity(binding.type), true), ownerTypeArgAsts.length > 0 ? ownerTypeArgAsts : undefined);
     return [
-        [
-            {
-                kind: "invocationExpression",
-                expression: {
-                    kind: "identifierExpression",
-                    identifier: "global::System.Linq.Enumerable.ToArray",
-                },
-                arguments: [concatAst],
-            },
-        ],
-        currentContext,
-    ];
-};
-const stableIrTypeKey = (type) => JSON.stringify(type);
-const isAsyncWrapperIrTypeLike = (type) => {
-    return isAwaitableIrType(type);
-};
-const containsPromiseChainArtifact = (type) => {
-    if (!type)
-        return false;
-    if (isAsyncWrapperIrTypeLike(type)) {
-        return true;
-    }
-    if (type.kind === "unionType" || type.kind === "intersectionType") {
-        return type.types.some((member) => !!member && containsPromiseChainArtifact(member));
-    }
-    return false;
-};
-const normalizePromiseChainResultIrType = (type) => {
-    if (!type)
-        return undefined;
-    const awaited = getAwaitedIrType(type);
-    if (awaited) {
-        return awaited.kind === "voidType"
-            ? awaited
-            : normalizePromiseChainResultIrType(awaited);
-    }
-    if (type.kind === "unionType") {
-        const normalizedTypes = [];
-        const seen = new Set();
-        for (const member of type.types) {
-            if (!member)
-                continue;
-            const normalized = normalizePromiseChainResultIrType(member);
-            if (!normalized)
-                continue;
-            const key = stableIrTypeKey(normalized);
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            normalizedTypes.push(normalized);
-        }
-        if (normalizedTypes.length === 0)
-            return undefined;
-        if (normalizedTypes.length === 1)
-            return normalizedTypes[0];
-        return {
-            kind: "unionType",
-            types: normalizedTypes,
-        };
-    }
-    return type;
-};
-const mergePromiseChainResultIrTypes = (...types) => {
-    const merged = [];
-    const seen = new Set();
-    for (const type of types) {
-        const normalized = normalizePromiseChainResultIrType(type);
-        if (!normalized)
-            continue;
-        if (normalized.kind === "unionType") {
-            for (const member of normalized.types) {
-                if (!member)
-                    continue;
-                const key = stableIrTypeKey(member);
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                merged.push(member);
-            }
-            continue;
-        }
-        const key = stableIrTypeKey(normalized);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        merged.push(normalized);
-    }
-    if (merged.length === 0)
-        return undefined;
-    if (merged.length === 1)
-        return merged[0];
-    return {
-        kind: "unionType",
-        types: merged,
-    };
-};
-const buildTaskTypeAst = (resultType) => resultType
-    ? {
-        kind: "identifierType",
-        name: "global::System.Threading.Tasks.Task",
-        typeArguments: [resultType],
-    }
-    : {
-        kind: "identifierType",
-        name: "global::System.Threading.Tasks.Task",
-    };
-const buildTaskRunInvocation = (outputTaskType, body, isAsync) => {
-    const resultType = getTaskResultType(outputTaskType);
-    return {
-        kind: "invocationExpression",
-        expression: {
+        {
             kind: "memberAccessExpression",
             expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Threading.Tasks.Task",
-            },
-            memberName: "Run",
-        },
-        arguments: [
-            {
-                kind: "lambdaExpression",
-                isAsync,
-                parameters: [],
-                body,
-            },
-        ],
-        typeArguments: resultType ? [resultType] : undefined,
-    };
-};
-const buildCompletedTaskAst = () => ({
-    kind: "memberAccessExpression",
-    expression: {
-        kind: "identifierExpression",
-        identifier: "global::System.Threading.Tasks.Task",
-    },
-    memberName: "CompletedTask",
-});
-const buildPromiseRejectedExceptionAst = (reasonAst) => {
-    const reasonExpr = reasonAst ??
-        {
-            kind: "literalExpression",
-            text: "null",
-        };
-    return {
-        kind: "binaryExpression",
-        operatorToken: "??",
-        left: {
-            kind: "asExpression",
-            expression: reasonExpr,
-            type: {
-                kind: "identifierType",
-                name: "global::System.Exception",
-            },
-        },
-        right: {
-            kind: "objectCreationExpression",
-            type: {
-                kind: "identifierType",
-                name: "global::System.Exception",
+                kind: "typeReferenceExpression",
+                type: ownerTypeAst,
             },
-            arguments: [
-                {
-                    kind: "binaryExpression",
-                    operatorToken: "??",
-                    left: {
-                        kind: "invocationExpression",
-                        expression: {
-                            kind: "conditionalMemberAccessExpression",
-                            expression: reasonExpr,
-                            memberName: "ToString",
-                        },
-                        arguments: [],
-                    },
-                    right: {
-                        kind: "literalExpression",
-                        text: '"Promise rejected"',
-                    },
-                },
-            ],
+            memberName: binding.member,
         },
-    };
-};
-const getPromiseStaticMethod = (expr) => {
-    if (expr.callee.kind !== "memberAccess")
-        return undefined;
-    if (expr.callee.isComputed)
-        return undefined;
-    if (typeof expr.callee.property !== "string")
-        return undefined;
-    if (expr.callee.object.kind !== "identifier")
-        return undefined;
-    const objectName = expr.callee.object.originalName ?? expr.callee.object.name;
-    const simpleObjectName = objectName.split(".").pop() ?? objectName;
-    if (simpleObjectName !== "Promise")
-        return undefined;
-    switch (expr.callee.property) {
-        case "resolve":
-        case "reject":
-        case "all":
-        case "race":
-            return expr.callee.property;
-        default:
-            return undefined;
-    }
+        currentContext,
+    ];
 };
-const getSequenceElementIrType = (type) => {
-    if (!type)
-        return undefined;
-    if (type.kind === "arrayType")
-        return type.elementType;
-    if (type.kind === "tupleType") {
-        if (type.elementTypes.length === 0)
-            return undefined;
-        if (type.elementTypes.length === 1)
-            return type.elementTypes[0];
-        return { kind: "unionType", types: type.elementTypes };
+const castInvokedLambdaTarget = (calleeExpr, calleeType, context) => {
+    if (calleeExpr.kind !== "lambdaExpression") {
+        return [calleeExpr, context];
     }
-    if (type.kind === "referenceType" &&
-        type.typeArguments &&
-        type.typeArguments.length > 0) {
-        const simpleName = type.name.split(".").pop() ?? type.name;
-        switch (simpleName) {
-            case "Array":
-            case "ReadonlyArray":
-            case "Iterable":
-            case "IterableIterator":
-            case "IEnumerable":
-            case "IReadOnlyList":
-            case "List":
-            case "Set":
-            case "ReadonlySet":
-            case "JSArray":
-                return type.typeArguments[0];
-            default:
-                return undefined;
-        }
+    if (!calleeType || calleeType.kind !== "functionType") {
+        throw new Error("Internal Compiler Error: Immediately-invoked function expression reached call emission without a concrete function type.");
     }
-    return undefined;
-};
-const isValueTaskLikeIrType = (type) => {
-    if (!type || type.kind !== "referenceType")
-        return false;
-    const simpleName = type.name.split(".").pop() ?? type.name;
-    const clrName = type.resolvedClrType ?? type.name;
-    return (simpleName === "ValueTask" ||
-        simpleName === "ValueTask_1" ||
-        simpleName === "ValueTask`1" ||
-        clrName === "System.Threading.Tasks.ValueTask" ||
-        clrName.startsWith("System.Threading.Tasks.ValueTask`1"));
-};
-const emitPromiseNormalizedTaskAst = (valueAst, valueType, resultTypeAst, context) => {
     let currentContext = context;
-    if (valueType && isAwaitableIrType(valueType)) {
-        if (isValueTaskLikeIrType(valueType)) {
-            return [
-                {
-                    kind: "invocationExpression",
-                    expression: {
-                        kind: "memberAccessExpression",
-                        expression: valueAst,
-                        memberName: "AsTask",
-                    },
-                    arguments: [],
-                },
-                currentContext,
-            ];
+    const parameterTypeAsts = [];
+    for (const parameter of calleeType.parameters) {
+        if (!parameter?.type) {
+            throw new Error("Internal Compiler Error: Function-expression invocation parameter is missing a concrete type.");
         }
-        return [valueAst, currentContext];
-    }
-    if (valueType?.kind === "unionType") {
-        const arms = [];
-        for (let index = 0; index < valueType.types.length; index++) {
-            const memberType = valueType.types[index];
-            if (!memberType)
-                continue;
-            const [memberTypeAst, memberTypeContext] = emitTypeAst(memberType, currentContext);
-            currentContext = memberTypeContext;
-            const memberName = `__tsonic_promise_value_${index}`;
-            const [normalizedArm, normalizedContext] = emitPromiseNormalizedTaskAst({
-                kind: "identifierExpression",
-                identifier: memberName,
-            }, memberType, resultTypeAst, currentContext);
-            currentContext = normalizedContext;
-            arms.push({
-                kind: "lambdaExpression",
-                isAsync: false,
-                parameters: [{ name: memberName, type: memberTypeAst }],
-                body: normalizedArm,
-            });
-        }
-        return [
-            {
-                kind: "invocationExpression",
-                expression: {
-                    kind: "memberAccessExpression",
-                    expression: valueAst,
-                    memberName: "Match",
-                },
-                arguments: arms,
-            },
-            currentContext,
-        ];
-    }
-    if (!resultTypeAst) {
-        return [buildCompletedTaskAst(), currentContext];
+        const [parameterTypeAst, parameterTypeContext] = emitTypeAst(parameter.type, currentContext);
+        parameterTypeAsts.push(parameterTypeAst);
+        currentContext = parameterTypeContext;
     }
+    const [returnTypeAst, returnTypeContext] = emitTypeAst(calleeType.returnType, currentContext);
     return [
         {
-            kind: "invocationExpression",
-            expression: {
-                kind: "memberAccessExpression",
-                expression: {
-                    kind: "identifierExpression",
-                    identifier: "global::System.Threading.Tasks.Task",
-                },
-                memberName: "FromResult",
-            },
-            typeArguments: [resultTypeAst],
-            arguments: [valueAst],
-        },
-        currentContext,
-    ];
-};
-const emitPromiseStaticCall = (expr, context) => {
-    const method = getPromiseStaticMethod(expr);
-    if (!method)
-        return null;
-    let currentContext = context;
-    const [outputTaskType, outputTaskContext] = emitTypeAst(expr.inferredType ?? {
-        kind: "referenceType",
-        name: "Promise",
-        typeArguments: [{ kind: "referenceType", name: "object" }],
-    }, currentContext);
-    currentContext = outputTaskContext;
-    const outputResultType = getTaskResultType(outputTaskType);
-    if (method === "resolve") {
-        const argument = expr.arguments[0];
-        if (!argument) {
-            return [buildCompletedTaskAst(), currentContext];
-        }
-        const [valueAst, valueContext] = emitExpressionAst(argument, currentContext, argument.inferredType);
-        currentContext = valueContext;
-        return emitPromiseNormalizedTaskAst(valueAst, argument.inferredType, outputResultType, currentContext);
-    }
-    if (method === "reject") {
-        const reason = expr.arguments[0];
-        let reasonAst;
-        if (reason) {
-            [reasonAst, currentContext] = emitExpressionAst(reason, currentContext, reason.inferredType);
-        }
-        const exceptionAst = buildPromiseRejectedExceptionAst(reasonAst);
-        return [
-            {
-                kind: "invocationExpression",
-                expression: {
-                    kind: "memberAccessExpression",
-                    expression: {
-                        kind: "identifierExpression",
-                        identifier: "global::System.Threading.Tasks.Task",
-                    },
-                    memberName: "FromException",
-                },
-                typeArguments: outputResultType ? [outputResultType] : undefined,
-                arguments: [exceptionAst],
-            },
-            currentContext,
-        ];
-    }
-    const valuesArg = expr.arguments[0];
-    if (!valuesArg)
-        return null;
-    const [valuesAst, valuesContext] = emitExpressionAst(valuesArg, currentContext, valuesArg.inferredType);
-    currentContext = valuesContext;
-    const inputElementType = getSequenceElementIrType(valuesArg.inferredType);
-    const resultElementTypeAst = outputResultType?.kind === "arrayType"
-        ? outputResultType.elementType
-        : outputResultType;
-    let normalizedValuesAst = valuesAst;
-    if (inputElementType) {
-        const [inputElementTypeAst, inputElementContext] = emitTypeAst(inputElementType, currentContext);
-        currentContext = inputElementContext;
-        const [normalizedTaskAst, normalizedTaskContext] = emitPromiseNormalizedTaskAst({
-            kind: "identifierExpression",
-            identifier: "__tsonic_promise_item",
-        }, inputElementType, resultElementTypeAst, currentContext);
-        currentContext = normalizedTaskContext;
-        normalizedValuesAst = {
-            kind: "invocationExpression",
+            kind: "parenthesizedExpression",
             expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Linq.Enumerable.Select",
-            },
-            arguments: [
-                valuesAst,
-                {
-                    kind: "lambdaExpression",
-                    isAsync: false,
-                    parameters: [
-                        {
-                            name: "__tsonic_promise_item",
-                            type: inputElementTypeAst,
-                        },
-                    ],
-                    body: normalizedTaskAst,
-                },
-            ],
-        };
-    }
-    if (method === "all") {
-        return [
-            {
-                kind: "invocationExpression",
+                kind: "castExpression",
+                type: buildDelegateType(parameterTypeAsts, returnTypeAst),
                 expression: {
-                    kind: "memberAccessExpression",
-                    expression: {
-                        kind: "identifierExpression",
-                        identifier: "global::System.Threading.Tasks.Task",
-                    },
-                    memberName: "WhenAll",
+                    kind: "parenthesizedExpression",
+                    expression: calleeExpr,
                 },
-                arguments: [normalizedValuesAst],
-            },
-            currentContext,
-        ];
-    }
-    const whenAnyAst = {
-        kind: "invocationExpression",
-        expression: {
-            kind: "memberAccessExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Threading.Tasks.Task",
             },
-            memberName: "WhenAny",
         },
-        arguments: [normalizedValuesAst],
-    };
-    if (!outputResultType) {
-        return [
-            buildTaskRunInvocation(outputTaskType, {
-                kind: "blockStatement",
-                statements: [
-                    {
-                        kind: "expressionStatement",
-                        expression: {
-                            kind: "awaitExpression",
-                            expression: {
-                                kind: "awaitExpression",
-                                expression: whenAnyAst,
-                            },
-                        },
-                    },
-                ],
-            }, true),
-            currentContext,
-        ];
-    }
-    return [
-        buildTaskRunInvocation(outputTaskType, {
-            kind: "blockStatement",
-            statements: [
-                {
-                    kind: "returnStatement",
-                    expression: {
-                        kind: "awaitExpression",
-                        expression: {
-                            kind: "awaitExpression",
-                            expression: whenAnyAst,
-                        },
-                    },
-                },
-            ],
-        }, true),
-        currentContext,
+        returnTypeContext,
     ];
 };
-const getDynamicImportSpecifier = (expr) => {
-    const [arg] = expr.arguments;
-    if (!arg || arg.kind === "spread")
+const emitSyntheticArraySliceCall = (expr, context) => {
+    if (expr.callee.kind !== "memberAccess") {
         return undefined;
-    return arg.kind === "literal" && typeof arg.value === "string"
-        ? arg.value
-        : undefined;
-};
-const resolveDynamicImportTargetModule = (specifier, context) => {
-    const currentFilePath = context.options.currentModuleFilePath;
-    const moduleMap = context.options.moduleMap;
-    if (!currentFilePath || !moduleMap) {
-        return undefined;
-    }
-    const targetPath = resolveImportPath(currentFilePath, specifier);
-    const direct = moduleMap.get(targetPath);
-    if (direct) {
-        return direct;
-    }
-    const normalizedTarget = targetPath.replace(/\\/g, "/");
-    for (const [key, identity] of moduleMap.entries()) {
-        const normalizedKey = key.replace(/\\/g, "/");
-        if (normalizedKey === normalizedTarget ||
-            normalizedKey.endsWith(`/${normalizedTarget}`) ||
-            normalizedTarget.endsWith(`/${normalizedKey}`)) {
-            return identity;
-        }
-    }
-    return undefined;
-};
-const buildDynamicImportContainerType = (targetModule) => {
-    const containerName = targetModule.hasTypeCollision
-        ? `${targetModule.className}__Module`
-        : targetModule.className;
-    return {
-        kind: "identifierType",
-        name: `global::${targetModule.namespace}.${containerName}`,
-    };
-};
-const buildRunClassConstructorExpression = (containerType) => ({
-    kind: "invocationExpression",
-    expression: {
-        kind: "memberAccessExpression",
-        expression: {
-            kind: "identifierExpression",
-            identifier: "global::System.Runtime.CompilerServices.RuntimeHelpers",
-        },
-        memberName: "RunClassConstructor",
-    },
-    arguments: [
-        {
-            kind: "memberAccessExpression",
-            expression: {
-                kind: "typeofExpression",
-                type: containerType,
-            },
-            memberName: "TypeHandle",
-        },
-    ],
-});
-const emitDynamicImportCall = (expr, context) => {
-    if (expr.callee.kind !== "identifier" || expr.callee.name !== "import") {
-        return null;
-    }
-    const specifier = getDynamicImportSpecifier(expr);
-    if (!specifier)
-        return null;
-    const completedTaskExpr = {
-        kind: "memberAccessExpression",
-        expression: {
-            kind: "identifierExpression",
-            identifier: "global::System.Threading.Tasks.Task",
-        },
-        memberName: "CompletedTask",
-    };
-    const targetModule = resolveDynamicImportTargetModule(specifier, context);
-    if (!expr.dynamicImportNamespace) {
-        if (!targetModule || !targetModule.hasRuntimeContainer) {
-            return [completedTaskExpr, context];
-        }
-        const containerType = buildDynamicImportContainerType(targetModule);
-        const runClassConstructor = buildRunClassConstructorExpression(containerType);
-        return [
-            {
-                kind: "invocationExpression",
-                expression: {
-                    kind: "memberAccessExpression",
-                    expression: {
-                        kind: "identifierExpression",
-                        identifier: "global::System.Threading.Tasks.Task",
-                    },
-                    memberName: "Run",
-                },
-                arguments: [
-                    {
-                        kind: "lambdaExpression",
-                        isAsync: false,
-                        parameters: [],
-                        body: runClassConstructor,
-                    },
-                ],
-            },
-            context,
-        ];
-    }
-    if (!targetModule) {
-        throw new Error(`ICE: Closed-world dynamic import '${specifier}' was validated as a namespace import but no module identity was available during emission.`);
-    }
-    let currentContext = context;
-    const [outputTaskType, outputTaskContext] = emitTypeAst(expr.inferredType ?? {
-        kind: "referenceType",
-        name: "Promise",
-        typeArguments: [{ kind: "referenceType", name: "object" }],
-    }, currentContext);
-    currentContext = outputTaskContext;
-    const [namespaceAst, namespaceContext] = expr.dynamicImportNamespace.properties.length === 0
-        ? [
-            {
-                kind: "objectCreationExpression",
-                type: { kind: "identifierType", name: "object" },
-                arguments: [],
-            },
-            currentContext,
-        ]
-        : emitExpressionAst(expr.dynamicImportNamespace, currentContext, expr.dynamicImportNamespace.inferredType);
-    currentContext = namespaceContext;
-    const setupStatements = [];
-    if (targetModule.hasRuntimeContainer) {
-        const containerType = buildDynamicImportContainerType(targetModule);
-        setupStatements.push({
-            kind: "expressionStatement",
-            expression: buildRunClassConstructorExpression(containerType),
-        });
     }
-    return [
-        buildTaskRunInvocation(outputTaskType, {
-            kind: "blockStatement",
-            statements: [
-                ...setupStatements,
-                {
-                    kind: "returnStatement",
-                    expression: namespaceAst,
-                },
-            ],
-        }, false),
-        currentContext,
-    ];
-};
-const emitPromiseThenCatchFinally = (expr, context) => {
-    if (expr.callee.kind !== "memberAccess")
-        return null;
-    if (typeof expr.callee.property !== "string")
-        return null;
-    if (!isPromiseChainMethod(expr.callee.property))
-        return null;
-    if (expr.callee.isOptional || expr.isOptional)
-        return null;
-    if (!isAsyncWrapperType(expr.callee.object.inferredType))
-        return null;
-    let currentContext = context;
-    const [receiverAst, receiverCtx] = emitExpressionAst(expr.callee.object, currentContext);
-    currentContext = receiverCtx;
-    const outputTypeHint = context.returnType && isAsyncWrapperType(context.returnType)
-        ? context.returnType
-        : expr.inferredType;
-    const [rawOutputTaskType, outputTaskCtx] = emitTypeAst(outputTypeHint ?? { kind: "referenceType", name: "Task" }, currentContext);
-    currentContext = outputTaskCtx;
-    const defaultOutputTaskType = isTaskTypeAst(rawOutputTaskType) &&
-        rawOutputTaskType.typeArguments?.length === 1 &&
-        containsVoidTypeAst(rawOutputTaskType.typeArguments[0])
-        ? { kind: "identifierType", name: "global::System.Threading.Tasks.Task" }
-        : rawOutputTaskType;
-    const [sourceTaskType, sourceTaskCtx] = emitTypeAst(expr.callee.object.inferredType ?? { kind: "referenceType", name: "Task" }, currentContext);
-    currentContext = sourceTaskCtx;
-    const sourceResultType = getTaskResultType(sourceTaskType);
-    const sourceResultIr = normalizePromiseChainResultIrType(expr.callee.object.inferredType);
-    const exIdent = "__tsonic_promise_ex";
-    const valueIdent = "__tsonic_promise_value";
-    const fulfilledArg = expr.arguments[0];
-    const rejectedArg = expr.callee.property === "then" ? expr.arguments[1] : expr.arguments[0];
-    const finallyArg = expr.callee.property === "finally" ? expr.arguments[0] : undefined;
-    let fulfilledAst;
-    let rejectedAst;
-    let finallyAst;
-    if (fulfilledArg && fulfilledArg.kind !== "spread") {
-        const [fAst, fCtx] = emitExpressionAst(fulfilledArg, currentContext);
-        fulfilledAst = fAst;
-        currentContext = fCtx;
-    }
-    if (rejectedArg && rejectedArg.kind !== "spread") {
-        const [rAst, rCtx] = emitExpressionAst(rejectedArg, currentContext);
-        rejectedAst = rAst;
-        currentContext = rCtx;
-    }
-    if (finallyArg && finallyArg.kind !== "spread") {
-        const [fiAst, fiCtx] = emitExpressionAst(finallyArg, currentContext);
-        finallyAst = fiAst;
-        currentContext = fiCtx;
-    }
-    const fulfilledResultIr = fulfilledArg && fulfilledArg.kind !== "spread"
-        ? normalizePromiseChainResultIrType(getCallbackReturnType(fulfilledArg))
-        : undefined;
-    const rejectedResultIr = rejectedArg && rejectedArg.kind !== "spread"
-        ? normalizePromiseChainResultIrType(getCallbackReturnType(rejectedArg))
-        : undefined;
-    const normalizedPromiseChainResultIr = (() => {
-        if (expr.callee.property === "then") {
-            if (rejectedArg && rejectedArg.kind !== "spread") {
-                return mergePromiseChainResultIrTypes(fulfilledResultIr ?? sourceResultIr, rejectedResultIr);
-            }
-            return fulfilledResultIr ?? sourceResultIr;
-        }
-        if (expr.callee.property === "catch") {
-            return mergePromiseChainResultIrTypes(sourceResultIr, rejectedResultIr);
-        }
-        if (expr.callee.property === "finally") {
-            return sourceResultIr;
-        }
+    const binding = expr.callee.memberBinding;
+    if (binding?.assembly !== "__synthetic" ||
+        binding.type !== "Array" ||
+        binding.member !== "slice" ||
+        expr.arguments.length !== 1) {
         return undefined;
-    })();
-    const normalizedFrontendPromiseChainResultIr = normalizePromiseChainResultIrType(expr.inferredType);
-    const preferredPromiseChainResultIr = normalizedFrontendPromiseChainResultIr &&
-        !containsPromiseChainArtifact(normalizedFrontendPromiseChainResultIr)
-        ? normalizedFrontendPromiseChainResultIr
-        : normalizedPromiseChainResultIr;
-    let outputResultType = getTaskResultType(defaultOutputTaskType);
-    let outputTaskType = defaultOutputTaskType;
-    if (preferredPromiseChainResultIr) {
-        const [normalizedResultAst, normalizedCtx] = emitTypeAst(preferredPromiseChainResultIr, currentContext);
-        currentContext = normalizedCtx;
-        outputResultType = containsVoidTypeAst(normalizedResultAst)
-            ? undefined
-            : normalizedResultAst;
-        outputTaskType = buildTaskTypeAst(outputResultType);
-    }
-    const awaitReceiverStatement = sourceResultType === undefined
-        ? {
-            kind: "expressionStatement",
-            expression: buildAwait(receiverAst),
-        }
-        : {
-            kind: "localDeclarationStatement",
-            modifiers: [],
-            type: { kind: "identifierType", name: "var" },
-            declarators: [
-                {
-                    name: valueIdent,
-                    initializer: buildAwait(receiverAst),
-                },
-            ],
-        };
-    const invokeFulfilled = () => {
-        if (!fulfilledAst) {
-            if (sourceResultType === undefined)
-                return [];
-            return [
-                {
-                    kind: "returnStatement",
-                    expression: {
-                        kind: "identifierExpression",
-                        identifier: valueIdent,
-                    },
-                },
-            ];
-        }
-        const fulfilledArgs = [];
-        if (sourceResultType !== undefined &&
-            callbackParameterCount(fulfilledArg) > 0) {
-            fulfilledArgs.push({
-                kind: "identifierExpression",
-                identifier: valueIdent,
-            });
-        }
-        const delegateParamTypes = sourceResultType !== undefined &&
-            callbackParameterCount(fulfilledArg) > 0
-            ? [sourceResultType]
-            : [];
-        const callbackReturnIr = getCallbackDelegateReturnType(fulfilledArg);
-        let callbackReturnTypeAst = outputResultType;
-        if (callbackReturnIr !== undefined) {
-            const [cbRetAst, cbRetCtx] = emitTypeAst(callbackReturnIr, currentContext);
-            callbackReturnTypeAst =
-                (cbRetAst.kind === "predefinedType" && cbRetAst.keyword === "void") ||
-                    (cbRetAst.kind === "identifierType" && cbRetAst.name === "void")
-                    ? undefined
-                    : cbRetAst;
-            currentContext = cbRetCtx;
-        }
-        if (outputResultType !== undefined && callbackReturnTypeAst === undefined) {
-            callbackReturnTypeAst = outputResultType;
-        }
-        if (callbackReturnTypeAst === undefined &&
-            fulfilledArg?.kind === "arrowFunction" &&
-            fulfilledArg.body.kind !== "blockStatement") {
-            callbackReturnTypeAst = { kind: "predefinedType", keyword: "object" };
-        }
-        const callbackCallee = fulfilledAst.kind === "lambdaExpression"
-            ? {
-                kind: "castExpression",
-                type: buildDelegateType(delegateParamTypes, callbackReturnTypeAst),
-                expression: fulfilledAst,
-            }
-            : fulfilledAst;
-        const callbackCall = callbackCallee.kind === "castExpression"
-            ? buildInvocation({
-                kind: "memberAccessExpression",
-                expression: callbackCallee,
-                memberName: "Invoke",
-            }, fulfilledArgs)
-            : buildInvocation(callbackCallee, fulfilledArgs);
-        const callbackExpr = callbackReturnsAsyncWrapper(fulfilledArg)
-            ? buildAwait(callbackCall)
-            : callbackCall;
-        if (outputResultType === undefined) {
-            return [{ kind: "expressionStatement", expression: callbackExpr }];
-        }
-        return [{ kind: "returnStatement", expression: callbackExpr }];
-    };
-    const invokeRejected = () => {
-        if (!rejectedAst) {
-            return [{ kind: "throwStatement" }];
-        }
-        const rejectedArgs = [];
-        if (callbackParameterCount(rejectedArg) > 0) {
-            rejectedArgs.push({
-                kind: "identifierExpression",
-                identifier: exIdent,
-            });
-        }
-        const callbackReturnIr = getCallbackDelegateReturnType(rejectedArg);
-        let callbackReturnTypeAst = outputResultType;
-        if (callbackReturnIr !== undefined) {
-            const [cbRetAst, cbRetCtx] = emitTypeAst(callbackReturnIr, currentContext);
-            callbackReturnTypeAst =
-                (cbRetAst.kind === "predefinedType" && cbRetAst.keyword === "void") ||
-                    (cbRetAst.kind === "identifierType" && cbRetAst.name === "void")
-                    ? undefined
-                    : cbRetAst;
-            currentContext = cbRetCtx;
-        }
-        if (outputResultType !== undefined && callbackReturnTypeAst === undefined) {
-            callbackReturnTypeAst = outputResultType;
-        }
-        if (callbackReturnTypeAst === undefined &&
-            rejectedArg?.kind === "arrowFunction" &&
-            rejectedArg.body.kind !== "blockStatement") {
-            callbackReturnTypeAst = { kind: "predefinedType", keyword: "object" };
-        }
-        const callbackCallee = rejectedAst.kind === "lambdaExpression"
-            ? {
-                kind: "castExpression",
-                type: buildDelegateType([{ kind: "identifierType", name: "global::System.Exception" }], callbackReturnTypeAst),
-                expression: rejectedAst,
-            }
-            : rejectedAst;
-        const callbackCall = callbackCallee.kind === "castExpression"
-            ? buildInvocation({
-                kind: "memberAccessExpression",
-                expression: callbackCallee,
-                memberName: "Invoke",
-            }, rejectedArgs)
-            : buildInvocation(callbackCallee, rejectedArgs);
-        const callbackExpr = callbackReturnsAsyncWrapper(rejectedArg)
-            ? buildAwait(callbackCall)
-            : callbackCall;
-        if (outputResultType === undefined) {
-            return [{ kind: "expressionStatement", expression: callbackExpr }];
-        }
-        return [{ kind: "returnStatement", expression: callbackExpr }];
-    };
-    const invokeFinally = () => {
-        if (!finallyAst)
-            return [];
-        const callbackReturnIr = getCallbackDelegateReturnType(finallyArg);
-        let callbackReturnTypeAst = undefined;
-        if (callbackReturnIr !== undefined) {
-            const [cbRetAst, cbRetCtx] = emitTypeAst(callbackReturnIr, currentContext);
-            callbackReturnTypeAst = cbRetAst;
-            currentContext = cbRetCtx;
-        }
-        if (callbackReturnTypeAst === undefined &&
-            finallyArg?.kind === "arrowFunction" &&
-            finallyArg.body.kind !== "blockStatement") {
-            callbackReturnTypeAst = { kind: "predefinedType", keyword: "object" };
-        }
-        const callbackCallee = finallyAst.kind === "lambdaExpression"
-            ? {
-                kind: "castExpression",
-                type: buildDelegateType([], callbackReturnTypeAst),
-                expression: finallyAst,
-            }
-            : finallyAst;
-        const callbackCall = callbackCallee.kind === "castExpression"
-            ? buildInvocation({
-                kind: "memberAccessExpression",
-                expression: callbackCallee,
-                memberName: "Invoke",
-            }, [])
-            : buildInvocation(callbackCallee, []);
-        const callbackExpr = callbackReturnsAsyncWrapper(finallyArg)
-            ? buildAwait(callbackCall)
-            : callbackCall;
-        return [{ kind: "expressionStatement", expression: callbackExpr }];
-    };
-    if (expr.callee.property === "then") {
-        const thenStatements = [
-            awaitReceiverStatement,
-            ...invokeFulfilled(),
-        ];
-        const bodyStatements = rejectedAst
-            ? [
-                {
-                    kind: "tryStatement",
-                    body: { kind: "blockStatement", statements: thenStatements },
-                    catches: [
-                        {
-                            type: {
-                                kind: "identifierType",
-                                name: "global::System.Exception",
-                            },
-                            identifier: exIdent,
-                            body: {
-                                kind: "blockStatement",
-                                statements: invokeRejected(),
-                            },
-                        },
-                    ],
-                },
-            ]
-            : thenStatements;
-        return [
-            buildTaskRunInvocation(outputTaskType, {
-                kind: "blockStatement",
-                statements: bodyStatements,
-            }, true),
-            currentContext,
-        ];
-    }
-    if (expr.callee.property === "catch") {
-        const successPath = sourceResultType === undefined
-            ? [{ kind: "expressionStatement", expression: buildAwait(receiverAst) }]
-            : [
-                {
-                    kind: "returnStatement",
-                    expression: buildAwait(receiverAst),
-                },
-            ];
-        const catches = [
-            {
-                type: { kind: "identifierType", name: "global::System.Exception" },
-                identifier: exIdent,
-                body: {
-                    kind: "blockStatement",
-                    statements: invokeRejected(),
-                },
-            },
-        ];
-        return [
-            buildTaskRunInvocation(outputTaskType, {
-                kind: "blockStatement",
-                statements: [
-                    {
-                        kind: "tryStatement",
-                        body: { kind: "blockStatement", statements: successPath },
-                        catches,
-                    },
-                ],
-            }, true),
-            currentContext,
-        ];
-    }
-    if (expr.callee.property === "finally") {
-        const tryStatements = sourceResultType === undefined
-            ? [{ kind: "expressionStatement", expression: buildAwait(receiverAst) }]
-            : [{ kind: "returnStatement", expression: buildAwait(receiverAst) }];
-        return [
-            buildTaskRunInvocation(outputTaskType, {
-                kind: "blockStatement",
-                statements: [
-                    {
-                        kind: "tryStatement",
-                        body: { kind: "blockStatement", statements: tryStatements },
-                        catches: [],
-                        finallyBody: {
-                            kind: "blockStatement",
-                            statements: invokeFinally(),
-                        },
-                    },
-                ],
-            }, true),
-            currentContext,
-        ];
-    }
-    return null;
-};
-/**
- * Emit call arguments as typed AST array.
- * Handles spread arrays, castModifier (ref/out from cast), and argumentPassing modes.
- */
-const emitCallArguments = (args, expr, context) => {
-    const functionValueSignature = getFunctionValueSignature(expr);
-    if (functionValueSignature &&
-        functionValueSignature.parameters.some((parameter) => parameter?.isRest ||
-            parameter?.isOptional ||
-            parameter?.initializer !== undefined)) {
-        return emitFunctionValueCallArguments(args, functionValueSignature, expr, context);
-    }
-    const parameterTypes = expr.parameterTypes ?? [];
-    const restInfo = detectRestParameterInfo(args, parameterTypes);
-    let currentContext = context;
-    const argAsts = [];
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg)
-            continue;
-        if (restInfo &&
-            i === restInfo.index &&
-            args
-                .slice(restInfo.index)
-                .some((candidate) => candidate?.kind === "spread")) {
-            const [flattenedRestArgs, flattenedContext] = emitFlattenedRestArguments(args.slice(restInfo.index), restInfo.elementType, currentContext);
-            argAsts.push(...flattenedRestArgs);
-            currentContext = flattenedContext;
-            break;
-        }
-        const expectedType = restInfo && i >= restInfo.index
-            ? restInfo.elementType
-            : parameterTypes[i];
-        if (arg.kind === "spread") {
-            const [spreadAst, ctx] = emitExpressionAst(arg.expression, currentContext);
-            argAsts.push(spreadAst);
-            currentContext = ctx;
-        }
-        else {
-            const castModifier = getPassingModifierFromCast(arg);
-            if (castModifier && isLValue(arg)) {
-                const [argAst, ctx] = emitExpressionAst(arg, currentContext);
-                argAsts.push(wrapArgModifier(castModifier, argAst));
-                currentContext = ctx;
-            }
-            else {
-                const [argAst, ctx] = emitExpressionAst(arg, currentContext, expectedType);
-                const passingMode = expr.argumentPassing?.[i];
-                const modifier = passingMode && passingMode !== "value" && isLValue(arg)
-                    ? passingMode
-                    : undefined;
-                argAsts.push(wrapArgModifier(modifier, argAst));
-                currentContext = ctx;
-            }
-        }
-    }
-    return [argAsts, currentContext];
-};
-/**
- * Emit a JsonSerializer call with NativeAOT-compatible options.
- */
-const isConcreteGlobalJsonParseTarget = (type) => {
-    if (!type)
-        return false;
-    if (type.kind === "unknownType" ||
-        type.kind === "anyType" ||
-        type.kind === "voidType" ||
-        type.kind === "neverType") {
-        return false;
-    }
-    if (type.kind === "unionType" || type.kind === "intersectionType") {
-        return false;
     }
-    return !containsTypeParameter(type);
-};
-const emitJsRuntimeJsonParseCall = (expr, context, typeArgument) => {
-    let currentContext = context;
-    const argAsts = [];
-    for (const arg of expr.arguments) {
-        if (arg.kind === "spread") {
-            const [spreadAst, ctx] = emitExpressionAst(arg.expression, currentContext);
-            argAsts.push(spreadAst);
-            currentContext = ctx;
-            continue;
-        }
-        const [argAst, ctx] = emitExpressionAst(arg, currentContext);
-        argAsts.push(argAst);
-        currentContext = ctx;
+    const startIndex = expr.arguments[0];
+    if (!startIndex || startIndex.kind === "spread") {
+        return undefined;
     }
+    const [receiverAst, receiverContext] = emitExpressionAst(expr.callee.object, context);
+    const [startAst, startContext] = emitExpressionAst(startIndex, receiverContext, { kind: "primitiveType", name: "int" });
     return [
         {
             kind: "invocationExpression",
-            expression: {
-                kind: "memberAccessExpression",
-                expression: {
-                    kind: "identifierExpression",
-                    identifier: "global::Tsonic.JSRuntime.JSON",
+            expression: identifierExpression("global::System.Linq.Enumerable.ToArray"),
+            arguments: [
+                {
+                    kind: "invocationExpression",
+                    expression: identifierExpression("global::System.Linq.Enumerable.Skip"),
+                    arguments: [receiverAst, startAst],
                 },
-                memberName: "parse",
-            },
-            arguments: argAsts,
-            typeArguments: [typeArgument],
+            ],
         },
-        currentContext,
+        startContext,
     ];
 };
-const emitJsonSerializerCall = (expr, context, method, deserializeTypeOverride) => {
-    let currentContext = context;
-    // Register the type with the JSON AOT registry
-    if (method === "Serialize") {
-        const firstArg = expr.arguments[0];
-        if (firstArg && firstArg.kind !== "spread") {
-            registerJsonAotExpressionTypes(firstArg, context);
-        }
-    }
-    else {
-        const typeArg = deserializeTypeOverride ?? expr.typeArguments?.[0];
-        if (typeArg) {
-            registerJsonAotType(typeArg, context);
-        }
-    }
-    // Emit type arguments for Deserialize<T>
-    let typeArgAsts = [];
-    const deserializeIrType = method === "Deserialize"
-        ? (deserializeTypeOverride ?? expr.typeArguments?.[0])
-        : undefined;
-    if (deserializeIrType) {
-        const [typeArgs, typeContext] = emitTypeArgumentsAst([deserializeIrType], currentContext);
-        typeArgAsts = typeArgs;
-        currentContext = typeContext;
-    }
-    else if (expr.typeArguments && expr.typeArguments.length > 0) {
-        const [typeArgs, typeContext] = emitTypeArgumentsAst(expr.typeArguments, currentContext);
-        typeArgAsts = typeArgs;
-        currentContext = typeContext;
-    }
-    // Emit arguments
-    const argAsts = [];
-    for (const arg of expr.arguments) {
-        if (arg.kind === "spread") {
-            const [spreadAst, ctx] = emitExpressionAst(arg.expression, currentContext);
-            argAsts.push(spreadAst);
-            currentContext = ctx;
-        }
-        else {
-            const [argAst, ctx] = emitExpressionAst(arg, currentContext);
-            argAsts.push(argAst);
-            currentContext = ctx;
-        }
-    }
-    // Only pass TsonicJson.Options when this call site actually participates in the
-    // NativeAOT JSON rewrite. Non-generic JSON.parse(...) intentionally returns
-    // unknown and should emit plain JsonSerializer calls without requiring the
-    // generated TsonicJson helper.
-    if (context.options.jsonAotRegistry?.needsJsonAot) {
-        argAsts.push({
-            kind: "identifierExpression",
-            identifier: "TsonicJson.Options",
-        });
-    }
-    const invocation = {
-        kind: "invocationExpression",
-        expression: {
-            kind: "memberAccessExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Text.Json.JsonSerializer",
-            },
-            memberName: method,
-        },
-        arguments: argAsts,
-        typeArguments: typeArgAsts.length > 0 ? typeArgAsts : undefined,
-    };
-    return [invocation, currentContext];
-};
-const emitGlobalJsonCall = (expr, context, method) => {
-    if (method === "Serialize") {
-        return emitJsonSerializerCall(expr, context, method);
-    }
-    const deserializeTarget = expr.typeArguments?.[0] ??
-        (isConcreteGlobalJsonParseTarget(expr.inferredType)
-            ? expr.inferredType
-            : undefined);
-    if (deserializeTarget) {
-        return emitJsonSerializerCall(expr, context, "Deserialize", deserializeTarget);
-    }
-    return emitJsRuntimeJsonParseCall(expr, context, {
-        kind: "predefinedType",
-        keyword: "object",
-    });
-};
 /**
  * Emit a function call expression as CSharpExpressionAst
  */
-export const emitCall = (expr, context) => {
-    const dynamicImport = emitDynamicImportCall(expr, context);
+export const emitCall = (expr, context, expectedType) => {
+    const normalizedExpr = normalizePromiseResolveCall(expr, context);
+    const syntheticArraySlice = emitSyntheticArraySliceCall(normalizedExpr, context);
+    if (syntheticArraySlice) {
+        return syntheticArraySlice;
+    }
+    const dynamicImport = emitDynamicImportCall(normalizedExpr, context);
     if (dynamicImport)
         return dynamicImport;
-    const promiseStaticCall = emitPromiseStaticCall(expr, context);
+    const promiseStaticCall = emitPromiseStaticCall(normalizedExpr, context, expectedType);
     if (promiseStaticCall)
         return promiseStaticCall;
-    const promiseChain = emitPromiseThenCatchFinally(expr, context);
+    const promiseChain = emitPromiseThenCatchFinally(normalizedExpr, context);
     if (promiseChain)
         return promiseChain;
+    const runtimeUnionArrayIsArray = emitRuntimeUnionArrayIsArrayCall(normalizedExpr, context);
+    if (runtimeUnionArrayIsArray) {
+        return runtimeUnionArrayIsArray;
+    }
     // Void promise resolve: emit as zero-arg call when safe.
-    if (expr.callee.kind === "identifier" &&
-        context.voidResolveNames?.has(expr.callee.name)) {
-        const isZeroArg = expr.arguments.length === 0;
-        const isSingleUndefined = expr.arguments.length === 1 &&
-            expr.arguments[0]?.kind === "identifier" &&
-            expr.arguments[0].name === "undefined";
+    const transparentCalleeIdentifier = extractTransparentIdentifier(normalizedExpr.callee);
+    if (transparentCalleeIdentifier &&
+        context.voidResolveNames?.has(transparentCalleeIdentifier.name)) {
+        const isZeroArg = normalizedExpr.arguments.length === 0;
+        const isSingleUndefined = normalizedExpr.arguments.length === 1 &&
+            normalizedExpr.arguments[0]?.kind === "identifier" &&
+            normalizedExpr.arguments[0].name === "undefined";
         if (isZeroArg || isSingleUndefined) {
-            const [calleeAst, calleeCtx] = emitExpressionAst(expr.callee, context);
+            const [calleeAst, calleeCtx] = emitExpressionAst(transparentCalleeIdentifier, context);
             return [
                 {
                     kind: "invocationExpression",
@@ -1947,21 +245,24 @@ export const emitCall = (expr, context) => {
         }
     }
     // Check for JsonSerializer calls (NativeAOT support)
-    const jsonCall = isJsonSerializerCall(expr.callee);
+    const jsonCall = isJsonSerializerCall(normalizedExpr.callee);
     if (jsonCall) {
-        return emitJsonSerializerCall(expr, context, jsonCall.method);
+        return emitJsonSerializerCall(normalizedExpr, context, jsonCall.method);
+    }
+    if (normalizedExpr.intrinsicKind === "globalSymbol") {
+        return emitGlobalSymbolCall(normalizedExpr, context);
     }
     // Check for global JSON.stringify/parse calls
-    const globalJsonCall = isGlobalJsonCall(expr.callee);
+    const globalJsonCall = isGlobalJsonCall(normalizedExpr.callee, context);
     if (globalJsonCall) {
-        return emitGlobalJsonCall(expr, context, globalJsonCall.method);
-    }
-    // EF Core query canonicalization: ToList().ToArray() → ToArray()
-    if (expr.callee.kind === "memberAccess" &&
-        expr.callee.property === "ToArray" &&
-        expr.arguments.length === 0 &&
-        expr.callee.object.kind === "call") {
-        const innerCall = expr.callee.object;
+        return emitGlobalJsonCall(normalizedExpr, context, globalJsonCall.method, expectedType);
+    }
+    // EF Core query canonicalization: ToList().ToArray() -> ToArray()
+    if (normalizedExpr.callee.kind === "memberAccess" &&
+        normalizedExpr.callee.property === "ToArray" &&
+        normalizedExpr.arguments.length === 0 &&
+        normalizedExpr.callee.object.kind === "call") {
+        const innerCall = normalizedExpr.callee.object;
         if (innerCall.callee.kind === "memberAccess" &&
             innerCall.callee.memberBinding?.isExtensionMethod &&
             isInstanceMemberAccess(innerCall.callee, context) &&
@@ -1987,116 +288,48 @@ export const emitCall = (expr, context) => {
             ];
         }
     }
-    // Extension method lowering: emit explicit static invocation with receiver as first arg.
-    if (expr.callee.kind === "memberAccess" &&
-        expr.callee.memberBinding?.isExtensionMethod &&
-        isInstanceMemberAccess(expr.callee, context)) {
-        let currentContext = context;
-        const binding = expr.callee.memberBinding;
-        const receiverExpr = expr.callee.object;
-        const [receiverAst, receiverContext] = emitExpressionAst(receiverExpr, currentContext);
-        currentContext = receiverContext;
-        // Fluent extension method path
-        if (shouldEmitFluentExtensionCall(binding)) {
-            const ns = getTypeNamespace(binding.type);
-            if (ns) {
-                currentContext.usings.add(ns);
-            }
-            let typeArgAsts = [];
-            if (expr.typeArguments && expr.typeArguments.length > 0) {
-                const [typeArgs, typeContext] = emitTypeArgumentsAst(expr.typeArguments, currentContext);
-                typeArgAsts = typeArgs;
-                currentContext = typeContext;
-            }
-            const [argAsts, argContext] = emitCallArguments(expr.arguments, expr, currentContext);
-            currentContext = argContext;
-            const memberAccess = expr.isOptional
-                ? {
-                    kind: "conditionalMemberAccessExpression",
-                    expression: receiverAst,
-                    memberName: binding.member,
-                }
-                : {
-                    kind: "memberAccessExpression",
-                    expression: receiverAst,
-                    memberName: binding.member,
-                };
-            const invocation = {
-                kind: "invocationExpression",
-                expression: memberAccess,
-                arguments: argAsts,
-                typeArguments: typeArgAsts.length > 0 ? typeArgAsts : undefined,
-            };
-            return [
-                wrapIntCast(needsIntCast(expr, binding.member), invocation),
-                currentContext,
-            ];
-        }
-        let finalCalleeName = `global::${binding.type}.${binding.member}`;
-        let typeArgAsts = [];
-        if (expr.typeArguments && expr.typeArguments.length > 0) {
-            if (expr.requiresSpecialization) {
-                const [specializedName, specContext] = generateSpecializedName(finalCalleeName, expr.typeArguments, currentContext);
-                finalCalleeName = specializedName;
-                currentContext = specContext;
-            }
-            else {
-                const [typeArgs, typeContext] = emitTypeArgumentsAst(expr.typeArguments, currentContext);
-                typeArgAsts = typeArgs;
-                currentContext = typeContext;
-            }
-        }
-        const [argAsts, argContext] = emitCallArguments(expr.arguments, expr, currentContext);
-        currentContext = argContext;
-        // Prepend receiver as first argument (static extension call)
-        const allArgAsts = [
-            receiverAst,
-            ...argAsts,
-        ];
-        const invocation = {
-            kind: "invocationExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: finalCalleeName,
-            },
-            arguments: allArgAsts,
-            typeArguments: typeArgAsts.length > 0 ? typeArgAsts : undefined,
-        };
-        // Wrap in ToArray() if result type is array
-        const callAst = expr.inferredType?.kind === "arrayType"
-            ? {
-                kind: "invocationExpression",
-                expression: {
-                    kind: "identifierExpression",
-                    identifier: "global::System.Linq.Enumerable.ToArray",
-                },
-                arguments: [invocation],
-            }
-            : invocation;
-        return [
-            wrapIntCast(needsIntCast(expr, finalCalleeName), callAst),
-            currentContext,
-        ];
-    }
-    const arrayWrapperInteropCall = emitArrayWrapperInteropCall(expr, context);
-    const arrayMutationInteropCall = emitArrayMutationInteropCall(expr, context);
+    const arrayWrapperInteropCall = emitArrayWrapperInteropCall(normalizedExpr, context, expectedType);
+    const arrayMutationInteropCall = emitArrayMutationInteropCall(normalizedExpr, context);
     if (arrayMutationInteropCall) {
         return arrayMutationInteropCall;
     }
     if (arrayWrapperInteropCall) {
         return arrayWrapperInteropCall;
     }
+    // Extension method lowering — delegated to call-extension-methods.ts
+    // Keep this after native array interop so lifted/static container array
+    // mutation calls cannot fall through to copy-based source-owned array syntax.
+    const extensionResult = tryEmitExtensionMethodCall(normalizedExpr, context, expectedType);
+    if (extensionResult) {
+        return extensionResult;
+    }
+    const callableStaticAccessor = tryGetCallableStaticAccessorCall(normalizedExpr);
+    if (callableStaticAccessor) {
+        return emitCallableStaticAccessorCall(normalizedExpr, callableStaticAccessor.binding, context);
+    }
     // Regular function call
-    const [calleeAst, newContext] = expr.callee.kind === "memberAccess"
-        ? emitMemberAccess(expr.callee, context, "call")
-        : emitExpressionAst(expr.callee, context);
+    const calleeExprForEmission = normalizedExpr.callee;
+    const shouldPreferParameterExpectedType = transparentCalleeIdentifier !== undefined &&
+        context.promiseResolveValueTypes?.has(transparentCalleeIdentifier.name) ===
+            true;
+    const calleeExpectedType = calleeExprForEmission.kind === "memberAccess"
+        ? undefined
+        : buildCallTargetExpectedType(normalizedExpr, shouldPreferParameterExpectedType);
+    const [calleeAst, newContext] = calleeExprForEmission.kind === "memberAccess"
+        ? emitMemberAccess(calleeExprForEmission, context, "call")
+        : emitExpressionAst(calleeExprForEmission, context, calleeExpectedType);
     let currentContext = newContext;
     let calleeExpr = calleeAst;
     let typeArgAsts = [];
-    if (expr.typeArguments && expr.typeArguments.length > 0) {
-        if (expr.requiresSpecialization) {
+    if (calleeExpr.kind === "lambdaExpression") {
+        const castedLambdaTarget = castInvokedLambdaTarget(calleeExpr, calleeExpectedType, currentContext);
+        calleeExpr = castedLambdaTarget[0];
+        currentContext = castedLambdaTarget[1];
+    }
+    if (normalizedExpr.typeArguments && normalizedExpr.typeArguments.length > 0) {
+        if (normalizedExpr.requiresSpecialization) {
             const calleeText = extractCalleeNameFromAst(calleeAst);
-            const [specializedName, specContext] = generateSpecializedName(calleeText, expr.typeArguments, currentContext);
+            const [specializedName, specContext] = generateSpecializedName(calleeText, normalizedExpr.typeArguments, currentContext);
             calleeExpr = {
                 kind: "identifierExpression",
                 identifier: specializedName,
@@ -2104,15 +337,16 @@ export const emitCall = (expr, context) => {
             currentContext = specContext;
         }
         else {
-            const [typeArgs, typeContext] = emitTypeArgumentsAst(expr.typeArguments, currentContext);
+            const [typeArgs, typeContext] = emitTypeArgumentsAst(normalizedExpr.typeArguments, currentContext);
             typeArgAsts = typeArgs;
             currentContext = typeContext;
         }
     }
-    const [argAsts, argContext] = emitCallArguments(expr.arguments, expr, currentContext);
+    const structuralViewParameterTypes = resolveStructuralViewCallParameterTypes(normalizedExpr.callee, currentContext);
+    const [argAsts, argContext] = emitCallArguments(normalizedExpr.arguments, normalizedExpr, currentContext, structuralViewParameterTypes);
     currentContext = argContext;
     // Build the invocation target (may need optional chaining wrapper)
-    const invocationTarget = expr.isOptional
+    const invocationTarget = normalizedExpr.isOptional
         ? (() => {
             // Optional call: callee?.(args) — in C# this requires the callee to be
             // a delegate and the call to be ?.Invoke(). For member access callees
@@ -2134,9 +368,26 @@ export const emitCall = (expr, context) => {
         arguments: argAsts,
         typeArguments: typeArgAsts.length > 0 ? typeArgAsts : undefined,
     };
+    const shouldCastSuperCallResult = normalizedExpr.callee.kind === "memberAccess" &&
+        normalizedExpr.callee.object.kind === "identifier" &&
+        normalizedExpr.callee.object.name === "super" &&
+        !!expectedType &&
+        expectedType.kind !== "voidType" &&
+        expectedType.kind !== "anyType" &&
+        expectedType.kind !== "unknownType";
+    let finalInvocation = invocation;
+    if (shouldCastSuperCallResult && expectedType) {
+        const [expectedTypeAst, expectedTypeContext] = emitTypeAst(expectedType, currentContext);
+        finalInvocation = {
+            kind: "castExpression",
+            type: expectedTypeAst,
+            expression: invocation,
+        };
+        currentContext = expectedTypeContext;
+    }
     const calleeText = extractCalleeNameFromAst(calleeAst);
     return [
-        wrapIntCast(needsIntCast(expr, calleeText), invocation),
+        wrapIntCast(needsIntCast(normalizedExpr, calleeText), finalInvocation),
         currentContext,
     ];
 };