@tsonic/frontend 0.0.60 → 0.0.62

package/dist/ir/type-system/type-system.js

@@ -14,7 +14,7 @@
 import * as ts from "typescript";
 import { substituteIrType as irSubstitute, } from "../types/ir-substitution.js";
 import { inferNumericKindFromRaw } from "../types/numeric-helpers.js";
-import { getBinaryResultKind, TSONIC_TO_NUMERIC_KIND } from "../types/numeric-kind.js";
+import { getBinaryResultKind, TSONIC_TO_NUMERIC_KIND, } from "../types/numeric-kind.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // BUILTIN NOMINAL MAPPING
 // ═══════════════════════════════════════════════════════════════════════════
@@ -144,6 +144,19 @@ export const createTypeSystem = (config) => {
     // ─────────────────────────────────────────────────────────────────────────
     // RAW SIGNATURE EXTRACTION
     // ─────────────────────────────────────────────────────────────────────────
+    const addUndefinedToType = (type) => {
+        const undefinedType = {
+            kind: "primitiveType",
+            name: "undefined",
+        };
+        if (type.kind === "unionType") {
+            const hasUndefined = type.types.some((x) => x.kind === "primitiveType" && x.name === "undefined");
+            return hasUndefined
+                ? type
+                : { ...type, types: [...type.types, undefinedType] };
+        }
+        return { kind: "unionType", types: [type, undefinedType] };
+    };
     /**
      * Get or compute raw signature info from SignatureId.
      * Caches the result for subsequent calls.
@@ -156,7 +169,18 @@ export const createTypeSystem = (config) => {
         if (!sigInfo)
             return undefined;
         // Convert parameter types from TypeNodes to IrTypes
-        const parameterTypes = sigInfo.parameters.map((p) => (p.typeNode ? convertTypeNode(p.typeNode) : undefined));
+        const parameterTypes = sigInfo.parameters.map((p) => {
+            const baseType = p.typeNode ? convertTypeNode(p.typeNode) : undefined;
+            if (!baseType)
+                return undefined;
+            // Optional/defaulted parameters must accept explicit `undefined` at call sites.
+            return p.isOptional ? addUndefinedToType(baseType) : baseType;
+        });
+        // Convert a TypeScript `this:` parameter type (if present) to an IrType.
+        const thisParameterType = (() => {
+            const n = sigInfo.thisTypeNode;
+            return n ? convertTypeNode(n) : undefined;
+        })();
         // Extract parameter modes
         const parameterModes = sigInfo.parameters.map((p) => p.mode ?? "value");
         // Extract parameter names
@@ -179,7 +203,10 @@ export const createTypeSystem = (config) => {
             // identity captured in Binding and the (class) type parameters captured for the
             // constructor signature.
             if (isConstructor && sigInfo.declaringTypeTsName) {
-                const typeArguments = typeParameters.map((tp) => ({ kind: "typeParameterType", name: tp.name }));
+                const typeArguments = typeParameters.map((tp) => ({
+                    kind: "typeParameterType",
+                    name: tp.name,
+                }));
                 return {
                     kind: "referenceType",
                     name: sigInfo.declaringTypeTsName,
@@ -209,6 +236,7 @@ export const createTypeSystem = (config) => {
         }
         const rawSig = {
             parameterTypes,
+            thisParameterType,
             returnType,
             parameterModes,
             typeParameters,
@@ -450,11 +478,24 @@ export const createTypeSystem = (config) => {
      * Look up a member on a structural (object) type.
      */
     const lookupStructuralMember = (type, memberName, site) => {
+        const addUndefinedToType = (t) => {
+            const undefinedType = {
+                kind: "primitiveType",
+                name: "undefined",
+            };
+            if (t.kind === "unionType") {
+                const hasUndefined = t.types.some((x) => x.kind === "primitiveType" && x.name === "undefined");
+                return hasUndefined ? t : { ...t, types: [...t.types, undefinedType] };
+            }
+            return { kind: "unionType", types: [t, undefinedType] };
+        };
         if (type.kind === "objectType") {
             const member = type.members.find((m) => m.name === memberName);
             if (member) {
                 if (member.kind === "propertySignature") {
-                    return member.type;
+                    return member.isOptional
+                        ? addUndefinedToType(member.type)
+                        : member.type;
                 }
                 // Method signature - return function type using the same parameters
                 if (member.kind === "methodSignature") {
@@ -473,7 +514,9 @@ export const createTypeSystem = (config) => {
             const member = type.structuralMembers.find((m) => m.name === memberName);
             if (member) {
                 if (member.kind === "propertySignature") {
-                    return member.type;
+                    return member.isOptional
+                        ? addUndefinedToType(member.type)
+                        : member.type;
                 }
                 if (member.kind === "methodSignature") {
                     const funcType = {
@@ -570,6 +613,25 @@ export const createTypeSystem = (config) => {
             return filtered[0];
         return { kind: "unionType", types: filtered };
     };
+    // tsbindgen-generated "sticky extension scope" helpers are TS-only wrappers that
+    // must erase for deterministic IR typing and call inference.
+    //
+    // Example (generated bindings for Tsonic source):
+    //   import type { ExtensionMethods as __TsonicExt_Ef } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js";
+    //   readonly Tenants: __TsonicExt_Ef<...>;
+    //
+    // These wrapper types have no CLR identity. For the compiler, the only meaningful
+    // runtime/CLR shape is the inner type argument.
+    const stripTsonicExtensionWrappers = (type) => {
+        if (type.kind === "referenceType") {
+            if (type.name.startsWith("__TsonicExt_") &&
+                (type.typeArguments?.length ?? 0) === 1) {
+                const inner = type.typeArguments?.[0];
+                return inner ? stripTsonicExtensionWrappers(inner) : type;
+            }
+        }
+        return type;
+    };
     const unwrapAwaitedForInference = (type) => {
         if (type.kind === "unionType") {
             return {
@@ -602,14 +664,15 @@ export const createTypeSystem = (config) => {
      * Deterministically infer an expression's type using only:
      * - local lambda parameter environment
      * - declaration types (typeOfDecl)
- * - numeric literal lexeme rules
- *
- * This is intentionally small: it's used only to type lambda bodies for
- * initializer-driven generic inference (e.g., `Enumerable.select(..., x => x * 2)`).
- */
+     * - numeric literal lexeme rules
+     *
+     * This is intentionally small: it's used only to type lambda bodies for
+     * initializer-driven generic inference (e.g., `Enumerable.select(..., x => x * 2)`).
+     */
     const inferExpressionType = (expr, env) => {
         const unwrapped = unwrapParens(expr);
-        if (ts.isAsExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped)) {
+        if (ts.isAsExpression(unwrapped) ||
+            ts.isTypeAssertionExpression(unwrapped)) {
             return convertTypeNode(unwrapped.type);
         }
         if (ts.isNonNullExpression(unwrapped)) {
@@ -790,13 +853,13 @@ export const createTypeSystem = (config) => {
         });
         const env = new Map();
         for (const p of parameters) {
-            if (p.pattern.kind === "identifierPattern" &&
-                p.pattern.name &&
-                p.type) {
+            if (p.pattern.kind === "identifierPattern" && p.pattern.name && p.type) {
                 env.set(p.pattern.name, p.type);
             }
         }
-        const explicitReturnType = "type" in unwrapped && unwrapped.type ? convertTypeNode(unwrapped.type) : undefined;
+        const explicitReturnType = "type" in unwrapped && unwrapped.type
+            ? convertTypeNode(unwrapped.type)
+            : undefined;
         const expectedReturnType = expectedFnType?.returnType;
         const inferredReturnType = explicitReturnType ??
             (expectedReturnType && !containsTypeParameter(expectedReturnType)
@@ -1157,6 +1220,10 @@ export const createTypeSystem = (config) => {
             const inferred = inferExpressionType(init, new Map());
             return inferred && inferred.kind !== "unknownType" ? inferred : undefined;
         }
+        const inferred = inferExpressionType(init, new Map());
+        if (inferred && inferred.kind !== "unknownType") {
+            return inferred;
+        }
         return undefined;
     };
     const typeOfDecl = (declId) => {
@@ -1222,7 +1289,9 @@ export const createTypeSystem = (config) => {
         const effectiveReceiver = receiver.kind === "unionType"
             ? (() => {
                 const nonNullish = receiver.types.filter((t) => t && !isNullishPrimitive(t));
-                return nonNullish.length === 1 && nonNullish[0] ? nonNullish[0] : receiver;
+                return nonNullish.length === 1 && nonNullish[0]
+                    ? nonNullish[0]
+                    : receiver;
             })()
             : receiver;
         // 1. Normalize receiver to nominal form
@@ -1230,7 +1299,8 @@ export const createTypeSystem = (config) => {
         if (!normalized) {
             // Handle structural types (objectType)
             if (effectiveReceiver.kind === "objectType" ||
-                (effectiveReceiver.kind === "referenceType" && effectiveReceiver.structuralMembers)) {
+                (effectiveReceiver.kind === "referenceType" &&
+                    effectiveReceiver.structuralMembers)) {
                 return lookupStructuralMember(effectiveReceiver, memberName, site);
             }
             emitDiagnostic("TSN5203", `Cannot resolve member '${memberName}' on type`, site);
@@ -1333,7 +1403,9 @@ export const createTypeSystem = (config) => {
         if (!first)
             return undefined;
         // Strip assembly qualification (", Assembly, Version=..., ...") if present.
-        const withoutAsm = first.includes(",") ? (first.split(",")[0] ?? first) : first;
+        const withoutAsm = first.includes(",")
+            ? (first.split(",")[0] ?? first)
+            : first;
         return withoutAsm.trim();
     };
     const getIndexerInfo = (receiver, _site) => {
@@ -1401,7 +1473,22 @@ export const createTypeSystem = (config) => {
                 return true;
             }
             // Poison/any provides no deterministic information
-            if (argumentType.kind === "unknownType" || argumentType.kind === "anyType") {
+            if (argumentType.kind === "unknownType" ||
+                argumentType.kind === "anyType") {
+                return true;
+            }
+            // Intersection argument types: unify through each constituent.
+            //
+            // This is required for airplane-grade extension method typing where the receiver
+            // often has the form `TShape & <extension markers> & <method table>`.
+            // Generic inference must still be able to infer through the real CLR shape in the intersection.
+            if (argumentType.kind === "intersectionType") {
+                for (const part of argumentType.types) {
+                    if (!part)
+                        continue;
+                    if (!tryUnify(parameterType, part))
+                        return false;
+                }
                 return true;
             }
             // Expression<TDelegate> wrapper: infer through the underlying delegate shape.
@@ -1419,12 +1506,14 @@ export const createTypeSystem = (config) => {
             // Without this, generic methods like:
             //   Select<TResult>(selector: Func<TSource, TResult>)
             // cannot infer TResult from a lambda argument, causing TSN5201/TSN5202.
-            if (parameterType.kind === "referenceType" && argumentType.kind === "functionType") {
+            if (parameterType.kind === "referenceType" &&
+                argumentType.kind === "functionType") {
                 const delegateFn = delegateToFunctionType(parameterType);
                 if (delegateFn)
                     return tryUnify(delegateFn, argumentType);
             }
-            if (parameterType.kind === "functionType" && argumentType.kind === "referenceType") {
+            if (parameterType.kind === "functionType" &&
+                argumentType.kind === "referenceType") {
                 const delegateFn = delegateToFunctionType(argumentType);
                 if (delegateFn)
                     return tryUnify(parameterType, delegateFn);
@@ -1435,14 +1524,18 @@ export const createTypeSystem = (config) => {
                 (parameterType.typeArguments?.length ?? 0) === 1 &&
                 argumentType.kind === "arrayType") {
                 const elementParam = parameterType.typeArguments?.[0];
-                return elementParam ? tryUnify(elementParam, argumentType.elementType) : true;
+                return elementParam
+                    ? tryUnify(elementParam, argumentType.elementType)
+                    : true;
             }
             // Union parameter type: allow deterministic inference through common nullish unions.
             // Example: constructor(value: T | null) with argument of type T.
             if (parameterType.kind === "unionType") {
                 const nonNullish = parameterType.types.filter((t) => t && !isNullishPrimitive(t));
                 const nullish = parameterType.types.filter((t) => t && isNullishPrimitive(t));
-                const candidates = isNullishPrimitive(argumentType) ? nullish : nonNullish;
+                const candidates = isNullishPrimitive(argumentType)
+                    ? nullish
+                    : nonNullish;
                 if (candidates.length === 1) {
                     const only = candidates[0];
                     return only ? tryUnify(only, argumentType) : true;
@@ -1455,7 +1548,9 @@ export const createTypeSystem = (config) => {
                 argumentType.name === "Array" &&
                 (argumentType.typeArguments?.length ?? 0) === 1) {
                 const elementArg = argumentType.typeArguments?.[0];
-                return elementArg ? tryUnify(parameterType.elementType, elementArg) : true;
+                return elementArg
+                    ? tryUnify(parameterType.elementType, elementArg)
+                    : true;
             }
             // Same-kind structural unification
             if (parameterType.kind !== argumentType.kind) {
@@ -1550,7 +1645,6 @@ export const createTypeSystem = (config) => {
                     }
                     return tryUnify(parameterType.returnType, argFn.returnType);
                 }
-                case "intersectionType":
                 case "objectType":
                 case "dictionaryType":
                     // Conservative: only infer through these when shapes already match exactly.
@@ -1573,6 +1667,80 @@ export const createTypeSystem = (config) => {
         }
         return substitution;
     };
+    const mapEntriesEqual = (left, right) => {
+        if (left.size !== right.size)
+            return false;
+        for (const [key, leftValue] of left) {
+            const rightValue = right.get(key);
+            if (!rightValue || !typesEqual(leftValue, rightValue))
+                return false;
+        }
+        return true;
+    };
+    const collectExpectedReturnCandidates = (type) => {
+        const queue = [type];
+        const out = [];
+        const seen = new Set();
+        const enqueue = (candidate) => {
+            if (!candidate)
+                return;
+            const key = JSON.stringify(candidate);
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            queue.push(candidate);
+        };
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current)
+                continue;
+            out.push(current);
+            if (current.kind === "unionType") {
+                for (const member of current.types)
+                    enqueue(member);
+                continue;
+            }
+            if (current.kind === "referenceType" && current.typeArguments) {
+                const typeId = current.typeId ??
+                    resolveTypeIdByName(current.resolvedClrType ?? current.name, current.typeArguments.length);
+                if (typeId) {
+                    const entry = unifiedCatalog.getByTypeId(typeId);
+                    if (entry?.aliasedType) {
+                        const aliasSubst = new Map();
+                        const aliasTypeParams = entry.typeParameters;
+                        const aliasTypeArgs = current.typeArguments;
+                        for (let i = 0; i < Math.min(aliasTypeParams.length, aliasTypeArgs.length); i++) {
+                            const tp = aliasTypeParams[i];
+                            const ta = aliasTypeArgs[i];
+                            if (tp && ta)
+                                aliasSubst.set(tp.name, ta);
+                        }
+                        const expanded = aliasSubst.size > 0
+                            ? irSubstitute(entry.aliasedType, aliasSubst)
+                            : entry.aliasedType;
+                        enqueue(expanded);
+                    }
+                }
+                if (current.typeArguments.length !== 1)
+                    continue;
+                const simpleName = current.name.split(".").pop() ?? current.name;
+                const clrName = current.resolvedClrType ?? current.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) {
+                    enqueue(current.typeArguments[0]);
+                }
+            }
+        }
+        return out;
+    };
     const containsMethodTypeParameter = (type, unresolved) => {
         if (type.kind === "typeParameterType")
             return unresolved.has(type.name);
@@ -1587,7 +1755,8 @@ export const createTypeSystem = (config) => {
         }
         if (type.kind === "functionType") {
             const paramsContain = type.parameters.some((p) => p.type ? containsMethodTypeParameter(p.type, unresolved) : false);
-            return paramsContain || containsMethodTypeParameter(type.returnType, unresolved);
+            return (paramsContain ||
+                containsMethodTypeParameter(type.returnType, unresolved));
         }
         if (type.kind === "unionType" || type.kind === "intersectionType") {
             return type.types.some((t) => t ? containsMethodTypeParameter(t, unresolved) : false);
@@ -1670,7 +1839,7 @@ export const createTypeSystem = (config) => {
         return score;
     };
     const tryResolveCallFromUnifiedCatalog = (declaringTypeTsName, declaringMemberName, query) => {
-        const { argumentCount, receiverType, explicitTypeArgs, argTypes, } = query;
+        const { argumentCount, receiverType, explicitTypeArgs, argTypes } = query;
         if (!argTypes)
             return undefined;
         if (argTypes.length < argumentCount)
@@ -1794,7 +1963,12 @@ export const createTypeSystem = (config) => {
         return best?.resolved;
     };
     const resolveCall = (query) => {
-        const { sigId, argumentCount, receiverType, explicitTypeArgs, argTypes, site, } = query;
+        const { sigId, argumentCount, receiverType, explicitTypeArgs, argTypes, expectedReturnType, site, } = query;
+        // Extension method scopes are modeled as TS-only wrapper types (e.g. __TsonicExt_Ef<T>).
+        // They must erase to their underlying CLR shapes for deterministic call inference.
+        const effectiveReceiverType = receiverType
+            ? stripTsonicExtensionWrappers(receiverType)
+            : undefined;
         // 1. Load raw signature (cached)
         const rawSig = getRawSignature(sigId);
         if (!rawSig) {
@@ -1810,15 +1984,19 @@ export const createTypeSystem = (config) => {
         }
         // 2. Start with raw types
         let workingParams = [...rawSig.parameterTypes];
+        let workingThisParam = rawSig.thisParameterType;
         let workingReturn = rawSig.returnType;
         let workingPredicate = rawSig.typePredicate;
         // 3. Compute receiver substitution (class type params)
-        if (receiverType &&
+        if (effectiveReceiverType &&
             rawSig.declaringTypeTsName &&
             rawSig.declaringMemberName) {
-            const receiverSubst = computeReceiverSubstitution(receiverType, rawSig.declaringTypeTsName, rawSig.declaringMemberName);
+            const receiverSubst = computeReceiverSubstitution(effectiveReceiverType, rawSig.declaringTypeTsName, rawSig.declaringMemberName);
             if (receiverSubst && receiverSubst.size > 0) {
                 workingParams = workingParams.map((p) => p ? irSubstitute(p, receiverSubst) : undefined);
+                if (workingThisParam) {
+                    workingThisParam = irSubstitute(workingThisParam, receiverSubst);
+                }
                 workingReturn = irSubstitute(workingReturn, receiverSubst);
                 if (workingPredicate) {
                     workingPredicate =
@@ -1849,9 +2027,38 @@ export const createTypeSystem = (config) => {
                 }
             }
             // Source 2: Deterministic argument-driven unification
-            if (argTypes && argTypes.length > 0) {
+            // 2a) Receiver-driven unification via TS `this:` parameter
+            //
+            // Method-table extension typing represents the receiver as an explicit `this:` parameter
+            // in the `.d.ts` signature. Generic methods like:
+            //   ToArrayAsync<T>(this: IQueryable<T>, ...): Task<T[]>
+            // must infer T from the receiver even when there are ZERO call arguments.
+            //
+            // This is airplane-grade determinism: we anchor inference to the selected TS signature’s
+            // `this:` type and the IR receiver type (not TS structural tricks).
+            if (effectiveReceiverType && workingThisParam) {
+                const receiverParamForInference = callSubst.size > 0
+                    ? irSubstitute(workingThisParam, callSubst)
+                    : workingThisParam;
+                const inferredFromReceiver = inferMethodTypeArgsFromArguments(methodTypeParams, [receiverParamForInference], [effectiveReceiverType]);
+                if (inferredFromReceiver) {
+                    for (const [name, inferredType] of inferredFromReceiver) {
+                        const existing = callSubst.get(name);
+                        if (existing) {
+                            if (!typesEqual(existing, inferredType)) {
+                                emitDiagnostic("TSN5202", `Conflicting type argument inference for '${name}' (receiver)`, site);
+                                return poisonedCall(argumentCount, diagnostics.slice());
+                            }
+                            continue;
+                        }
+                        callSubst.set(name, inferredType);
+                    }
+                }
+            }
+            // 2b) Argument-driven unification (run even when argTypes is empty).
+            if (argTypes) {
                 const paramsForInference = callSubst.size > 0
-                    ? workingParams.map((p) => (p ? irSubstitute(p, callSubst) : undefined))
+                    ? workingParams.map((p) => p ? irSubstitute(p, callSubst) : undefined)
                     : workingParams;
                 const inferred = inferMethodTypeArgsFromArguments(methodTypeParams, paramsForInference, argTypes);
                 if (!inferred) {
@@ -1870,7 +2077,52 @@ export const createTypeSystem = (config) => {
                     callSubst.set(name, inferredType);
                 }
             }
-            // Source 3: Default type parameters
+            // Source 3: Contextual expected return type from the call site.
+            // This handles generic APIs where method type parameters appear only in
+            // the return position (or where argument inference is intentionally weak).
+            if (expectedReturnType) {
+                const returnForInference = callSubst.size > 0
+                    ? irSubstitute(workingReturn, callSubst)
+                    : workingReturn;
+                const expectedCandidates = collectExpectedReturnCandidates(expectedReturnType);
+                let matched;
+                for (const candidate of expectedCandidates) {
+                    const inferred = inferMethodTypeArgsFromArguments(methodTypeParams, [returnForInference], [candidate]);
+                    if (!inferred || inferred.size === 0)
+                        continue;
+                    let conflictsWithExisting = false;
+                    for (const [name, inferredType] of inferred) {
+                        const existing = callSubst.get(name);
+                        if (existing && !typesEqual(existing, inferredType)) {
+                            conflictsWithExisting = true;
+                            break;
+                        }
+                    }
+                    if (conflictsWithExisting)
+                        continue;
+                    if (matched && !mapEntriesEqual(matched, inferred)) {
+                        // Ambiguous contextual-return inference: ignore this source and
+                        // rely on explicit/argument/default inference only.
+                        matched = undefined;
+                        break;
+                    }
+                    matched = inferred;
+                }
+                if (matched) {
+                    for (const [name, inferredType] of matched) {
+                        const existing = callSubst.get(name);
+                        if (existing) {
+                            if (!typesEqual(existing, inferredType)) {
+                                emitDiagnostic("TSN5202", `Conflicting type argument inference for '${name}' (expected return context)`, site);
+                                return poisonedCall(argumentCount, diagnostics.slice());
+                            }
+                            continue;
+                        }
+                        callSubst.set(name, inferredType);
+                    }
+                }
+            }
+            // Source 4: Default type parameters
             for (const tp of methodTypeParams) {
                 if (!callSubst.has(tp.name) && tp.defaultType) {
                     callSubst.set(tp.name, tp.defaultType);
@@ -1897,7 +2149,8 @@ export const createTypeSystem = (config) => {
             const unresolved = new Set(methodTypeParams
                 .map((tp) => tp.name)
                 .filter((name) => !callSubst.has(name)));
-            if (unresolved.size > 0 && containsMethodTypeParameter(workingReturn, unresolved)) {
+            if (unresolved.size > 0 &&
+                containsMethodTypeParameter(workingReturn, unresolved)) {
                 const fallback = argTypes && rawSig.declaringTypeTsName && rawSig.declaringMemberName
                     ? tryResolveCallFromUnifiedCatalog(rawSig.declaringTypeTsName, rawSig.declaringMemberName, query)
                     : undefined;
@@ -2237,7 +2490,10 @@ export const createTypeSystem = (config) => {
      */
     const expandAwaitedUtility = (type) => {
         if (type.kind === "unionType") {
-            return { kind: "unionType", types: type.types.map((t) => expandAwaitedUtility(t)) };
+            return {
+                kind: "unionType",
+                types: type.types.map((t) => expandAwaitedUtility(t)),
+            };
         }
         // Check for Promise<T>
         if (type.kind === "referenceType" &&