@tsonic/frontend 0.0.59 → 0.0.61

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
 // ═══════════════════════════════════════════════════════════════════════════
@@ -157,6 +157,11 @@ export const createTypeSystem = (config) => {
             return undefined;
         // Convert parameter types from TypeNodes to IrTypes
         const parameterTypes = sigInfo.parameters.map((p) => (p.typeNode ? convertTypeNode(p.typeNode) : undefined));
+        // 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 +184,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 +217,7 @@ export const createTypeSystem = (config) => {
         }
         const rawSig = {
             parameterTypes,
+            thisParameterType,
             returnType,
             parameterModes,
             typeParameters,
@@ -602,14 +611,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 +800,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)
@@ -1222,7 +1232,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 +1242,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 +1346,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 +1416,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 +1449,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 +1467,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 +1491,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 +1588,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.
@@ -1587,7 +1624,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 +1708,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)
@@ -1810,6 +1848,7 @@ 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)
@@ -1819,6 +1858,9 @@ export const createTypeSystem = (config) => {
             const receiverSubst = computeReceiverSubstitution(receiverType, 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 +1891,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 (receiverType && workingThisParam) {
+                const receiverParamForInference = callSubst.size > 0
+                    ? irSubstitute(workingThisParam, callSubst)
+                    : workingThisParam;
+                const inferredFromReceiver = inferMethodTypeArgsFromArguments(methodTypeParams, [receiverParamForInference], [receiverType]);
+                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) {
@@ -1897,7 +1968,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 +2309,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" &&