@tsonic/frontend 0.0.15 → 0.0.16

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

@@ -63,7 +63,7 @@ export const poisonedCall = (arity, diagnostics) => ({
  * the returned TypeSystem instance.
  */
 export const createTypeSystem = (config) => {
-    const { handleRegistry, typeRegistry, nominalEnv, convertTypeNode, unifiedCatalog, aliasTable, resolveIdentifier, resolveCallSignature, resolveConstructorSignature, } = config;
+    const { handleRegistry, typeRegistry, nominalEnv, convertTypeNode: convertTypeNodeRaw, unifiedCatalog, aliasTable, resolveIdentifier, resolveCallSignature, resolveConstructorSignature, } = config;
     // ─────────────────────────────────────────────────────────────────────────
     // INTERNAL CACHES — Step 4 Implementation
     // ─────────────────────────────────────────────────────────────────────────
@@ -236,6 +236,92 @@ export const createTypeSystem = (config) => {
             unifiedCatalog.resolveTsName(name) ??
             unifiedCatalog.resolveClrName(name));
     };
+    /**
+     * Attach canonical TypeIds to IR types where possible.
+     *
+     * This keeps nominal identity stable throughout the pipeline and enables
+     * emit-time resolution without relying on string name matching.
+     */
+    const attachParameterTypeIds = (p) => ({
+        ...p,
+        type: p.type ? attachTypeIds(p.type) : undefined,
+    });
+    const attachTypeParameterTypeIds = (tp) => ({
+        ...tp,
+        constraint: tp.constraint ? attachTypeIds(tp.constraint) : undefined,
+        default: tp.default ? attachTypeIds(tp.default) : undefined,
+        structuralMembers: tp.structuralMembers?.map(attachInterfaceMemberTypeIds),
+    });
+    const attachInterfaceMemberTypeIds = (m) => {
+        if (m.kind === "propertySignature") {
+            return { ...m, type: attachTypeIds(m.type) };
+        }
+        return {
+            ...m,
+            typeParameters: m.typeParameters?.map(attachTypeParameterTypeIds),
+            parameters: m.parameters.map(attachParameterTypeIds),
+            returnType: m.returnType ? attachTypeIds(m.returnType) : undefined,
+        };
+    };
+    const attachTypeIds = (type) => {
+        switch (type.kind) {
+            case "referenceType": {
+                const typeId = type.typeId ??
+                    resolveTypeIdByName(type.resolvedClrType ?? type.name);
+                return {
+                    ...type,
+                    ...(type.typeArguments
+                        ? { typeArguments: type.typeArguments.map(attachTypeIds) }
+                        : {}),
+                    ...(type.structuralMembers
+                        ? {
+                            structuralMembers: type.structuralMembers.map(attachInterfaceMemberTypeIds),
+                        }
+                        : {}),
+                    ...(typeId ? { typeId } : {}),
+                };
+            }
+            case "arrayType":
+                return { ...type, elementType: attachTypeIds(type.elementType) };
+            case "tupleType":
+                return {
+                    ...type,
+                    elementTypes: type.elementTypes.map(attachTypeIds),
+                };
+            case "functionType":
+                return {
+                    ...type,
+                    parameters: type.parameters.map(attachParameterTypeIds),
+                    returnType: attachTypeIds(type.returnType),
+                };
+            case "objectType":
+                return {
+                    ...type,
+                    members: type.members.map(attachInterfaceMemberTypeIds),
+                };
+            case "dictionaryType":
+                return {
+                    ...type,
+                    keyType: attachTypeIds(type.keyType),
+                    valueType: attachTypeIds(type.valueType),
+                };
+            case "unionType":
+            case "intersectionType":
+                return { ...type, types: type.types.map(attachTypeIds) };
+            default:
+                return type;
+        }
+    };
+    /**
+     * Deterministic type syntax conversion with canonical TypeId attachment.
+     *
+     * The underlying converter is syntax-only; this wrapper re-attaches the
+     * nominal identity from the UnifiedUniverse so downstream passes (including
+     * the emitter) can resolve CLR types without re-driving a parallel lookup.
+     */
+    const convertTypeNode = (node) => {
+        return attachTypeIds(convertTypeNodeRaw(node));
+    };
     /**
      * Normalize a receiver type to nominal form for member lookup.
      *
@@ -245,9 +331,10 @@ export const createTypeSystem = (config) => {
      */
     const normalizeToNominal = (type) => {
         if (type.kind === "referenceType") {
-            const typeId = (type.resolvedClrType
-                ? resolveTypeIdByName(type.resolvedClrType)
-                : undefined) ?? resolveTypeIdByName(type.name);
+            const typeId = type.typeId ??
+                (type.resolvedClrType
+                    ? resolveTypeIdByName(type.resolvedClrType)
+                    : undefined) ?? resolveTypeIdByName(type.name);
             if (!typeId)
                 return undefined;
             return { typeId, typeArgs: type.typeArguments ?? [] };
@@ -443,17 +530,53 @@ export const createTypeSystem = (config) => {
         }
         return undefined;
     };
+    const stripNullishForInference = (type) => {
+        if (isNullishPrimitive(type))
+            return undefined;
+        if (type.kind !== "unionType")
+            return type;
+        const filtered = type.types.filter((t) => !isNullishPrimitive(t));
+        if (filtered.length === 0)
+            return undefined;
+        if (filtered.length === 1 && filtered[0])
+            return filtered[0];
+        return { kind: "unionType", types: filtered };
+    };
+    const unwrapAwaitedForInference = (type) => {
+        if (type.kind === "referenceType" &&
+            (type.name === "Promise" || type.name === "PromiseLike")) {
+            const inner = type.typeArguments?.[0];
+            if (inner)
+                return unwrapAwaitedForInference(inner);
+        }
+        return type;
+    };
     /**
      * 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)) {
+            return convertTypeNode(unwrapped.type);
+        }
+        if (ts.isNonNullExpression(unwrapped)) {
+            const inner = inferExpressionType(unwrapped.expression, env);
+            if (!inner || inner.kind === "unknownType")
+                return undefined;
+            return stripNullishForInference(inner);
+        }
+        if (ts.isAwaitExpression(unwrapped)) {
+            const inner = inferExpressionType(unwrapped.expression, env);
+            if (!inner || inner.kind === "unknownType")
+                return undefined;
+            return unwrapAwaitedForInference(inner);
+        }
         if (ts.isCallExpression(unwrapped)) {
             return tryInferReturnTypeFromCallExpression(unwrapped, env);
         }
@@ -532,6 +655,10 @@ export const createTypeSystem = (config) => {
         if (ts.isStringLiteral(unwrapped)) {
             return { kind: "primitiveType", name: "string" };
         }
+        if (ts.isNoSubstitutionTemplateLiteral(unwrapped) ||
+            ts.isTemplateExpression(unwrapped)) {
+            return { kind: "primitiveType", name: "string" };
+        }
         if (unwrapped.kind === ts.SyntaxKind.TrueKeyword ||
             unwrapped.kind === ts.SyntaxKind.FalseKeyword) {
             return { kind: "primitiveType", name: "boolean" };
@@ -717,13 +844,8 @@ export const createTypeSystem = (config) => {
             if (!ts.isPropertyAccessExpression(call.expression))
                 return undefined;
             const receiverExpr = call.expression.expression;
-            if (!ts.isIdentifier(receiverExpr))
-                return undefined;
-            const receiverDeclId = resolveIdentifier(receiverExpr);
-            if (!receiverDeclId)
-                return undefined;
-            const receiver = typeOfDecl(receiverDeclId);
-            return receiver.kind === "unknownType" ? undefined : receiver;
+            const receiver = inferExpressionType(receiverExpr, env);
+            return receiver && receiver.kind !== "unknownType" ? receiver : undefined;
         })();
         const argumentCount = call.arguments.length;
         // Two-pass: resolve once to get expected parameter types, then infer non-lambda args,
@@ -845,9 +967,12 @@ export const createTypeSystem = (config) => {
         const node = declNode;
         if (!ts.isVariableDeclaration(node))
             return undefined;
-        const init = node.initializer;
+        let init = node.initializer;
         if (!init)
             return undefined;
+        while (ts.isParenthesizedExpression(init)) {
+            init = init.expression;
+        }
         // Explicit type assertions are deterministic sources for variable typing.
         // This supports patterns like:
         //   const xs = numbers as unknown as LinqSeq<int>;
@@ -855,6 +980,18 @@ export const createTypeSystem = (config) => {
         if (ts.isAsExpression(init) || ts.isTypeAssertionExpression(init)) {
             return convertTypeNode(init.type);
         }
+        if (ts.isNonNullExpression(init)) {
+            const inner = inferExpressionType(init.expression, new Map());
+            if (!inner || inner.kind === "unknownType")
+                return undefined;
+            return stripNullishForInference(inner);
+        }
+        if (ts.isAwaitExpression(init)) {
+            const inner = inferExpressionType(init.expression, new Map());
+            if (!inner || inner.kind === "unknownType")
+                return undefined;
+            return unwrapAwaitedForInference(inner);
+        }
         if (ts.isCallExpression(init)) {
             return tryInferReturnTypeFromCallExpression(init, new Map());
         }
@@ -953,22 +1090,16 @@ export const createTypeSystem = (config) => {
             return sourceType.kind === "unknownType" ? undefined : sourceType;
         }
         // Property access: const output = response.outputStream
-        // DETERMINISTIC: Infer via TypeSystem member lookup on a typed receiver identifier.
+        // DETERMINISTIC: Infer via TypeSystem member lookup on a deterministically typed receiver.
         if (ts.isPropertyAccessExpression(init)) {
-            const receiver = init.expression;
-            if (ts.isIdentifier(receiver)) {
-                const receiverDeclId = resolveIdentifier(receiver);
-                if (!receiverDeclId)
-                    return undefined;
-                const receiverType = typeOfDecl(receiverDeclId);
-                if (receiverType.kind === "unknownType")
-                    return undefined;
-                const memberType = typeOfMember(receiverType, {
-                    kind: "byName",
-                    name: init.name.text,
-                });
-                return memberType.kind === "unknownType" ? undefined : memberType;
-            }
+            const receiverType = inferExpressionType(init.expression, new Map());
+            if (!receiverType || receiverType.kind === "unknownType")
+                return undefined;
+            const memberType = typeOfMember(receiverType, {
+                kind: "byName",
+                name: init.name.text,
+            });
+            return memberType.kind === "unknownType" ? undefined : memberType;
         }
         return undefined;
     };
@@ -1623,13 +1754,41 @@ export const createTypeSystem = (config) => {
                 workingReturn = unknownType;
             }
         }
-        return {
+        const resolved = {
             parameterTypes: workingParams,
             parameterModes: rawSig.parameterModes,
             returnType: workingReturn,
             typePredicate: workingPredicate,
             diagnostics: [],
         };
+        // CLR overload correction (airplane-grade determinism):
+        //
+        // TypeScript cannot always select the correct overload for CLR APIs because some
+        // Tsonic surface types intentionally erase to TS primitives (e.g., `char` is `string`
+        // in @tsonic/core for TSC compatibility). This can cause TS to resolve calls like
+        // Console.writeLine("Hello") to a `char` overload, which is semantically invalid.
+        //
+        // When we have full argument types, and the call targets an assembly-origin type,
+        // prefer the best matching overload from the UnifiedTypeCatalog if it scores higher
+        // than the TS-selected signature.
+        if (!resolved.typePredicate &&
+            argTypes &&
+            rawSig.declaringTypeTsName &&
+            rawSig.declaringMemberName) {
+            const hasAllArgTypes = argTypes.length >= argumentCount &&
+                Array.from({ length: argumentCount }, (_, i) => argTypes[i]).every((t) => t !== undefined);
+            if (hasAllArgTypes) {
+                const catalogResolved = tryResolveCallFromUnifiedCatalog(rawSig.declaringTypeTsName, rawSig.declaringMemberName, query);
+                if (catalogResolved) {
+                    const currentScore = scoreSignatureMatch(resolved.parameterTypes, argTypes, argumentCount);
+                    const catalogScore = scoreSignatureMatch(catalogResolved.parameterTypes, argTypes, argumentCount);
+                    if (catalogScore > currentScore) {
+                        return catalogResolved;
+                    }
+                }
+            }
+        }
+        return resolved;
     };
     // ─────────────────────────────────────────────────────────────────────────
     // expandUtility — Utility type expansion (Step 8)