@tsonic/frontend 0.0.62 → 0.0.64

package/dist/ir/converters/expressions/calls.js

@@ -4,1348 +4,6 @@
  * ALICE'S SPEC: All call resolution goes through TypeSystem.resolveCall().
  * NO FALLBACKS ALLOWED. If TypeSystem can't resolve, return unknownType.
  */
-import * as ts from "typescript";
-import { getSourceSpan, extractTypeArguments, checkIfRequiresSpecialization, } from "./helpers.js";
-import { convertExpression } from "../../expression-converter.js";
-import { createDiagnostic } from "../../../types/diagnostic.js";
-const referenceTypeIdentity = (type) => type.typeId?.stableId
-    ? `id:${type.typeId.stableId}`
-    : type.resolvedClrType
-        ? `clr:${type.resolvedClrType}`
-        : `name:${type.name}`;
-const irTypesEqual = (left, right) => {
-    if (left.kind !== right.kind)
-        return false;
-    switch (left.kind) {
-        case "primitiveType":
-            return left.name === right.name;
-        case "literalType":
-            return left.value === right.value;
-        case "voidType":
-        case "unknownType":
-        case "anyType":
-        case "neverType":
-            return true;
-        case "typeParameterType":
-            return left.name === right.name;
-        case "arrayType":
-            return irTypesEqual(left.elementType, right.elementType);
-        case "tupleType": {
-            const rhs = right;
-            if (left.elementTypes.length !== rhs.elementTypes.length)
-                return false;
-            return left.elementTypes.every((t, i) => {
-                const other = rhs.elementTypes[i];
-                return other ? irTypesEqual(t, other) : false;
-            });
-        }
-        case "dictionaryType":
-            return (irTypesEqual(left.keyType, right.keyType) &&
-                irTypesEqual(left.valueType, right.valueType));
-        case "referenceType": {
-            const rhs = right;
-            if (referenceTypeIdentity(left) !== referenceTypeIdentity(rhs))
-                return false;
-            const leftArgs = left.typeArguments ?? [];
-            const rightArgs = rhs.typeArguments ?? [];
-            if (leftArgs.length !== rightArgs.length)
-                return false;
-            return leftArgs.every((t, i) => {
-                const other = rightArgs[i];
-                return other ? irTypesEqual(t, other) : false;
-            });
-        }
-        case "unionType":
-        case "intersectionType": {
-            const rhs = right;
-            if (left.types.length !== rhs.types.length)
-                return false;
-            return left.types.every((t, i) => {
-                const other = rhs.types[i];
-                return other ? irTypesEqual(t, other) : false;
-            });
-        }
-        case "functionType": {
-            const rhs = right;
-            if (left.parameters.length !== rhs.parameters.length)
-                return false;
-            const paramsEqual = left.parameters.every((p, i) => {
-                const other = rhs.parameters[i];
-                if (!other ||
-                    p.isRest !== other.isRest ||
-                    p.isOptional !== other.isOptional)
-                    return false;
-                if (!p.type || !other.type)
-                    return p.type === other.type;
-                return irTypesEqual(p.type, other.type);
-            });
-            return paramsEqual && irTypesEqual(left.returnType, rhs.returnType);
-        }
-        case "objectType": {
-            const rhs = right;
-            if (left.members.length !== rhs.members.length)
-                return false;
-            return left.members.every((m, i) => {
-                const other = rhs.members[i];
-                if (!other || m.kind !== other.kind || m.name !== other.name) {
-                    return false;
-                }
-                if (m.kind === "propertySignature") {
-                    return (other.kind === "propertySignature" &&
-                        m.isOptional === other.isOptional &&
-                        m.isReadonly === other.isReadonly &&
-                        irTypesEqual(m.type, other.type));
-                }
-                if (other.kind !== "methodSignature")
-                    return false;
-                if ((m.typeParameters?.length ?? 0) !==
-                    (other.typeParameters?.length ?? 0))
-                    return false;
-                if (m.parameters.length !== other.parameters.length)
-                    return false;
-                const paramsMatch = m.parameters.every((p, paramIndex) => {
-                    const otherParam = other.parameters[paramIndex];
-                    if (!otherParam)
-                        return false;
-                    if (p.isRest !== otherParam.isRest ||
-                        p.isOptional !== otherParam.isOptional ||
-                        p.passing !== otherParam.passing) {
-                        return false;
-                    }
-                    if (!p.type || !otherParam.type)
-                        return p.type === otherParam.type;
-                    return irTypesEqual(p.type, otherParam.type);
-                });
-                if (!paramsMatch)
-                    return false;
-                if (!m.returnType || !other.returnType) {
-                    return m.returnType === other.returnType;
-                }
-                return irTypesEqual(m.returnType, other.returnType);
-            });
-        }
-    }
-};
-const unifyTypeTemplate = (template, actual, substitutions) => {
-    if (template.kind === "typeParameterType") {
-        const existing = substitutions.get(template.name);
-        if (!existing) {
-            substitutions.set(template.name, actual);
-            return true;
-        }
-        return irTypesEqual(existing, actual);
-    }
-    if (template.kind !== actual.kind)
-        return false;
-    switch (template.kind) {
-        case "primitiveType":
-            return template.name === actual.name;
-        case "literalType":
-            return template.value === actual.value;
-        case "voidType":
-        case "unknownType":
-        case "anyType":
-        case "neverType":
-            return true;
-        case "arrayType":
-            return unifyTypeTemplate(template.elementType, actual.elementType, substitutions);
-        case "tupleType": {
-            const rhs = actual;
-            if (template.elementTypes.length !== rhs.elementTypes.length)
-                return false;
-            return template.elementTypes.every((t, i) => {
-                const other = rhs.elementTypes[i];
-                return other ? unifyTypeTemplate(t, other, substitutions) : false;
-            });
-        }
-        case "dictionaryType":
-            return (unifyTypeTemplate(template.keyType, actual.keyType, substitutions) &&
-                unifyTypeTemplate(template.valueType, actual.valueType, substitutions));
-        case "referenceType": {
-            const rhs = actual;
-            if (referenceTypeIdentity(template) !== referenceTypeIdentity(rhs))
-                return false;
-            const templateArgs = template.typeArguments ?? [];
-            const actualArgs = rhs.typeArguments ?? [];
-            if (templateArgs.length !== actualArgs.length)
-                return false;
-            return templateArgs.every((t, i) => {
-                const other = actualArgs[i];
-                return other ? unifyTypeTemplate(t, other, substitutions) : false;
-            });
-        }
-        case "unionType":
-        case "intersectionType": {
-            const rhs = actual;
-            if (template.types.length !== rhs.types.length)
-                return false;
-            return template.types.every((t, i) => {
-                const other = rhs.types[i];
-                return other ? unifyTypeTemplate(t, other, substitutions) : false;
-            });
-        }
-        case "functionType": {
-            const rhs = actual;
-            if (template.parameters.length !== rhs.parameters.length)
-                return false;
-            const paramsMatch = template.parameters.every((p, i) => {
-                const other = rhs.parameters[i];
-                if (!other ||
-                    p.isRest !== other.isRest ||
-                    p.isOptional !== other.isOptional)
-                    return false;
-                if (!p.type || !other.type)
-                    return p.type === other.type;
-                return unifyTypeTemplate(p.type, other.type, substitutions);
-            });
-            return (paramsMatch &&
-                unifyTypeTemplate(template.returnType, rhs.returnType, substitutions));
-        }
-        case "objectType": {
-            const rhs = actual;
-            if (template.members.length !== rhs.members.length)
-                return false;
-            return template.members.every((m, i) => {
-                const other = rhs.members[i];
-                if (!other || m.kind !== other.kind || m.name !== other.name) {
-                    return false;
-                }
-                if (m.kind === "propertySignature") {
-                    return (other.kind === "propertySignature" &&
-                        m.isOptional === other.isOptional &&
-                        m.isReadonly === other.isReadonly &&
-                        unifyTypeTemplate(m.type, other.type, substitutions));
-                }
-                if (other.kind !== "methodSignature")
-                    return false;
-                if ((m.typeParameters?.length ?? 0) !==
-                    (other.typeParameters?.length ?? 0))
-                    return false;
-                if (m.parameters.length !== other.parameters.length)
-                    return false;
-                const paramsMatch = m.parameters.every((p, paramIndex) => {
-                    const otherParam = other.parameters[paramIndex];
-                    if (!otherParam)
-                        return false;
-                    if (p.isRest !== otherParam.isRest ||
-                        p.isOptional !== otherParam.isOptional ||
-                        p.passing !== otherParam.passing) {
-                        return false;
-                    }
-                    if (!p.type || !otherParam.type)
-                        return p.type === otherParam.type;
-                    return unifyTypeTemplate(p.type, otherParam.type, substitutions);
-                });
-                if (!paramsMatch)
-                    return false;
-                if (!m.returnType || !other.returnType) {
-                    return m.returnType === other.returnType;
-                }
-                return unifyTypeTemplate(m.returnType, other.returnType, substitutions);
-            });
-        }
-    }
-};
-const deriveSubstitutionsFromExpectedReturn = (returnTemplate, expectedType) => {
-    if (!returnTemplate || !expectedType)
-        return undefined;
-    const candidateQueue = expectedType.kind === "unionType"
-        ? [...expectedType.types]
-        : [expectedType];
-    const candidates = [];
-    const seen = new Set();
-    const enqueue = (candidate) => {
-        const key = JSON.stringify(candidate);
-        if (seen.has(key))
-            return;
-        seen.add(key);
-        candidateQueue.push(candidate);
-    };
-    while (candidateQueue.length > 0) {
-        const candidate = candidateQueue.shift();
-        if (!candidate)
-            continue;
-        candidates.push(candidate);
-        if (candidate.kind === "referenceType" &&
-            candidate.typeArguments &&
-            candidate.typeArguments.length === 1) {
-            const simpleName = candidate.name.split(".").pop() ?? candidate.name;
-            const clrName = candidate.resolvedClrType ?? candidate.name;
-            const isAsyncWrapper = simpleName === "Promise" ||
-                simpleName === "Task_1" ||
-                simpleName === "Task`1" ||
-                simpleName === "ValueTask_1" ||
-                simpleName === "ValueTask`1" ||
-                clrName === "System.Threading.Tasks.Task" ||
-                clrName === "System.Threading.Tasks.ValueTask" ||
-                clrName.startsWith("System.Threading.Tasks.Task`1") ||
-                clrName.startsWith("System.Threading.Tasks.ValueTask`1");
-            if (isAsyncWrapper) {
-                const inner = candidate.typeArguments[0];
-                if (inner)
-                    enqueue(inner);
-            }
-        }
-        else if (candidate.kind === "unionType") {
-            for (const member of candidate.types) {
-                enqueue(member);
-            }
-        }
-    }
-    let matched;
-    for (const candidate of candidates) {
-        const attempt = new Map();
-        if (!unifyTypeTemplate(returnTemplate, candidate, attempt))
-            continue;
-        if (attempt.size === 0)
-            continue;
-        if (matched) {
-            return undefined;
-        }
-        matched = attempt;
-    }
-    return matched;
-};
-const substituteTypeParameters = (type, substitutions) => {
-    if (!type)
-        return undefined;
-    switch (type.kind) {
-        case "typeParameterType":
-            return substitutions.get(type.name) ?? type;
-        case "arrayType":
-            return {
-                ...type,
-                elementType: substituteTypeParameters(type.elementType, substitutions),
-            };
-        case "tupleType":
-            return {
-                ...type,
-                elementTypes: type.elementTypes.map((t) => substituteTypeParameters(t, substitutions)),
-            };
-        case "dictionaryType":
-            return {
-                ...type,
-                keyType: substituteTypeParameters(type.keyType, substitutions),
-                valueType: substituteTypeParameters(type.valueType, substitutions),
-            };
-        case "referenceType":
-            return {
-                ...type,
-                ...(type.typeArguments
-                    ? {
-                        typeArguments: type.typeArguments.map((t) => substituteTypeParameters(t, substitutions)),
-                    }
-                    : {}),
-            };
-        case "unionType":
-        case "intersectionType":
-            return {
-                ...type,
-                types: type.types.map((t) => substituteTypeParameters(t, substitutions)),
-            };
-        case "functionType":
-            return {
-                ...type,
-                parameters: type.parameters.map((p) => ({
-                    ...p,
-                    type: substituteTypeParameters(p.type, substitutions),
-                })),
-                returnType: substituteTypeParameters(type.returnType, substitutions),
-            };
-        case "objectType":
-            return {
-                ...type,
-                members: type.members.map((m) => {
-                    if (m.kind === "propertySignature") {
-                        return {
-                            ...m,
-                            type: substituteTypeParameters(m.type, substitutions),
-                        };
-                    }
-                    return {
-                        ...m,
-                        typeParameters: m.typeParameters?.map((tp) => ({
-                            ...tp,
-                            constraint: substituteTypeParameters(tp.constraint, substitutions),
-                            default: substituteTypeParameters(tp.default, substitutions),
-                        })),
-                        parameters: m.parameters.map((p) => ({
-                            ...p,
-                            type: substituteTypeParameters(p.type, substitutions),
-                        })),
-                        returnType: substituteTypeParameters(m.returnType, substitutions),
-                    };
-                }),
-            };
-        default:
-            return type;
-    }
-};
-/**
- * Unwrap call-site argument modifier markers.
- *
- * @tsonic/core/lang.js exports compile-time-only intrinsics:
- * - out(x)   → emit `out x` at the call site
- * - ref(x)   → emit `ref x`
- * - inref(x) → emit `in x`
- *
- * These markers must be erased by the compiler and must never reach emission as
- * normal calls.
- */
-const unwrapCallSiteArgumentModifier = (expr) => {
-    // Unwrap parentheses first (out((x)) etc).
-    let current = expr;
-    while (ts.isParenthesizedExpression(current)) {
-        current = current.expression;
-    }
-    if (!ts.isCallExpression(current))
-        return { expression: expr };
-    if (!ts.isIdentifier(current.expression))
-        return { expression: expr };
-    const name = current.expression.text;
-    if (name !== "out" && name !== "ref" && name !== "inref") {
-        return { expression: expr };
-    }
-    // Markers are non-generic and take exactly one argument.
-    if (current.typeArguments && current.typeArguments.length > 0) {
-        return { expression: expr };
-    }
-    if (current.arguments.length !== 1) {
-        return { expression: expr };
-    }
-    const inner = current.arguments[0];
-    if (!inner)
-        return { expression: expr };
-    const modifier = name === "inref" ? "in" : name;
-    return { expression: inner, modifier };
-};
-const applyCallSiteArgumentModifiers = (base, overrides, argCount, ctx, node) => {
-    const hasOverrides = overrides.some((m) => m !== undefined);
-    if (!hasOverrides)
-        return base;
-    const passing = base?.slice(0, argCount) ?? Array(argCount).fill("value");
-    for (let i = 0; i < argCount; i++) {
-        const override = overrides[i];
-        if (!override)
-            continue;
-        const existing = passing[i];
-        // If we have a resolved signature, call-site modifiers must match it exactly.
-        // (We do not currently use call-site modifiers to influence overload resolution.)
-        if (base !== undefined && existing !== override) {
-            ctx.diagnostics.push(createDiagnostic("TSN7444", "error", `Call-site passing modifier '${override}' conflicts with resolved signature (expected '${existing}' at argument ${i}).`, getSourceSpan(node), "Remove the call-site modifier, or call the correct overload that matches ref/out/in."));
-            continue;
-        }
-        passing[i] = override;
-    }
-    return passing;
-};
-/**
- * Extract argument passing modes from resolved signature.
- * Returns array aligned with arguments, indicating ref/out/in/value for each.
- *
- * ALICE'S SPEC: Uses TypeSystem to get parameter modes.
- * Parameter modes were normalized in Binding at registration time.
- */
-const extractArgumentPassing = (node, ctx) => {
-    // Get the TypeSystem
-    const typeSystem = ctx.typeSystem;
-    // Handle both CallExpression and NewExpression
-    const sigId = ts.isCallExpression(node)
-        ? ctx.binding.resolveCallSignature(node)
-        : ctx.binding.resolveConstructorSignature(node);
-    if (!sigId)
-        return undefined;
-    // Use TypeSystem.resolveCall() to get parameter modes
-    const resolved = typeSystem.resolveCall({
-        sigId,
-        argumentCount: ts.isCallExpression(node)
-            ? node.arguments.length
-            : (node.arguments?.length ?? 0),
-    });
-    // Return parameter modes from TypeSystem (already normalized in Binding)
-    return resolved.parameterModes;
-};
-/**
- * Get the declared return type from a call or new expression's signature.
- *
- * This function extracts the return type from the **signature declaration's TypeNode**,
- * NOT from TypeScript's inferred type. This is critical for preserving CLR type aliases.
- *
- * For generic methods, type parameters are substituted using the receiver's type arguments.
- * For example: `dict.get(key)` where `dict: Dictionary<int, Todo>` returns `Todo | undefined`,
- * not `TValue | undefined`.
- *
- * Returns undefined if:
- * - No signature found
- * - No declaration on signature
- * - No return type annotation on declaration
- */
-// DELETED: getReturnTypeFromFunctionType - Was part of fallback path
-// DELETED: getCalleesDeclaredType - Was part of fallback path
-// Alice's spec: TypeSystem.resolveCall() is the single source of truth.
-/**
- * Walk a property access chain and build a qualified name.
- * For `Foo.Bar.Baz`, returns "Foo.Bar.Baz" by walking the AST identifiers.
- * This avoids getText() which bakes source formatting into type identity.
- */
-const buildQualifiedName = (expr) => {
-    if (ts.isIdentifier(expr)) {
-        return expr.text;
-    }
-    if (ts.isPropertyAccessExpression(expr)) {
-        const parts = [];
-        let current = expr;
-        while (ts.isPropertyAccessExpression(current)) {
-            parts.unshift(current.name.text);
-            current = current.expression;
-        }
-        if (ts.isIdentifier(current)) {
-            parts.unshift(current.text);
-            return parts.join(".");
-        }
-    }
-    return undefined;
-};
-// DELETED: getDeclaredReturnTypeFallback - Alice's spec: no fallbacks allowed
-// TypeSystem.resolveCall() is the single source of truth.
-// DELETED: normalizeReceiverToNominal - No longer needed without NominalEnv fallback
-// DELETED: getDeclaredReturnTypeNominalEnvFallback - Alice's spec: no fallbacks allowed
-// TypeSystem.resolveCall() is the single source of truth.
-/**
- * Get the declared return type from a call or new expression's signature.
- *
- * ALICE'S SPEC: Uses TypeSystem.resolveCall() EXCLUSIVELY.
- * NO FALLBACKS. If TypeSystem can't resolve, return unknownType.
- * This ensures any missing TypeSystem functionality surfaces as test failures.
- */
-export const getDeclaredReturnType = (node, ctx, receiverIrType) => {
-    const DEBUG = process.env.DEBUG_RETURN_TYPE === "1";
-    const methodName = ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)
-        ? node.expression.name.text
-        : undefined;
-    if (DEBUG && methodName) {
-        console.log("[getDeclaredReturnType]", methodName, "receiver:", receiverIrType);
-    }
-    // Handle new expressions specially - they construct the type from the expression
-    if (ts.isNewExpression(node)) {
-        // For new expressions with explicit type arguments
-        if (node.typeArguments && node.typeArguments.length > 0) {
-            const typeName = buildQualifiedName(node.expression);
-            if (typeName) {
-                // PHASE 4 (Alice's spec): Use captureTypeSyntax + typeFromSyntax
-                const typeSystem = ctx.typeSystem;
-                return {
-                    kind: "referenceType",
-                    name: typeName,
-                    typeArguments: node.typeArguments.map((ta) => typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(ta))),
-                };
-            }
-        }
-        // For constructors without type arguments, use the class name
-        const typeName = buildQualifiedName(node.expression);
-        if (typeName) {
-            return { kind: "referenceType", name: typeName };
-        }
-        return undefined;
-    }
-    // For call expressions, use TypeSystem.resolveCall() EXCLUSIVELY
-    const typeSystem = ctx.typeSystem;
-    const sigId = ctx.binding.resolveCallSignature(node);
-    if (!sigId) {
-        if (DEBUG && methodName)
-            console.log("[getDeclaredReturnType]", methodName, "No signature resolved");
-        return undefined;
-    }
-    // Get argument count for totality
-    const argumentCount = node.arguments.length;
-    // Extract explicit type arguments from call site if any
-    // PHASE 4 (Alice's spec): Use captureTypeSyntax + typeFromSyntax
-    const explicitTypeArgs = node.typeArguments
-        ? node.typeArguments.map((ta) => typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(ta)))
-        : undefined;
-    // Use TypeSystem.resolveCall() - guaranteed to return a result
-    // NO FALLBACK: If TypeSystem returns unknownType, that's the answer
-    const resolved = typeSystem.resolveCall({
-        sigId,
-        argumentCount,
-        receiverType: receiverIrType,
-        explicitTypeArgs,
-    });
-    if (DEBUG && methodName) {
-        console.log("[getDeclaredReturnType]", methodName, "TypeSystem returned:", resolved.returnType);
-    }
-    // Return TypeSystem's answer directly - no fallbacks
-    return resolved.returnType;
-};
-const extractArgumentPassingFromParameterModifiers = (modifiers, argCount) => {
-    if (modifiers.length === 0)
-        return undefined;
-    const passing = Array(argCount).fill("value");
-    for (const mod of modifiers) {
-        if (mod.index >= 0 && mod.index < argCount) {
-            passing[mod.index] = mod.modifier;
-        }
-    }
-    return passing;
-};
-/**
- * Extract argument passing modes from CLR bindings for the *selected overload*.
- *
- * CRITICAL: Methods can be overloaded, and overloads can differ in ref/out/in modifiers.
- * We must not attach a single overload's modifiers to the member access itself.
- *
- * This resolver selects the best-matching binding overload using the call's argument
- * types, then applies that overload's parameterModifiers.
- */
-const extractArgumentPassingFromBinding = (callee, argCount, ctx, parameterTypes, argTypes) => {
-    if (callee.kind !== "memberAccess" || !callee.memberBinding)
-        return undefined;
-    // Fast path: already-resolved modifiers (extension methods or non-overloaded members).
-    const directMods = callee.memberBinding.parameterModifiers;
-    if (directMods && directMods.length > 0) {
-        return extractArgumentPassingFromParameterModifiers(directMods, argCount);
-    }
-    // No member binding → no CLR parameter modifiers.
-    const binding = callee.memberBinding;
-    const overloadsAll = ctx.bindings.getClrMemberOverloads(binding.assembly, binding.type, binding.member);
-    if (!overloadsAll || overloadsAll.length === 0)
-        return undefined;
-    const calledName = typeof callee.property === "string" ? callee.property : undefined;
-    const overloads = calledName
-        ? overloadsAll.filter((m) => m.alias === calledName || m.name === calledName)
-        : overloadsAll;
-    if (overloads.length === 0)
-        return undefined;
-    const matchTypes = parameterTypes ?? argTypes;
-    const hasMatchTypes = matchTypes && matchTypes.some((t) => t !== undefined);
-    const splitSignatureTypeList = (str) => {
-        const result = [];
-        let depth = 0;
-        let current = "";
-        for (const char of str) {
-            if (char === "[") {
-                depth++;
-                current += char;
-            }
-            else if (char === "]") {
-                depth--;
-                current += char;
-            }
-            else if (char === "," && depth === 0) {
-                result.push(current.trim());
-                current = "";
-            }
-            else {
-                current += char;
-            }
-        }
-        if (current.trim())
-            result.push(current.trim());
-        return result;
-    };
-    const parseParameterTypes = (sig) => {
-        if (!sig)
-            return [];
-        const paramsMatch = sig.match(/\|\(([^)]*)\):/);
-        const paramsStr = paramsMatch?.[1]?.trim();
-        if (!paramsStr)
-            return [];
-        return splitSignatureTypeList(paramsStr).map((s) => s.trim());
-    };
-    const extractSimpleClrName = (typeName) => {
-        let t = typeName.trim();
-        if (t.endsWith("&"))
-            t = t.slice(0, -1);
-        if (t.endsWith("[]"))
-            t = t.slice(0, -2);
-        const bracket = t.indexOf("[");
-        if (bracket >= 0)
-            t = t.slice(0, bracket);
-        const lastDot = t.lastIndexOf(".");
-        if (lastDot >= 0)
-            t = t.slice(lastDot + 1);
-        return t;
-    };
-    const primitiveToClrSimpleName = (name) => {
-        switch (name) {
-            case "string":
-                return "String";
-            case "boolean":
-            case "bool":
-                return "Boolean";
-            case "char":
-                return "Char";
-            case "byte":
-                return "Byte";
-            case "sbyte":
-                return "SByte";
-            case "short":
-                return "Int16";
-            case "ushort":
-                return "UInt16";
-            case "int":
-                return "Int32";
-            case "uint":
-                return "UInt32";
-            case "long":
-                return "Int64";
-            case "ulong":
-                return "UInt64";
-            case "float":
-                return "Single";
-            case "double":
-                return "Double";
-            case "decimal":
-                return "Decimal";
-            default:
-                return undefined;
-        }
-    };
-    const collectMatchNames = (t) => {
-        switch (t.kind) {
-            case "primitiveType": {
-                const mapped = primitiveToClrSimpleName(t.name);
-                return mapped ? [mapped] : [];
-            }
-            case "referenceType": {
-                const lastDot = t.name.lastIndexOf(".");
-                const simple = lastDot >= 0 ? t.name.slice(lastDot + 1) : t.name;
-                return [
-                    simple
-                        .replace(/\$instance$/, "")
-                        .replace(/^\_\_/, "")
-                        .replace(/\$views$/, ""),
-                ];
-            }
-            case "unionType":
-                return Array.from(new Set(t.types.flatMap((x) => collectMatchNames(x))));
-            case "intersectionType":
-                return Array.from(new Set(t.types.flatMap((x) => collectMatchNames(x))));
-            default:
-                return [];
-        }
-    };
-    const modifiersKey = (m) => {
-        const mods = m.parameterModifiers ?? [];
-        if (mods.length === 0)
-            return "";
-        return [...mods]
-            .slice()
-            .sort((a, b) => a.index - b.index)
-            .map((mod) => `${mod.index}:${mod.modifier}`)
-            .join(",");
-    };
-    const scoreCandidate = (m) => {
-        if (!hasMatchTypes)
-            return 0;
-        const paramTypes = parseParameterTypes(m.signature);
-        let score = 0;
-        for (let i = 0; i < argCount; i++) {
-            const expected = matchTypes?.[i];
-            if (!expected)
-                continue;
-            const expectedNames = collectMatchNames(expected);
-            if (expectedNames.length === 0)
-                continue;
-            const paramType = paramTypes[i];
-            if (!paramType)
-                continue;
-            const paramName = extractSimpleClrName(paramType);
-            if (expectedNames.includes(paramName)) {
-                score += 10;
-            }
-            else {
-                score -= 3;
-            }
-        }
-        return score;
-    };
-    // Discard candidates that can't accept the provided arguments (best-effort, arity only).
-    const candidates = overloads.filter((m) => {
-        if (typeof m.parameterCount !== "number")
-            return true;
-        return m.parameterCount >= argCount;
-    });
-    if (candidates.length === 0)
-        return undefined;
-    let bestScore = Number.NEGATIVE_INFINITY;
-    let best = [];
-    for (const c of candidates) {
-        const score = scoreCandidate(c);
-        if (score > bestScore) {
-            bestScore = score;
-            best = [c];
-        }
-        else if (score === bestScore) {
-            best.push(c);
-        }
-    }
-    if (best.length === 0)
-        return undefined;
-    // If ambiguous, only accept when all best candidates agree on modifiers.
-    const first = best[0];
-    if (!first)
-        return undefined;
-    const key = modifiersKey(first);
-    if (best.some((m) => modifiersKey(m) !== key)) {
-        return undefined;
-    }
-    const chosenMods = first.parameterModifiers;
-    if (!chosenMods || chosenMods.length === 0)
-        return undefined;
-    return extractArgumentPassingFromParameterModifiers(chosenMods, argCount);
-};
-/**
- * Convert call expression
- */
-export const convertCallExpression = (node, ctx, expectedType) => {
-    // Check for asinterface<T>(x) - compile-time-only interface view.
-    //
-    // Airplane-grade rule:
-    // - Must not introduce runtime casts in emitted C#.
-    // - Used to treat a value as a CLR interface/nominal type for TS type-checking.
-    if (ts.isIdentifier(node.expression) &&
-        node.expression.text === "asinterface" &&
-        node.typeArguments &&
-        node.typeArguments.length === 1 &&
-        node.arguments.length === 1) {
-        const targetTypeNode = node.typeArguments[0];
-        const argNode = node.arguments[0];
-        if (!targetTypeNode || !argNode) {
-            throw new Error("ICE: asinterface requires exactly 1 type argument and 1 argument");
-        }
-        const typeSystem = ctx.typeSystem;
-        const targetType = typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(targetTypeNode));
-        const argExpr = convertExpression(argNode, ctx, targetType);
-        return {
-            kind: "asinterface",
-            expression: argExpr,
-            targetType,
-            inferredType: targetType,
-            sourceSpan: getSourceSpan(node),
-        };
-    }
-    // Check for istype<T>(x) - compiler-only type guard used for overload specialization.
-    //
-    // Airplane-grade rule:
-    // - istype must be erased by the compiler (no runtime emission).
-    // - It is only valid in contexts where the compiler can prove the result is constant
-    //   (e.g., when specializing an overload implementation).
-    //
-    // We still convert it into an IR call so it can participate in control-flow narrowing
-    // and later specialization passes.
-    if (ts.isIdentifier(node.expression) &&
-        node.expression.text === "istype" &&
-        node.typeArguments &&
-        node.typeArguments.length === 1 &&
-        node.arguments.length === 1) {
-        const targetTypeNode = node.typeArguments[0];
-        const argNode = node.arguments[0];
-        if (!targetTypeNode || !argNode) {
-            throw new Error("ICE: istype requires exactly 1 type argument and 1 argument");
-        }
-        const typeSystem = ctx.typeSystem;
-        const targetType = typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(targetTypeNode));
-        const argExpr = convertExpression(argNode, ctx, undefined);
-        const callee = convertExpression(node.expression, ctx, undefined);
-        return {
-            kind: "call",
-            callee,
-            arguments: [argExpr],
-            isOptional: false,
-            inferredType: { kind: "primitiveType", name: "boolean" },
-            typeArguments: [targetType],
-            sourceSpan: getSourceSpan(node),
-        };
-    }
-    // Check for defaultof<T>() - language intrinsic for default value.
-    // defaultof<T>() compiles to C#: default(T)
-    if (ts.isIdentifier(node.expression) &&
-        node.expression.text === "defaultof" &&
-        node.typeArguments &&
-        node.typeArguments.length === 1 &&
-        node.arguments.length === 0) {
-        const targetTypeNode = node.typeArguments[0];
-        if (!targetTypeNode) {
-            throw new Error("ICE: defaultof requires exactly 1 type argument");
-        }
-        const typeSystem = ctx.typeSystem;
-        const targetType = typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(targetTypeNode));
-        return {
-            kind: "defaultof",
-            targetType,
-            inferredType: targetType,
-            sourceSpan: getSourceSpan(node),
-        };
-    }
-    // Check for trycast<T>(x) - special intrinsic for safe casting
-    // trycast<T>(x) compiles to C#: x as T (safe cast, returns null on failure)
-    if (ts.isIdentifier(node.expression) &&
-        node.expression.text === "trycast" &&
-        node.typeArguments &&
-        node.typeArguments.length === 1 &&
-        node.arguments.length === 1) {
-        // We've verified length === 1 above, so these are guaranteed to exist
-        const targetTypeNode = node.typeArguments[0];
-        const argNode = node.arguments[0];
-        if (!targetTypeNode || !argNode) {
-            throw new Error("ICE: trycast requires exactly 1 type argument and 1 argument");
-        }
-        // PHASE 4 (Alice's spec): Use captureTypeSyntax + typeFromSyntax
-        const typeSystem = ctx.typeSystem;
-        const targetType = typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(targetTypeNode));
-        const argExpr = convertExpression(argNode, ctx, undefined);
-        // Build union type T | null for inferredType
-        const nullType = { kind: "primitiveType", name: "null" };
-        const unionType = {
-            kind: "unionType",
-            types: [targetType, nullType],
-        };
-        return {
-            kind: "trycast",
-            expression: argExpr,
-            targetType,
-            inferredType: unionType,
-            sourceSpan: getSourceSpan(node),
-        };
-    }
-    // Check for stackalloc<T>(size) - language intrinsic for stack allocation.
-    // stackalloc<T>(size) compiles to C#: stackalloc T[size]
-    if (ts.isIdentifier(node.expression) &&
-        node.expression.text === "stackalloc" &&
-        node.typeArguments &&
-        node.typeArguments.length === 1 &&
-        node.arguments.length === 1) {
-        const elementTypeNode = node.typeArguments[0];
-        const sizeNode = node.arguments[0];
-        if (!elementTypeNode || !sizeNode) {
-            throw new Error("ICE: stackalloc requires exactly 1 type argument and 1 argument");
-        }
-        const typeSystem = ctx.typeSystem;
-        const elementType = typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(elementTypeNode));
-        const sizeExpr = convertExpression(sizeNode, ctx, {
-            kind: "primitiveType",
-            name: "int",
-        });
-        return {
-            kind: "stackalloc",
-            elementType,
-            size: sizeExpr,
-            inferredType: {
-                kind: "referenceType",
-                name: "Span",
-                typeArguments: [elementType],
-            },
-            sourceSpan: getSourceSpan(node),
-        };
-    }
-    // Extract type arguments from the call signature
-    const typeArguments = extractTypeArguments(node, ctx);
-    const requiresSpecialization = checkIfRequiresSpecialization(node, ctx);
-    // Convert callee first so we can access memberBinding and receiver type
-    const callee = convertExpression(node.expression, ctx, undefined);
-    // Extract receiver type for member method calls (e.g., dict.get() → dict's type)
-    const receiverIrType = callee.kind === "memberAccess" ? callee.object.inferredType : undefined;
-    // Resolve call (two-pass):
-    // 1) Resolve parameter types (for expectedType threading)
-    // 2) Convert arguments, then re-resolve with argTypes to infer generics deterministically
-    const typeSystem = ctx.typeSystem;
-    const sigId = ctx.binding.resolveCallSignature(node);
-    const argumentCount = node.arguments.length;
-    const callSiteArgModifiers = new Array(argumentCount).fill(undefined);
-    const explicitTypeArgs = node.typeArguments
-        ? node.typeArguments.map((ta) => typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(ta)))
-        : undefined;
-    // If we can't resolve a signature handle (common for calls through function-typed
-    // variables), fall back to the callee's inferred function type.
-    const calleeFunctionType = (() => {
-        const t = callee.inferredType;
-        if (!t)
-            return undefined;
-        if (t.kind === "functionType")
-            return t;
-        return typeSystem.delegateToFunctionType(t) ?? undefined;
-    })();
-    if (!sigId && calleeFunctionType) {
-        const params = calleeFunctionType.parameters;
-        const paramTypesForArgs = [];
-        const hasRest = params.some((p) => p.isRest);
-        for (let i = 0; i < node.arguments.length; i++) {
-            const p = params[i] ?? (hasRest ? params[params.length - 1] : undefined);
-            paramTypesForArgs[i] = p?.type;
-        }
-        const args = [];
-        for (let i = 0; i < node.arguments.length; i++) {
-            const arg = node.arguments[i];
-            if (!arg)
-                continue;
-            const expectedType = paramTypesForArgs[i];
-            if (ts.isSpreadElement(arg)) {
-                const spreadExpr = convertExpression(arg.expression, ctx, undefined);
-                args.push({
-                    kind: "spread",
-                    expression: spreadExpr,
-                    inferredType: spreadExpr.inferredType,
-                    sourceSpan: getSourceSpan(arg),
-                });
-                continue;
-            }
-            const unwrapped = unwrapCallSiteArgumentModifier(arg);
-            if (unwrapped.modifier) {
-                callSiteArgModifiers[i] = unwrapped.modifier;
-            }
-            args.push(convertExpression(unwrapped.expression, ctx, expectedType));
-        }
-        const argumentPassing = applyCallSiteArgumentModifiers(extractArgumentPassing(node, ctx), callSiteArgModifiers, argumentCount, ctx, node);
-        return {
-            kind: "call",
-            callee,
-            arguments: args,
-            isOptional: node.questionDotToken !== undefined,
-            inferredType: calleeFunctionType.returnType,
-            sourceSpan: getSourceSpan(node),
-            typeArguments,
-            requiresSpecialization,
-            argumentPassing,
-            parameterTypes: paramTypesForArgs,
-        };
-    }
-    const initialResolved = sigId
-        ? typeSystem.resolveCall({
-            sigId,
-            argumentCount,
-            receiverType: receiverIrType,
-            explicitTypeArgs,
-            expectedReturnType: expectedType,
-        })
-        : undefined;
-    const initialParameterTypes = (() => {
-        const substitutions = deriveSubstitutionsFromExpectedReturn(initialResolved?.returnType, expectedType);
-        if (!substitutions || !initialResolved?.parameterTypes) {
-            return initialResolved?.parameterTypes;
-        }
-        return initialResolved.parameterTypes.map((t) => substituteTypeParameters(t, substitutions));
-    })();
-    const isLambdaArg = (expr) => {
-        if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr))
-            return true;
-        if (ts.isParenthesizedExpression(expr))
-            return isLambdaArg(expr.expression);
-        return false;
-    };
-    const isExplicitlyTypedLambdaArg = (expr) => {
-        if (ts.isParenthesizedExpression(expr)) {
-            return isExplicitlyTypedLambdaArg(expr.expression);
-        }
-        if (!ts.isArrowFunction(expr) && !ts.isFunctionExpression(expr)) {
-            return false;
-        }
-        if (expr.type)
-            return true;
-        if (expr.typeParameters && expr.typeParameters.length > 0)
-            return true;
-        return expr.parameters.some((p) => p.type !== undefined);
-    };
-    const shouldDeferLambdaForInference = (expr) => isLambdaArg(expr) && !isExplicitlyTypedLambdaArg(expr);
-    // Pass 1: convert non-lambda arguments and infer type args from them.
-    const argsWorking = new Array(node.arguments.length);
-    const argTypesForInference = Array(node.arguments.length).fill(undefined);
-    for (let index = 0; index < node.arguments.length; index++) {
-        const arg = node.arguments[index];
-        if (!arg)
-            continue;
-        const expectedType = initialParameterTypes?.[index];
-        if (ts.isSpreadElement(arg)) {
-            const spreadExpr = convertExpression(arg.expression, ctx, undefined);
-            argsWorking[index] = {
-                kind: "spread",
-                expression: spreadExpr,
-                inferredType: spreadExpr.inferredType,
-                sourceSpan: getSourceSpan(arg),
-            };
-            continue;
-        }
-        const unwrapped = unwrapCallSiteArgumentModifier(arg);
-        if (unwrapped.modifier) {
-            callSiteArgModifiers[index] = unwrapped.modifier;
-        }
-        if (shouldDeferLambdaForInference(unwrapped.expression)) {
-            // Defer *untyped* lambda conversion until after we infer generic type args
-            // from other arguments. Explicitly typed lambdas are safe to convert early
-            // and often provide the only deterministic inference signal.
-            continue;
-        }
-        const converted = convertExpression(unwrapped.expression, ctx, expectedType);
-        argsWorking[index] = converted;
-        argTypesForInference[index] = converted.inferredType;
-    }
-    const lambdaContextResolved = sigId
-        ? typeSystem.resolveCall({
-            sigId,
-            argumentCount,
-            receiverType: receiverIrType,
-            explicitTypeArgs,
-            argTypes: argTypesForInference,
-            expectedReturnType: expectedType,
-        })
-        : initialResolved;
-    const parameterTypesForLambdaContext = lambdaContextResolved?.parameterTypes ?? initialParameterTypes;
-    // Pass 2: convert lambda arguments with inferred parameter types in scope.
-    //
-    // IMPORTANT (airplane-grade):
-    // Lambdas may have been converted in Pass 1 (e.g., because they have explicit
-    // parameter annotations) before we had a fully resolved call signature.
-    //
-    // In those cases, block-bodied arrows can lose contextual return types and be
-    // treated as `void`, which then mis-emits `return expr;` as:
-    //   expr;
-    //   return;
-    //
-    // Re-convert *all* lambda arguments here using the resolved parameter type so
-    // contextual parameter + return typing is applied deterministically.
-    for (let index = 0; index < node.arguments.length; index++) {
-        const arg = node.arguments[index];
-        if (!arg)
-            continue;
-        if (ts.isSpreadElement(arg))
-            continue;
-        const unwrapped = unwrapCallSiteArgumentModifier(arg);
-        if (unwrapped.modifier) {
-            callSiteArgModifiers[index] = unwrapped.modifier;
-        }
-        if (!isLambdaArg(unwrapped.expression))
-            continue;
-        const expectedType = parameterTypesForLambdaContext?.[index];
-        const lambdaExpectedType = expectedType?.kind === "functionType"
-            ? expectedType
-            : expectedType
-                ? (typeSystem.delegateToFunctionType(expectedType) ?? expectedType)
-                : undefined;
-        argsWorking[index] = convertExpression(unwrapped.expression, ctx, lambdaExpectedType);
-    }
-    const convertedArgs = argsWorking.map((a) => {
-        if (!a) {
-            throw new Error("ICE: call argument conversion produced a hole");
-        }
-        return a;
-    });
-    const argTypes = convertedArgs.map((a) => a.kind === "spread" ? undefined : a.inferredType);
-    const finalResolved = sigId
-        ? typeSystem.resolveCall({
-            sigId,
-            argumentCount,
-            receiverType: receiverIrType,
-            explicitTypeArgs,
-            argTypes,
-            expectedReturnType: expectedType,
-        })
-        : lambdaContextResolved;
-    const parameterTypes = finalResolved?.parameterTypes ?? initialParameterTypes;
-    const inferredType = finalResolved?.returnType ?? { kind: "unknownType" };
-    const argumentPassingFromBinding = extractArgumentPassingFromBinding(callee, node.arguments.length, ctx, parameterTypes, argTypes);
-    const argumentPassing = argumentPassingFromBinding ??
-        (finalResolved
-            ? finalResolved.parameterModes.slice(0, node.arguments.length)
-            : extractArgumentPassing(node, ctx));
-    const argumentPassingWithOverrides = applyCallSiteArgumentModifiers(argumentPassing, callSiteArgModifiers, argumentCount, ctx, node);
-    const narrowing = (() => {
-        const pred = finalResolved?.typePredicate;
-        if (!pred)
-            return undefined;
-        if (pred.kind !== "param")
-            return undefined;
-        return {
-            kind: "typePredicate",
-            argIndex: pred.parameterIndex,
-            targetType: pred.targetType,
-        };
-    })();
-    return {
-        kind: "call",
-        callee,
-        // Pass parameter types as expectedType for deterministic contextual typing
-        // This ensures `spreadArray([1,2,3], [4,5,6])` with `number[]` params produces `double[]`
-        arguments: convertedArgs,
-        isOptional: node.questionDotToken !== undefined,
-        inferredType,
-        sourceSpan: getSourceSpan(node),
-        typeArguments,
-        requiresSpecialization,
-        argumentPassing: argumentPassingWithOverrides,
-        parameterTypes,
-        narrowing,
-    };
-};
-// DELETED: getConstructedType - Phase 15 uses resolveCall.returnType instead
-/**
- * Convert new expression
- *
- * Phase 15 (Alice's spec): Two-pass resolution for deterministic constructor typing.
- * 1) Resolve once (without argTypes) to get parameter types for expected-type threading.
- * 2) Convert non-lambda arguments first, collecting argTypes for inference.
- * 3) Re-resolve with argTypes to infer constructor type parameters.
- * 4) Convert lambda arguments using instantiated parameter types.
- * 5) Final resolve with full argTypes.
- * 6) inferredType MUST be finalResolved.returnType.
- */
-export const convertNewExpression = (node, ctx) => {
-    // Extract explicit type arguments (for IR output, not inference)
-    const typeArguments = extractTypeArguments(node, ctx);
-    const requiresSpecialization = checkIfRequiresSpecialization(node, ctx);
-    // Convert callee (the constructor expression)
-    const callee = convertExpression(node.expression, ctx, undefined);
-    // Two-pass resolution (matching convertCallExpression pattern)
-    const typeSystem = ctx.typeSystem;
-    const sigId = ctx.binding.resolveConstructorSignature(node);
-    const argumentCount = node.arguments?.length ?? 0;
-    const callSiteArgModifiers = new Array(argumentCount).fill(undefined);
-    // Extract explicit type arguments from call site
-    const explicitTypeArgs = node.typeArguments
-        ? node.typeArguments.map((ta) => typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(ta)))
-        : undefined;
-    // Initial resolution (without argTypes) for parameter type threading
-    const initialResolved = sigId
-        ? typeSystem.resolveCall({
-            sigId,
-            argumentCount,
-            explicitTypeArgs,
-        })
-        : undefined;
-    const initialParameterTypes = initialResolved?.parameterTypes;
-    const isLambdaArg = (expr) => {
-        if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr))
-            return true;
-        if (ts.isParenthesizedExpression(expr))
-            return isLambdaArg(expr.expression);
-        return false;
-    };
-    // Pass 1: convert non-lambda arguments and collect argTypes for inference
-    const argsWorking = new Array(argumentCount);
-    const argTypesForInference = Array(argumentCount).fill(undefined);
-    const args = node.arguments ?? [];
-    for (let index = 0; index < args.length; index++) {
-        const arg = args[index];
-        if (!arg)
-            continue;
-        const expectedType = initialParameterTypes?.[index];
-        if (ts.isSpreadElement(arg)) {
-            const spreadExpr = convertExpression(arg.expression, ctx, undefined);
-            argsWorking[index] = {
-                kind: "spread",
-                expression: spreadExpr,
-                inferredType: spreadExpr.inferredType,
-                sourceSpan: getSourceSpan(arg),
-            };
-            continue;
-        }
-        const unwrapped = unwrapCallSiteArgumentModifier(arg);
-        if (unwrapped.modifier) {
-            callSiteArgModifiers[index] = unwrapped.modifier;
-        }
-        if (isLambdaArg(unwrapped.expression)) {
-            // Defer lambda conversion until after generic type arg inference
-            continue;
-        }
-        const converted = convertExpression(unwrapped.expression, ctx, expectedType);
-        argsWorking[index] = converted;
-        argTypesForInference[index] = converted.inferredType;
-    }
-    // Re-resolve with argTypes to infer constructor type parameters
-    const lambdaContextResolved = sigId
-        ? typeSystem.resolveCall({
-            sigId,
-            argumentCount,
-            explicitTypeArgs,
-            argTypes: argTypesForInference,
-        })
-        : initialResolved;
-    const parameterTypesForLambdaContext = lambdaContextResolved?.parameterTypes ?? initialParameterTypes;
-    // Pass 2: convert lambda arguments with inferred parameter types
-    for (let index = 0; index < args.length; index++) {
-        if (argsWorking[index])
-            continue;
-        const arg = args[index];
-        if (!arg)
-            continue;
-        if (ts.isSpreadElement(arg))
-            continue;
-        const unwrapped = unwrapCallSiteArgumentModifier(arg);
-        if (unwrapped.modifier) {
-            callSiteArgModifiers[index] = unwrapped.modifier;
-        }
-        if (!isLambdaArg(unwrapped.expression))
-            continue;
-        const expectedType = parameterTypesForLambdaContext?.[index];
-        const lambdaExpectedType = expectedType?.kind === "functionType"
-            ? expectedType
-            : expectedType
-                ? (typeSystem.delegateToFunctionType(expectedType) ?? expectedType)
-                : undefined;
-        argsWorking[index] = convertExpression(unwrapped.expression, ctx, lambdaExpectedType);
-    }
-    // Fill any remaining undefined slots (shouldn't happen, but be safe)
-    const convertedArgs = argsWorking.map((a, index) => {
-        if (a)
-            return a;
-        const arg = args[index];
-        if (!arg) {
-            throw new Error("ICE: new expression argument conversion produced a hole");
-        }
-        if (ts.isSpreadElement(arg)) {
-            const spreadExpr = convertExpression(arg.expression, ctx, undefined);
-            return {
-                kind: "spread",
-                expression: spreadExpr,
-                inferredType: spreadExpr.inferredType,
-                sourceSpan: getSourceSpan(arg),
-            };
-        }
-        const unwrapped = unwrapCallSiteArgumentModifier(arg);
-        if (unwrapped.modifier) {
-            callSiteArgModifiers[index] = unwrapped.modifier;
-        }
-        return convertExpression(unwrapped.expression, ctx, undefined);
-    });
-    // Collect final argTypes
-    const argTypes = convertedArgs.map((a) => a.kind === "spread" ? undefined : a.inferredType);
-    // Final resolution with full argTypes
-    const finalResolved = sigId
-        ? typeSystem.resolveCall({
-            sigId,
-            argumentCount,
-            explicitTypeArgs,
-            argTypes,
-        })
-        : lambdaContextResolved;
-    // Phase 15: inferredType MUST be finalResolved.returnType
-    // If sigId is missing, use unknownType (do not fabricate a nominal type)
-    const inferredType = finalResolved?.returnType ?? {
-        kind: "unknownType",
-    };
-    const parameterTypes = finalResolved?.parameterTypes ?? initialParameterTypes;
-    const argumentPassingBase = finalResolved
-        ? finalResolved.parameterModes.slice(0, argumentCount)
-        : extractArgumentPassing(node, ctx);
-    const argumentPassing = applyCallSiteArgumentModifiers(argumentPassingBase, callSiteArgModifiers, argumentCount, ctx, node);
-    // Phase 18: IrNewExpression.typeArguments must include inferred type arguments.
-    // The emitter relies on this field to emit generic constructor calls (e.g., new Box<int>(...)).
-    const inferredTypeArguments = inferredType.kind === "referenceType"
-        ? inferredType.typeArguments
-        : undefined;
-    const typeArgumentsForIr = typeArguments ??
-        (inferredTypeArguments && inferredTypeArguments.length > 0
-            ? inferredTypeArguments
-            : undefined);
-    return {
-        kind: "new",
-        callee,
-        arguments: convertedArgs,
-        inferredType,
-        sourceSpan: getSourceSpan(node),
-        argumentPassing,
-        parameterTypes,
-        typeArguments: typeArgumentsForIr,
-        requiresSpecialization,
-    };
-};
+export { getDeclaredReturnType, convertCallExpression, } from "./calls/call-converter.js";
+export { convertNewExpression } from "./calls/new-converter.js";
 //# sourceMappingURL=calls.js.map