@tsonic/frontend 0.0.12 → 0.0.13

package/dist/ir/type-converter/utility-types.js

@@ -0,0 +1,528 @@
+/**
+ * Utility type expansion - Partial, Required, Readonly, Pick, Omit
+ *
+ * These utility types are expanded at compile time by resolving the type
+ * through TypeScript's type checker and converting the result to IrObjectType.
+ */
+import * as ts from "typescript";
+/**
+ * Set of supported mapped utility types that can be expanded
+ */
+export const EXPANDABLE_UTILITY_TYPES = new Set([
+    "Partial",
+    "Required",
+    "Readonly",
+    "Pick",
+    "Omit",
+]);
+/**
+ * Check if a type name is an expandable utility type
+ */
+export const isExpandableUtilityType = (name) => EXPANDABLE_UTILITY_TYPES.has(name);
+/**
+ * Set of supported conditional utility types that can be expanded
+ * These delegate to TypeScript's type checker for evaluation.
+ */
+export const EXPANDABLE_CONDITIONAL_UTILITY_TYPES = new Set([
+    "NonNullable",
+    "Exclude",
+    "Extract",
+    "ReturnType",
+    "Parameters",
+    "Awaited",
+]);
+/**
+ * Check if a type name is an expandable conditional utility type
+ */
+export const isExpandableConditionalUtilityType = (name) => EXPANDABLE_CONDITIONAL_UTILITY_TYPES.has(name);
+/**
+ * Check if a type node explicitly contains undefined in a union.
+ * Used to detect explicit `x?: T | undefined` vs synthetic `x?: T`.
+ */
+const typeNodeContainsUndefined = (typeNode) => {
+    if (!typeNode)
+        return false;
+    if (ts.isUnionTypeNode(typeNode)) {
+        return typeNode.types.some((t) => t.kind === ts.SyntaxKind.UndefinedKeyword);
+    }
+    return typeNode.kind === ts.SyntaxKind.UndefinedKeyword;
+};
+/**
+ * Check if ANY declaration in the list explicitly contains undefined.
+ * Handles merged declarations where any declaration might have explicit undefined.
+ */
+const anyDeclarationHasExplicitUndefined = (declarations) => {
+    if (!declarations)
+        return false;
+    return declarations.some((decl) => {
+        if (ts.isPropertySignature(decl) || ts.isPropertyDeclaration(decl)) {
+            return typeNodeContainsUndefined(decl.type);
+        }
+        return false;
+    });
+};
+/**
+ * Check if a declaration has a readonly modifier.
+ */
+const declarationHasReadonlyModifier = (decl) => {
+    if (ts.isPropertySignature(decl) || ts.isPropertyDeclaration(decl)) {
+        return (decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ??
+            false);
+    }
+    return false;
+};
+/**
+ * Get readonly status from TypeScript internal checkFlags.
+ * WARNING: This uses TypeScript internal API (symbol.links.checkFlags).
+ * The value 8 is CheckFlags.Readonly in TypeScript's internal enum.
+ * This is necessary for mapped types where readonly is not in declaration modifiers.
+ * If TypeScript internals change, this will need updating.
+ */
+const isReadonlyFromCheckFlags = (symbol) => {
+    const CHECK_FLAGS_READONLY = 8; // TypeScript internal: CheckFlags.Readonly
+    const checkFlags = symbol.links
+        ?.checkFlags ?? 0;
+    return (checkFlags & CHECK_FLAGS_READONLY) !== 0;
+};
+/**
+ * Determine if a property is readonly.
+ * Combines declaration-based check (stable) with internal checkFlags (for mapped types).
+ * Prefers declaration-based when available for stability across TS versions.
+ */
+const isPropertyReadonly = (symbol, declarations) => {
+    // First try declaration-based (stable public API)
+    const fromDeclaration = declarations?.some(declarationHasReadonlyModifier) ?? false;
+    if (fromDeclaration)
+        return true;
+    // Fall back to internal checkFlags for mapped types (Readonly<T>, etc.)
+    // This handles cases where readonly is synthesized, not in declaration
+    return isReadonlyFromCheckFlags(symbol);
+};
+/**
+ * Check if a property name is a non-string key (symbol or computed).
+ * These cannot be represented as C# property names.
+ */
+const isNonStringKey = (symbol) => {
+    const propName = symbol.getName();
+    return (propName.startsWith("__@") || // Internal symbol marker
+        ((symbol.flags & ts.SymbolFlags.Transient) !== 0 &&
+            propName.startsWith("[")));
+};
+/**
+ * Strip `undefined` from a union type, but ONLY the synthetic undefined
+ * introduced by optionality. If the declaration explicitly included undefined
+ * (like `x?: T | undefined`), we preserve it to maintain type semantics.
+ *
+ * Compiler-grade rule per review:
+ * - Only strip the synthetic undefined introduced by optionality
+ * - Do NOT strip explicit undefined that was already in the declared type
+ * - If we can't reliably distinguish, don't strip (prefer correctness)
+ */
+const stripSyntheticUndefined = (type, checker, enclosingNode, flags, declarations) => {
+    // If ANY declaration explicitly contains undefined, don't strip anything
+    // This handles merged declarations where any might have explicit undefined
+    if (anyDeclarationHasExplicitUndefined(declarations)) {
+        return checker.typeToTypeNode(type, enclosingNode, flags);
+    }
+    // Check if it's a union type
+    if (type.isUnion()) {
+        // Filter out undefined from the union
+        const filteredTypes = type.types.filter((t) => !(t.flags & ts.TypeFlags.Undefined));
+        // If only one type remains, return that type's node
+        const firstType = filteredTypes[0];
+        if (filteredTypes.length === 1 && firstType) {
+            return checker.typeToTypeNode(firstType, enclosingNode, flags);
+        }
+        // If multiple types remain (excluding undefined), keep them as union
+        // This happens for things like `string | number | undefined` → `string | number`
+        if (filteredTypes.length > 1) {
+            // For complex unions, don't strip - let emitter handle it
+            // This is safer than potentially changing type semantics
+            return checker.typeToTypeNode(type, enclosingNode, flags);
+        }
+        // All types were undefined (shouldn't happen) - return undefined type
+        return checker.typeToTypeNode(type, enclosingNode, flags);
+    }
+    // Not a union - return as-is
+    return checker.typeToTypeNode(type, enclosingNode, flags);
+};
+/**
+ * Expand a mapped utility type to an IrObjectType.
+ *
+ * This function uses TypeScript's type checker to resolve the utility type
+ * and extracts the properties from the resolved type.
+ *
+ * @param node - The TypeReferenceNode for the utility type
+ * @param typeName - The name of the utility type (Partial, Required, etc.)
+ * @param checker - The TypeScript type checker
+ * @param convertType - Function to convert nested types
+ * @returns IrObjectType with the expanded properties, or null if expansion fails
+ */
+export const expandUtilityType = (node, typeName, checker, convertType) => {
+    // Get the resolved type from TypeScript's type checker
+    const resolvedType = checker.getTypeAtLocation(node);
+    // Check if the type has properties (object-like)
+    const properties = resolvedType.getProperties();
+    if (!properties || properties.length === 0) {
+        // Type parameter or empty type - can't expand
+        return null;
+    }
+    // Check if ANY type argument is a type parameter (generic)
+    // We can only expand when ALL type arguments are concrete.
+    // This is important for Pick<T, K> / Omit<T, K> where either T or K
+    // could be a type parameter.
+    const typeArgs = node.typeArguments;
+    if (typeArgs) {
+        for (const typeArg of typeArgs) {
+            const argType = checker.getTypeAtLocation(typeArg);
+            if (argType.flags & ts.TypeFlags.TypeParameter) {
+                // At least one type argument is a type parameter - can't expand
+                return null;
+            }
+        }
+    }
+    // SAFETY: Check for index signatures - expansion would lose them
+    // Never expand if doing so would drop members (compiler-grade rule)
+    const stringIndexType = checker.getIndexInfoOfType(resolvedType, ts.IndexKind.String);
+    const numberIndexType = checker.getIndexInfoOfType(resolvedType, ts.IndexKind.Number);
+    if (stringIndexType || numberIndexType) {
+        // Type has index signatures that cannot be represented in expansion
+        // Return null to fall back to referenceType behavior
+        return null;
+    }
+    // SAFETY: Check for non-string keys before processing
+    // Never expand if doing so would drop members (compiler-grade rule)
+    for (const prop of properties) {
+        if (isNonStringKey(prop)) {
+            // Type has symbol/computed keys that cannot be represented as C# properties
+            // Return null to fall back to referenceType behavior
+            return null;
+        }
+    }
+    // Convert properties to IR members
+    const members = [];
+    for (const prop of properties) {
+        const propType = checker.getTypeOfSymbolAtLocation(prop, node);
+        // Get declarations for readonly check and explicit undefined detection
+        const declarations = prop.getDeclarations();
+        // Get optional/readonly status
+        // TypeScript correctly sets Optional flag for Partial<T> properties
+        const symbolOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+        // Readonly: combine declaration-based (stable) with internal checkFlags (mapped types)
+        const baseReadonly = isPropertyReadonly(prop, declarations);
+        // Apply utility type transformations
+        // Readonly<T> makes all properties readonly
+        // Required<T> makes all properties required (non-optional)
+        // Partial<T> - TypeScript already sets Optional flag, we just use it
+        const isReadonly = typeName === "Readonly" ? true : baseReadonly;
+        const isOptional = typeName === "Required" ? false : symbolOptional;
+        // For optional properties, TypeScript includes `| undefined` in the type.
+        // We strip ONLY synthetic undefined (from optionality), not explicit undefined.
+        // Pass all declarations so we check ALL for explicit undefined (handles merges).
+        // Use NoTruncation to get complete type representation.
+        const typeNodeFlags = ts.NodeBuilderFlags.NoTruncation;
+        const propTypeNode = isOptional
+            ? stripSyntheticUndefined(propType, checker, node, typeNodeFlags, declarations)
+            : checker.typeToTypeNode(propType, node, typeNodeFlags);
+        // Check if it's a method or property
+        const isMethod = declarations?.some((decl) => ts.isMethodSignature(decl) || ts.isMethodDeclaration(decl)) ?? false;
+        if (isMethod && propTypeNode && ts.isFunctionTypeNode(propTypeNode)) {
+            // Method signature
+            const methSig = {
+                kind: "methodSignature",
+                name: prop.name,
+                parameters: propTypeNode.parameters.map((param, index) => ({
+                    kind: "parameter",
+                    pattern: {
+                        kind: "identifierPattern",
+                        // Use identifier text if available, otherwise fallback to arg{index}
+                        // typeToTypeNode may create synthetic nodes without source file context
+                        name: ts.isIdentifier(param.name) ? param.name.text : `arg${index}`,
+                    },
+                    type: param.type ? convertType(param.type, checker) : undefined,
+                    isOptional: !!param.questionToken,
+                    isRest: !!param.dotDotDotToken,
+                    passing: "value",
+                })),
+                returnType: propTypeNode.type
+                    ? convertType(propTypeNode.type, checker)
+                    : undefined,
+            };
+            members.push(methSig);
+        }
+        else {
+            // Property signature
+            const propSig = {
+                kind: "propertySignature",
+                name: prop.name,
+                type: propTypeNode
+                    ? convertType(propTypeNode, checker)
+                    : { kind: "anyType" },
+                isOptional,
+                isReadonly,
+            };
+            members.push(propSig);
+        }
+    }
+    return { kind: "objectType", members };
+};
+/**
+ * Check if a type contains any type parameters (is generic).
+ * Returns true if the type or any nested type is a type parameter.
+ */
+const containsTypeParameter = (type, checker) => {
+    // Direct type parameter check
+    if (type.flags & ts.TypeFlags.TypeParameter) {
+        return true;
+    }
+    // Check union types recursively
+    if (type.isUnion()) {
+        return type.types.some((t) => containsTypeParameter(t, checker));
+    }
+    // Check intersection types recursively
+    if (type.isIntersection()) {
+        return type.types.some((t) => containsTypeParameter(t, checker));
+    }
+    return false;
+};
+/**
+ * Expand a conditional utility type (NonNullable, Exclude, Extract) to IR.
+ *
+ * This function delegates to TypeScript's type checker to evaluate the
+ * conditional type, then converts the resolved result to IR.
+ *
+ * CONCRETE-ONLY EXPANSION RULE:
+ * This function ONLY expands utility types when ALL type arguments are concrete
+ * (non-generic). If any type argument contains a type parameter, we return null
+ * and let the caller fall through to referenceType. This is intentional because:
+ *
+ * 1. TypeScript's conditional types are distributive over unions, which requires
+ *    knowing the actual types at compile time.
+ * 2. For generic contexts like `function f<T>(x: NonNullable<T>)`, we cannot
+ *    evaluate the conditional - it must remain as a type reference.
+ * 3. This matches TypeScript semantics: deferred evaluation in generic contexts.
+ *
+ * Gating conditions:
+ * - Returns null if any type argument contains type parameters (generic context)
+ * - Returns null if TypeScript cannot resolve the type
+ *
+ * Special handling:
+ * - NonNullable<any> → anyType (preserve)
+ * - NonNullable<unknown> → unknownType (preserve)
+ * - NonNullable<never> → neverType (preserve)
+ * - Result is never → neverType
+ *
+ * @param node - The TypeReferenceNode for the utility type
+ * @param typeName - The name of the utility type (NonNullable, Exclude, Extract)
+ * @param checker - The TypeScript type checker
+ * @param convertType - Function to convert nested types
+ * @returns IR type with the expanded result, or null if expansion fails
+ */
+export const expandConditionalUtilityType = (node, typeName, checker, convertType) => {
+    const typeArgs = node.typeArguments;
+    if (!typeArgs || typeArgs.length === 0) {
+        return null;
+    }
+    // Check if ANY type argument contains type parameters (generic)
+    // We can only expand when ALL type arguments are concrete.
+    for (const typeArg of typeArgs) {
+        const argType = checker.getTypeAtLocation(typeArg);
+        if (containsTypeParameter(argType, checker)) {
+            return null;
+        }
+    }
+    // Special handling for NonNullable with any/unknown/never
+    // These should be preserved rather than transformed
+    if (typeName === "NonNullable" && typeArgs.length >= 1) {
+        const firstArg = typeArgs[0];
+        if (firstArg) {
+            const argType = checker.getTypeAtLocation(firstArg);
+            if (argType.flags & ts.TypeFlags.Any) {
+                return { kind: "anyType" };
+            }
+            if (argType.flags & ts.TypeFlags.Unknown) {
+                return { kind: "unknownType" };
+            }
+            if (argType.flags & ts.TypeFlags.Never) {
+                return { kind: "neverType" };
+            }
+        }
+    }
+    // Get the resolved type from TypeScript's type checker
+    const resolvedType = checker.getTypeAtLocation(node);
+    // Check for never result (e.g., Exclude<string, string> → never)
+    if (resolvedType.flags & ts.TypeFlags.Never) {
+        return { kind: "neverType" };
+    }
+    // Directly convert the resolved type to IR without using typeToTypeNode
+    // This avoids TypeScript substituting back the original type alias name
+    const irType = convertTypeDirectly(resolvedType, checker, convertType);
+    if (irType) {
+        return irType;
+    }
+    // Fallback: use typeToTypeNode for complex types
+    const typeNodeFlags = ts.NodeBuilderFlags.NoTruncation;
+    const resolvedTypeNode = checker.typeToTypeNode(resolvedType, node, typeNodeFlags);
+    if (!resolvedTypeNode) {
+        return null;
+    }
+    return convertType(resolvedTypeNode, checker);
+};
+/**
+ * Directly convert a ts.Type to IrType without going through typeToTypeNode.
+ * This handles the common cases (primitives, literals, unions) to avoid
+ * TypeScript substituting back type alias names.
+ */
+const convertTypeDirectly = (type, checker, convertType) => {
+    // Primitive types
+    if (type.flags & ts.TypeFlags.String) {
+        return { kind: "primitiveType", name: "string" };
+    }
+    if (type.flags & ts.TypeFlags.Number) {
+        return { kind: "primitiveType", name: "number" };
+    }
+    if (type.flags & ts.TypeFlags.Boolean) {
+        return { kind: "primitiveType", name: "boolean" };
+    }
+    if (type.flags & ts.TypeFlags.Null) {
+        return { kind: "primitiveType", name: "null" };
+    }
+    if (type.flags & ts.TypeFlags.Undefined) {
+        return { kind: "primitiveType", name: "undefined" };
+    }
+    // String literal
+    if (type.flags & ts.TypeFlags.StringLiteral) {
+        const literal = type;
+        return { kind: "literalType", value: literal.value };
+    }
+    // Number literal
+    if (type.flags & ts.TypeFlags.NumberLiteral) {
+        const literal = type;
+        return { kind: "literalType", value: literal.value };
+    }
+    // Boolean literal (true/false)
+    if (type.flags & ts.TypeFlags.BooleanLiteral) {
+        // TypeScript represents true/false via symbol name
+        const symbol = type.getSymbol();
+        const isTrue = symbol?.getName() === "true";
+        return { kind: "literalType", value: isTrue };
+    }
+    // Union type - recursively convert constituents
+    if (type.isUnion()) {
+        const irTypes = [];
+        for (const constituent of type.types) {
+            const irType = convertTypeDirectly(constituent, checker, convertType);
+            if (!irType) {
+                // Can't convert this constituent directly, fall back
+                return null;
+            }
+            irTypes.push(irType);
+        }
+        return { kind: "unionType", types: irTypes };
+    }
+    // Can't handle directly - return null to use fallback
+    return null;
+};
+/**
+ * Extract literal values from a type.
+ * Returns an array of string literals (numbers are converted to strings).
+ * Returns null if the type contains non-literal constituents or type parameters.
+ */
+const extractLiteralKeys = (type, checker) => {
+    // Check for type parameter
+    if (containsTypeParameter(type, checker)) {
+        return null;
+    }
+    // Check for string type (not literal)
+    if (type.flags & ts.TypeFlags.String) {
+        return null;
+    }
+    // Check for number type (not literal)
+    if (type.flags & ts.TypeFlags.Number) {
+        return null;
+    }
+    // String literal
+    if (type.flags & ts.TypeFlags.StringLiteral) {
+        const literal = type;
+        return [literal.value];
+    }
+    // Number literal
+    if (type.flags & ts.TypeFlags.NumberLiteral) {
+        const literal = type;
+        return [String(literal.value)];
+    }
+    // Union type - collect all literals
+    if (type.isUnion()) {
+        const keys = [];
+        for (const t of type.types) {
+            const subKeys = extractLiteralKeys(t, checker);
+            if (subKeys === null) {
+                return null;
+            }
+            keys.push(...subKeys);
+        }
+        return keys;
+    }
+    // Other types (boolean, object, etc.) - not supported as Record keys
+    return null;
+};
+/**
+ * Expand Record<K, T> to IrObjectType when K is a finite set of literal keys.
+ *
+ * Gating conditions:
+ * - Returns null if K contains type parameters (generic context)
+ * - Returns null if K is string or number (should remain IrDictionaryType)
+ * - Returns null if K contains non-literal types
+ *
+ * Examples:
+ * - Record<"a" | "b", number> → IrObjectType with props {a: number, b: number}
+ * - Record<1 | 2, string> → IrObjectType with props {"1": string, "2": string}
+ * - Record<string, number> → null (use IrDictionaryType)
+ * - Record<K, T> → null (type parameter)
+ *
+ * @param node - The TypeReferenceNode for Record<K, T>
+ * @param checker - The TypeScript type checker
+ * @param convertType - Function to convert nested types
+ * @returns IrObjectType with the expanded properties, or null if should use dictionary
+ */
+export const expandRecordType = (node, checker, convertType) => {
+    const typeArgs = node.typeArguments;
+    if (!typeArgs || typeArgs.length !== 2) {
+        return null;
+    }
+    const keyTypeNode = typeArgs[0];
+    const valueTypeNode = typeArgs[1];
+    if (!keyTypeNode || !valueTypeNode) {
+        return null;
+    }
+    // Get the key type
+    const keyType = checker.getTypeAtLocation(keyTypeNode);
+    // Check for type parameters in key
+    if (containsTypeParameter(keyType, checker)) {
+        return null;
+    }
+    // Check for type parameters in value
+    const valueType = checker.getTypeAtLocation(valueTypeNode);
+    if (containsTypeParameter(valueType, checker)) {
+        return null;
+    }
+    // Try to extract finite literal keys
+    const literalKeys = extractLiteralKeys(keyType, checker);
+    if (literalKeys === null || literalKeys.length === 0) {
+        // Not a finite set of literals - use IrDictionaryType
+        return null;
+    }
+    // Convert the value type
+    const irValueType = convertType(valueTypeNode, checker);
+    // Build IrObjectType with a property for each key
+    // Prefix numeric keys with '_' to make them valid C# identifiers
+    const members = literalKeys.map((key) => ({
+        kind: "propertySignature",
+        name: /^\d/.test(key) ? `_${key}` : key,
+        type: irValueType,
+        isOptional: false,
+        isReadonly: false,
+    }));
+    return { kind: "objectType", members };
+};
+//# sourceMappingURL=utility-types.js.map

package/dist/ir/type-converter/utility-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-types.js","sourceRoot":"","sources":["../../../src/ir/type-converter/utility-types.ts"],"names":[],"mappings":"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"}

package/dist/ir/type-converter/utility-types.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for utility type expansion
+ *
+ * Covers the safety guarantees per Alice's review:
+ * 1. Index signatures block expansion (never drop members)
+ * 2. Symbol/computed keys block expansion (never drop members)
+ * 3. Explicit undefined is preserved (not stripped)
+ */
+export {};
+//# sourceMappingURL=utility-types.test.d.ts.map

package/dist/ir/type-converter/utility-types.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-types.test.d.ts","sourceRoot":"","sources":["../../../src/ir/type-converter/utility-types.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}