@tsonic/frontend 0.0.14 → 0.0.15

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

@@ -1,380 +1,149 @@
 /**
  * Call and new expression converters
+ *
+ * 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 { getInferredType, getSourceSpan, extractTypeArguments, checkIfRequiresSpecialization, } from "./helpers.js";
+import { getSourceSpan, extractTypeArguments, checkIfRequiresSpecialization, } from "./helpers.js";
 import { convertExpression } from "../../expression-converter.js";
-import { convertType, convertTsTypeToIr } from "../../type-converter.js";
-/**
- * Extract argument passing modes from resolved signature
- * Returns array aligned with arguments, indicating ref/out/in/value for each
- */
-const extractArgumentPassing = (node, checker) => {
-    try {
-        const signature = checker.getResolvedSignature(node);
-        if (!signature || !signature.declaration) {
-            return undefined;
-        }
-        const decl = signature.declaration;
-        let parameters = [];
-        // Extract parameters from declaration
-        if (ts.isFunctionDeclaration(decl) ||
-            ts.isMethodDeclaration(decl) ||
-            ts.isConstructorDeclaration(decl) ||
-            ts.isArrowFunction(decl) ||
-            ts.isFunctionExpression(decl)) {
-            parameters = decl.parameters;
-        }
-        if (parameters.length === 0) {
-            return undefined;
-        }
-        // Build passing mode for each parameter
-        const passingModes = [];
-        for (const param of parameters) {
-            let passing = "value";
-            // Check if parameter type is ref<T>, out<T>, or in<T>
-            if (param.type &&
-                ts.isTypeReferenceNode(param.type) &&
-                ts.isIdentifier(param.type.typeName)) {
-                const typeName = param.type.typeName.text;
-                if ((typeName === "ref" || typeName === "out" || typeName === "in") &&
-                    param.type.typeArguments &&
-                    param.type.typeArguments.length > 0) {
-                    passing = typeName === "in" ? "in" : typeName;
-                }
-            }
-            passingModes.push(passing);
-        }
-        return passingModes;
-    }
-    catch {
-        return undefined;
-    }
-};
 /**
- * Safely convert a ts.Type to IrType
+ * 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 convertTsTypeToIrSafe = (tsType, node, checker) => {
-    try {
-        const typeNode = checker.typeToTypeNode(tsType, node, ts.NodeBuilderFlags.None);
-        return typeNode
-            ? convertType(typeNode, checker)
-            : convertTsTypeToIr(tsType, checker);
-    }
-    catch {
+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;
 };
 /**
- * Extract type predicate narrowing metadata from a call expression.
- * Returns narrowing info if the callee is a type predicate function (x is T).
- */
-const extractNarrowing = (node, checker) => {
-    try {
-        const sig = checker.getResolvedSignature(node);
-        if (!sig)
-            return undefined;
-        const pred = checker.getTypePredicateOfSignature(sig);
-        // We only handle "param is T" predicates (not "this is T")
-        if (pred &&
-            pred.kind === ts.TypePredicateKind.Identifier &&
-            pred.parameterIndex !== undefined &&
-            pred.type) {
-            const targetType = convertTsTypeToIrSafe(pred.type, node, checker);
-            if (targetType) {
-                return {
-                    kind: "typePredicate",
-                    argIndex: pred.parameterIndex,
-                    targetType,
-                };
-            }
-        }
-        return undefined;
-    }
-    catch {
-        return undefined;
-    }
-};
-/**
- * Build a substitution map from type parameter names to their instantiated TypeNodes.
+ * 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 a call like `dict.add(key, value)` where `dict: Dictionary<int, Todo>`,
- * this returns a map: { "TKey" -> int TypeNode, "TValue" -> Todo TypeNode }
+ * 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`.
  *
- * The key insight is that the RECEIVER's type (Dictionary<int, Todo>) preserves
- * the type arguments as TypeNodes, which in turn preserve CLR type aliases.
- * TypeScript's type instantiation mechanism loses aliasSymbol, but TypeNodes don't.
+ * Returns undefined if:
+ * - No signature found
+ * - No declaration on signature
+ * - No return type annotation on declaration
  */
-const buildTypeParameterSubstitutionMap = (node, checker) => {
-    // For method calls, get the receiver's type arguments
-    // e.g., for dict.add(...), get Dictionary<int, Todo>'s type arguments
-    if (ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression)) {
-        const receiver = node.expression.expression;
-        const receiverType = checker.getTypeAtLocation(receiver);
-        // Get the class/interface/type alias declaration that defines the type parameters
-        // For type aliases like Dictionary_2<TKey, TValue>, use aliasSymbol
-        // For classes/interfaces, use getSymbol()
-        const symbol = receiverType.aliasSymbol ?? receiverType.getSymbol();
-        if (!symbol)
-            return undefined;
-        const declarations = symbol.getDeclarations();
-        if (!declarations || declarations.length === 0)
-            return undefined;
-        // Find the class/interface/type alias declaration with type parameters
-        let typeParamDecls;
-        for (const decl of declarations) {
-            if (ts.isClassDeclaration(decl) && decl.typeParameters) {
-                typeParamDecls = decl.typeParameters;
-                break;
-            }
-            if (ts.isInterfaceDeclaration(decl) && decl.typeParameters) {
-                typeParamDecls = decl.typeParameters;
-                break;
-            }
-            if (ts.isTypeAliasDeclaration(decl) && decl.typeParameters) {
-                typeParamDecls = decl.typeParameters;
-                break;
-            }
-        }
-        if (!typeParamDecls || typeParamDecls.length === 0)
-            return undefined;
-        // Get the type arguments from the receiver's type
-        // IMPORTANT: We must trace back to the ORIGINAL source code AST to preserve
-        // CLR type aliases like `int`. TypeScript's typeToTypeNode() does NOT preserve
-        // type aliases - it synthesizes primitive keywords like NumberKeyword instead.
-        //
-        // Look for the variable declaration that has type arguments in:
-        // 1. Explicit type annotation: const dict: Dictionary<int, Todo> = ...
-        // 2. NewExpression initializer: const dict = new Dictionary<int, Todo>()
-        // 3. Other declaration forms (property, parameter)
-        const receiverSymbol = checker.getSymbolAtLocation(receiver);
-        if (receiverSymbol) {
-            const receiverDecls = receiverSymbol.getDeclarations();
-            if (receiverDecls) {
-                for (const decl of receiverDecls) {
-                    // Helper to build substitution map from type argument nodes
-                    const buildMapFromTypeArgs = (typeArgNodes) => {
-                        if (typeParamDecls &&
-                            typeArgNodes.length === typeParamDecls.length) {
-                            const substitutionMap = new Map();
-                            for (let i = 0; i < typeParamDecls.length; i++) {
-                                const paramDecl = typeParamDecls[i];
-                                const argNode = typeArgNodes[i];
-                                if (paramDecl && argNode) {
-                                    substitutionMap.set(paramDecl.name.text, argNode);
-                                }
-                            }
-                            return substitutionMap;
-                        }
-                        return undefined;
-                    };
-                    // Check explicit type annotation first
-                    if (ts.isVariableDeclaration(decl) && decl.type) {
-                        if (ts.isTypeReferenceNode(decl.type) && decl.type.typeArguments) {
-                            const result = buildMapFromTypeArgs(decl.type.typeArguments);
-                            if (result)
-                                return result;
-                        }
-                    }
-                    // Check initializer: new Dictionary<int, Todo>()
-                    // This handles: const todos = new Dictionary<int, Todo>();
-                    if (ts.isVariableDeclaration(decl) && decl.initializer) {
-                        // Handle direct NewExpression
-                        if (ts.isNewExpression(decl.initializer) &&
-                            decl.initializer.typeArguments) {
-                            const result = buildMapFromTypeArgs(decl.initializer.typeArguments);
-                            if (result)
-                                return result;
-                        }
-                        // Handle AsExpression (type assertion): new List<int>() as List<int>
-                        // The type arguments are in the AsExpression's type, not the NewExpression
-                        if (ts.isAsExpression(decl.initializer)) {
-                            const asType = decl.initializer.type;
-                            if (ts.isTypeReferenceNode(asType) && asType.typeArguments) {
-                                const result = buildMapFromTypeArgs(asType.typeArguments);
-                                if (result)
-                                    return result;
-                            }
-                        }
-                    }
-                    // Also check property declarations with type annotation
-                    if (ts.isPropertyDeclaration(decl) &&
-                        decl.type &&
-                        ts.isTypeReferenceNode(decl.type) &&
-                        decl.type.typeArguments) {
-                        const result = buildMapFromTypeArgs(decl.type.typeArguments);
-                        if (result)
-                            return result;
-                    }
-                    // Check property declaration initializer
-                    if (ts.isPropertyDeclaration(decl) && decl.initializer) {
-                        if (ts.isNewExpression(decl.initializer) &&
-                            decl.initializer.typeArguments) {
-                            const result = buildMapFromTypeArgs(decl.initializer.typeArguments);
-                            if (result)
-                                return result;
-                        }
-                    }
-                    // Check parameter declarations
-                    if (ts.isParameter(decl) &&
-                        decl.type &&
-                        ts.isTypeReferenceNode(decl.type) &&
-                        decl.type.typeArguments) {
-                        const result = buildMapFromTypeArgs(decl.type.typeArguments);
-                        if (result)
-                            return result;
-                    }
-                }
-            }
-        }
-    }
-    return undefined;
-};
+// 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.
 /**
- * Substitute type parameters in a TypeNode using the substitution map.
- * For a type like `TKey`, returns the substituted TypeNode (e.g., `int`).
- * For complex types like `List<TKey>`, recursively substitutes.
- *
- * Returns the substituted TypeNode, or undefined if no substitution needed.
+ * 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 substituteTypeNode = (typeNode, substitutionMap, checker) => {
-    // Handle type reference nodes (most common case)
-    if (ts.isTypeReferenceNode(typeNode)) {
-        const typeName = ts.isIdentifier(typeNode.typeName)
-            ? typeNode.typeName.text
-            : typeNode.typeName.getText();
-        // Direct substitution: if this is a type parameter, substitute it
-        const substitution = substitutionMap.get(typeName);
-        if (substitution) {
-            return substitution;
-        }
-        // Recursive substitution: if this is a generic type, substitute its type arguments
-        if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
-            let anySubstituted = false;
-            const newTypeArgs = [];
-            for (const arg of typeNode.typeArguments) {
-                const substituted = substituteTypeNode(arg, substitutionMap, checker);
-                if (substituted) {
-                    newTypeArgs.push(substituted);
-                    anySubstituted = true;
-                }
-                else {
-                    newTypeArgs.push(arg);
-                }
-            }
-            if (anySubstituted) {
-                // Create a new type reference with substituted type arguments
-                // We use the factory to create a new node
-                return ts.factory.createTypeReferenceNode(typeNode.typeName, newTypeArgs);
-            }
-        }
-    }
-    // Handle array types: T[] -> int[]
-    if (ts.isArrayTypeNode(typeNode)) {
-        const substituted = substituteTypeNode(typeNode.elementType, substitutionMap, checker);
-        if (substituted) {
-            return ts.factory.createArrayTypeNode(substituted);
-        }
+const buildQualifiedName = (expr) => {
+    if (ts.isIdentifier(expr)) {
+        return expr.text;
     }
-    // Handle union types: T | null -> int | null
-    if (ts.isUnionTypeNode(typeNode)) {
-        let anySubstituted = false;
-        const newTypes = [];
-        for (const member of typeNode.types) {
-            const substituted = substituteTypeNode(member, substitutionMap, checker);
-            if (substituted) {
-                newTypes.push(substituted);
-                anySubstituted = true;
-            }
-            else {
-                newTypes.push(member);
-            }
+    if (ts.isPropertyAccessExpression(expr)) {
+        const parts = [];
+        let current = expr;
+        while (ts.isPropertyAccessExpression(current)) {
+            parts.unshift(current.name.text);
+            current = current.expression;
         }
-        if (anySubstituted) {
-            return ts.factory.createUnionTypeNode(newTypes);
+        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.
 /**
- * Extract parameter types from resolved signature.
- * Used for threading expectedType to array literal arguments etc.
+ * Get the declared return type from a call or new expression's signature.
  *
- * Uses the resolved signature to get INSTANTIATED parameter types.
- * For example, for `dict.add(key, value)` where `dict: Dictionary<int, Todo>`,
- * this returns the instantiated types [int, Todo], not the formal types [TKey, TValue].
- *
- * CLR type aliases (like `int`) are preserved by:
- * 1. For non-type-parameter declarations: use the declaration's type node directly
- * 2. For type parameters: use TypeNode substitution to preserve CLR aliases
- *
- * The key insight is that TypeScript's type instantiation mechanism loses
- * aliasSymbol, but the original TypeNodes in variable declarations preserve
- * the type aliases. We trace back to those TypeNodes and substitute.
+ * 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.
  */
-const extractParameterTypes = (node, checker) => {
-    try {
-        const signature = checker.getResolvedSignature(node);
-        if (!signature) {
-            return undefined;
-        }
-        const sigParams = signature.getParameters();
-        if (sigParams.length === 0) {
-            return undefined;
-        }
-        // Build type parameter substitution map from receiver's type arguments
-        // This preserves CLR type aliases through generic instantiation
-        const substitutionMap = buildTypeParameterSubstitutionMap(node, checker);
-        // Build parameter type array using instantiated types from signature
-        const paramTypes = [];
-        for (const sigParam of sigParams) {
-            const decl = sigParam.valueDeclaration;
-            // Get the declaration's type node if available
-            if (decl && ts.isParameter(decl) && decl.type) {
-                // Check if the declaration type is a type parameter
-                const declType = checker.getTypeAtLocation(decl.type);
-                const isTypeParameter = Boolean(declType.flags & ts.TypeFlags.TypeParameter);
-                if (isTypeParameter) {
-                    if (substitutionMap) {
-                        // Type parameter case: use substitution map to preserve CLR aliases
-                        const substituted = substituteTypeNode(decl.type, substitutionMap, checker);
-                        if (substituted) {
-                            const irType = convertType(substituted, checker);
-                            if (irType) {
-                                paramTypes.push(irType);
-                                continue;
-                            }
-                        }
-                    }
-                    // Type parameter without substitution (e.g., generic function call with inferred types)
-                    // The type parameter is INFERRED from the argument, so don't validate against
-                    // TypeScript's instantiated type (which loses CLR type aliases like `int`).
-                    // Push undefined to skip validation for this parameter.
-                    paramTypes.push(undefined);
-                    continue;
-                }
-                else {
-                    // Non-type-parameter: use declaration type node directly
-                    // This preserves imported CLR type aliases like `int`
-                    const irType = convertType(decl.type, checker);
-                    if (irType) {
-                        paramTypes.push(irType);
-                        continue;
-                    }
-                }
+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))),
+                };
             }
-            // Fallback: Use instantiated type from getTypeOfSymbolAtLocation
-            // This handles cases where we couldn't get the declaration type
-            const paramType = checker.getTypeOfSymbolAtLocation(sigParam, decl ?? node);
-            const irType = convertTsTypeToIr(paramType, checker);
-            paramTypes.push(irType);
         }
-        return paramTypes;
+        // For constructors without type arguments, use the class name
+        const typeName = buildQualifiedName(node.expression);
+        if (typeName) {
+            return { kind: "referenceType", name: typeName };
+        }
+        return undefined;
     }
-    catch {
+    // 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;
 };
 /**
  * Extract argument passing modes from member binding's parameter modifiers.
@@ -404,18 +173,24 @@ const extractArgumentPassingFromBinding = (callee, argCount) => {
 /**
  * Convert call expression
  */
-export const convertCallExpression = (node, checker) => {
-    // 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)
+export const convertCallExpression = (node, ctx) => {
+    // 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.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 targetType = convertType(targetTypeNode, checker);
-        const argExpr = convertExpression(node.arguments[0], checker);
+        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 = {
@@ -423,39 +198,191 @@ export const convertCallExpression = (node, checker) => {
             types: [targetType, nullType],
         };
         return {
-            kind: "tryCast",
+            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, checker);
-    const requiresSpecialization = checkIfRequiresSpecialization(node, checker);
-    const narrowing = extractNarrowing(node, checker);
-    const parameterTypes = extractParameterTypes(node, checker);
-    // Convert callee first so we can access its memberBinding
-    const callee = convertExpression(node.expression, checker);
+    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 explicitTypeArgs = node.typeArguments
+        ? node.typeArguments.map((ta) => typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(ta)))
+        : undefined;
+    const initialResolved = sigId
+        ? typeSystem.resolveCall({
+            sigId,
+            argumentCount,
+            receiverType: receiverIrType,
+            explicitTypeArgs,
+        })
+        : undefined;
+    const initialParameterTypes = initialResolved?.parameterTypes;
     // Try to get argument passing from binding's parameter modifiers first (tsbindgen format),
     // then fall back to TypeScript declaration analysis (ref<T>/out<T>/in<T> wrapper types)
-    const argumentPassing = extractArgumentPassingFromBinding(callee, node.arguments.length) ??
-        extractArgumentPassing(node, checker);
+    const argumentPassingFromBinding = extractArgumentPassingFromBinding(callee, node.arguments.length);
+    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;
+        }
+        if (shouldDeferLambdaForInference(arg)) {
+            // 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(arg, ctx, expectedType);
+        argsWorking[index] = converted;
+        argTypesForInference[index] = converted.inferredType;
+    }
+    const lambdaContextResolved = sigId
+        ? typeSystem.resolveCall({
+            sigId,
+            argumentCount,
+            receiverType: receiverIrType,
+            explicitTypeArgs,
+            argTypes: argTypesForInference,
+        })
+        : initialResolved;
+    const parameterTypesForLambdaContext = lambdaContextResolved?.parameterTypes ?? initialParameterTypes;
+    // Pass 2: convert lambda arguments with inferred parameter types in scope.
+    for (let index = 0; index < node.arguments.length; index++) {
+        if (argsWorking[index])
+            continue;
+        const arg = node.arguments[index];
+        if (!arg)
+            continue;
+        if (ts.isSpreadElement(arg))
+            continue;
+        if (!isLambdaArg(arg))
+            continue;
+        const expectedType = parameterTypesForLambdaContext?.[index];
+        const lambdaExpectedType = expectedType?.kind === "functionType"
+            ? expectedType
+            : expectedType
+                ? typeSystem.delegateToFunctionType(expectedType) ?? expectedType
+                : undefined;
+        argsWorking[index] = convertExpression(arg, 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,
+        })
+        : lambdaContextResolved;
+    const parameterTypes = finalResolved?.parameterTypes ?? initialParameterTypes;
+    const inferredType = finalResolved?.returnType ?? { kind: "unknownType" };
+    const argumentPassing = argumentPassingFromBinding ??
+        (finalResolved
+            ? finalResolved.parameterModes.slice(0, node.arguments.length)
+            : extractArgumentPassing(node, ctx));
+    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,
-        arguments: node.arguments.map((arg) => {
-            if (ts.isSpreadElement(arg)) {
-                return {
-                    kind: "spread",
-                    expression: convertExpression(arg.expression, checker),
-                    sourceSpan: getSourceSpan(arg),
-                };
-            }
-            return convertExpression(arg, checker);
-        }),
+        // 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: getInferredType(node, checker),
+        inferredType,
         sourceSpan: getSourceSpan(node),
         typeArguments,
         requiresSpecialization,
@@ -464,29 +391,142 @@ export const convertCallExpression = (node, checker) => {
         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, checker) => {
-    // Extract type arguments from the constructor signature
-    const typeArguments = extractTypeArguments(node, checker);
-    const requiresSpecialization = checkIfRequiresSpecialization(node, checker);
+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;
+    // 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;
+        }
+        if (isLambdaArg(arg)) {
+            // Defer lambda conversion until after generic type arg inference
+            continue;
+        }
+        const converted = convertExpression(arg, 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;
+        if (!isLambdaArg(arg))
+            continue;
+        const expectedType = parameterTypesForLambdaContext?.[index];
+        const lambdaExpectedType = expectedType?.kind === "functionType"
+            ? expectedType
+            : expectedType
+                ? typeSystem.delegateToFunctionType(expectedType) ?? expectedType
+                : undefined;
+        argsWorking[index] = convertExpression(arg, 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");
+        }
+        return convertExpression(arg, 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" };
+    // 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: convertExpression(node.expression, checker),
-        arguments: node.arguments?.map((arg) => {
-            if (ts.isSpreadElement(arg)) {
-                return {
-                    kind: "spread",
-                    expression: convertExpression(arg.expression, checker),
-                    sourceSpan: getSourceSpan(arg),
-                };
-            }
-            return convertExpression(arg, checker);
-        }) ?? [],
-        inferredType: getInferredType(node, checker),
+        callee,
+        arguments: convertedArgs,
+        inferredType,
         sourceSpan: getSourceSpan(node),
-        typeArguments,
+        typeArguments: typeArgumentsForIr,
         requiresSpecialization,
     };
 };