@tsonic/frontend 0.0.73 → 0.0.75

package/dist/ir/converters/expressions/ambient-global-source-owner.js

@@ -0,0 +1,252 @@
+import * as ts from "typescript";
+import { getClassNameFromPath } from "../../../resolver/naming.js";
+import { resolveImport } from "../../../resolver.js";
+import { resolveSourceFileNamespace } from "../../../program/source-file-identity.js";
+import { readSourcePackageMetadata } from "../../../program/source-package-metadata.js";
+const normalizeFilePath = (filePath) => filePath.replace(/\\/g, "/");
+const getAmbientDeclarationName = (declaration) => {
+    if ((ts.isFunctionDeclaration(declaration) ||
+        ts.isVariableDeclaration(declaration) ||
+        ts.isClassDeclaration(declaration) ||
+        ts.isInterfaceDeclaration(declaration) ||
+        ts.isEnumDeclaration(declaration)) &&
+        declaration.name &&
+        ts.isIdentifier(declaration.name)) {
+        return declaration.name.text;
+    }
+    return undefined;
+};
+const getDeclarationTypeNode = (declaration) => {
+    if (ts.isVariableDeclaration(declaration)) {
+        return declaration.type;
+    }
+    if (ts.isPropertySignature(declaration) ||
+        ts.isPropertyDeclaration(declaration)) {
+        return declaration.type;
+    }
+    return undefined;
+};
+const readEntityNameText = (name) => {
+    if (ts.isIdentifier(name)) {
+        return name.text;
+    }
+    if (ts.isQualifiedName(name)) {
+        return `${readEntityNameText(name.left)}.${name.right.text}`;
+    }
+    if (ts.isPropertyAccessExpression(name)) {
+        return `${readEntityNameText(name.expression)}.${name.name.text}`;
+    }
+    return ts.isStringLiteral(name) ? name.text : name.getText();
+};
+const extractImportTypeTarget = (declaration) => {
+    const typeNode = getDeclarationTypeNode(declaration);
+    if (!typeNode) {
+        return undefined;
+    }
+    if (ts.isImportTypeNode(typeNode) && typeNode.isTypeOf) {
+        const literal = ts.isLiteralTypeNode(typeNode.argument) &&
+            ts.isStringLiteral(typeNode.argument.literal)
+            ? typeNode.argument.literal
+            : undefined;
+        if (!literal) {
+            return undefined;
+        }
+        const exportName = typeNode.qualifier
+            ? readEntityNameText(typeNode.qualifier).trim()
+            : undefined;
+        if (!exportName) {
+            return undefined;
+        }
+        return {
+            specifier: literal.text,
+            exportName,
+        };
+    }
+    if (!ts.isTypeQueryNode(typeNode)) {
+        return undefined;
+    }
+    const exprName = typeNode.exprName;
+    const rootIdentifier = ts.isIdentifier(exprName)
+        ? exprName
+        : ts.isQualifiedName(exprName)
+            ? exprName.left
+            : undefined;
+    if (!rootIdentifier || !ts.isIdentifier(rootIdentifier)) {
+        return undefined;
+    }
+    const sourceFile = declaration.getSourceFile();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !statement.importClause ||
+            !statement.moduleSpecifier ||
+            !ts.isStringLiteral(statement.moduleSpecifier)) {
+            continue;
+        }
+        const namedBindings = statement.importClause.namedBindings;
+        if (namedBindings && ts.isNamedImports(namedBindings)) {
+            for (const element of namedBindings.elements) {
+                if (element.name.text !== rootIdentifier.text) {
+                    continue;
+                }
+                return {
+                    specifier: statement.moduleSpecifier.text,
+                    exportName: element.propertyName?.text ?? element.name.text,
+                };
+            }
+        }
+    }
+    return undefined;
+};
+const resolveTopLevelLocalOwner = (sourceFile, localName, ctx) => {
+    const namespace = resolveSourceFileNamespace(sourceFile.fileName, ctx.sourceRoot, ctx.rootNamespace);
+    const fileClass = getClassNameFromPath(sourceFile.fileName);
+    for (const statement of sourceFile.statements) {
+        if ((ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) &&
+            statement.name?.text === localName) {
+            return `${namespace}.${localName}`;
+        }
+        if (ts.isFunctionDeclaration(statement) &&
+            statement.name?.text === localName) {
+            return `${namespace}.${fileClass}.${localName}`;
+        }
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) &&
+                    declaration.name.text === localName) {
+                    return `${namespace}.${fileClass}.${localName}`;
+                }
+            }
+        }
+    }
+    return undefined;
+};
+const resolveExportOwnerFromSourceFile = (sourceFile, exportName, ctx, visited) => {
+    const visitKey = `${normalizeFilePath(sourceFile.fileName)}::${exportName}`;
+    if (visited.has(visitKey)) {
+        return undefined;
+    }
+    visited.add(visitKey);
+    for (const statement of sourceFile.statements) {
+        if ((ts.isClassDeclaration(statement) ||
+            ts.isEnumDeclaration(statement) ||
+            ts.isFunctionDeclaration(statement)) &&
+            statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) &&
+            statement.name?.text === exportName) {
+            return resolveTopLevelLocalOwner(sourceFile, exportName, ctx);
+        }
+        if (ts.isVariableStatement(statement) &&
+            statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) &&
+                    declaration.name.text === exportName) {
+                    return resolveTopLevelLocalOwner(sourceFile, exportName, ctx);
+                }
+            }
+        }
+        if (!ts.isExportDeclaration(statement) || !statement.exportClause) {
+            continue;
+        }
+        if (!ts.isNamedExports(statement.exportClause)) {
+            continue;
+        }
+        for (const element of statement.exportClause.elements) {
+            if (element.name.text !== exportName) {
+                continue;
+            }
+            const targetName = element.propertyName?.text ?? element.name.text;
+            if (!statement.moduleSpecifier ||
+                !ts.isStringLiteral(statement.moduleSpecifier)) {
+                return resolveTopLevelLocalOwner(sourceFile, targetName, ctx);
+            }
+            const redirected = resolveImport(statement.moduleSpecifier.text, sourceFile.fileName, ctx.sourceRoot, {
+                clrResolver: ctx.clrResolver,
+                bindings: ctx.bindings,
+                projectRoot: ctx.projectRoot,
+                surface: ctx.surface,
+                authoritativeTsonicPackageRoots: ctx.authoritativeTsonicPackageRoots,
+                declarationModuleAliases: ctx.declarationModuleAliases,
+            });
+            if (!redirected.ok || !redirected.value.resolvedPath) {
+                return undefined;
+            }
+            const redirectedSourceFile = ctx.sourceFilesByPath.get(normalizeFilePath(redirected.value.resolvedPath));
+            if (!redirectedSourceFile || redirectedSourceFile.isDeclarationFile) {
+                return undefined;
+            }
+            return resolveExportOwnerFromSourceFile(redirectedSourceFile, targetName, ctx, visited);
+        }
+    }
+    return undefined;
+};
+const resolveAmbientExportOwnerByName = (declaration, exportName, ctx) => {
+    const declarationFilePath = normalizeFilePath(declaration.getSourceFile().fileName);
+    const packageMetadata = [...ctx.authoritativeTsonicPackageRoots.values()]
+        .map((packageRoot) => readSourcePackageMetadata(packageRoot))
+        .find((metadata) => metadata !== null &&
+        metadata.ambientPaths.some((ambientPath) => normalizeFilePath(ambientPath) === declarationFilePath));
+    if (!packageMetadata) {
+        return undefined;
+    }
+    const owners = new Set();
+    for (const exportPath of packageMetadata.exportPaths) {
+        const sourceFile = ctx.sourceFilesByPath.get(normalizeFilePath(exportPath));
+        if (!sourceFile || sourceFile.isDeclarationFile) {
+            continue;
+        }
+        const owner = resolveExportOwnerFromSourceFile(sourceFile, exportName, ctx, new Set());
+        if (owner) {
+            owners.add(owner);
+        }
+    }
+    if (owners.size !== 1) {
+        return undefined;
+    }
+    return [...owners][0];
+};
+export const resolveAmbientGlobalSourceOwner = (declarations, ctx) => {
+    for (const declaration of declarations) {
+        const target = extractImportTypeTarget(declaration);
+        if (!target) {
+            continue;
+        }
+        const resolved = resolveImport(target.specifier, declaration.getSourceFile().fileName, ctx.sourceRoot, {
+            clrResolver: ctx.clrResolver,
+            bindings: ctx.bindings,
+            projectRoot: ctx.projectRoot,
+            surface: ctx.surface,
+            authoritativeTsonicPackageRoots: ctx.authoritativeTsonicPackageRoots,
+            declarationModuleAliases: ctx.declarationModuleAliases,
+        });
+        if (!resolved.ok || !resolved.value.resolvedPath) {
+            continue;
+        }
+        const targetSourceFile = ctx.sourceFilesByPath.get(normalizeFilePath(resolved.value.resolvedPath));
+        if (!targetSourceFile || targetSourceFile.isDeclarationFile) {
+            continue;
+        }
+        const owner = resolveExportOwnerFromSourceFile(targetSourceFile, target.exportName, ctx, new Set());
+        if (owner) {
+            return owner;
+        }
+    }
+    for (const declaration of declarations) {
+        const declarationName = getAmbientDeclarationName(declaration);
+        if (!declarationName) {
+            continue;
+        }
+        const owner = resolveAmbientExportOwnerByName(declaration, declarationName, ctx);
+        if (owner) {
+            return owner;
+        }
+    }
+    return undefined;
+};
+export const resolveAmbientGlobalSourceOwnerByName = (name, location, ctx, meaning = ts.SymbolFlags.Value) => {
+    const symbols = ctx.checker.getSymbolsInScope(location, meaning);
+    const symbol = symbols.find((candidate) => candidate.name === name);
+    if (!symbol) {
+        return undefined;
+    }
+    return resolveAmbientGlobalSourceOwner(symbol.getDeclarations() ?? [], ctx);
+};
+//# sourceMappingURL=ambient-global-source-owner.js.map

package/dist/ir/converters/expressions/ambient-global-source-owner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-global-source-owner.js","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/ambient-global-source-owner.ts"],"names":[],"mappings":"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"}

package/dist/ir/converters/expressions/array-literals.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Array literal expression converters
+ */
+import * as ts from "typescript";
+import { IrArrayExpression, IrType } from "../../types.js";
+import type { ProgramContext } from "../../program-context.js";
+export declare const isNullishPrimitive: (type: IrType) => boolean;
+export declare const normalizeExpectedArrayType: (expectedType: IrType | undefined, ctx: ProgramContext) => Extract<IrType, {
+    kind: "arrayType";
+}> | undefined;
+/**
+ * Convert array literal expression
+ *
+ * DETERMINISTIC TYPING:
+ * - If expectedType is provided (from LHS annotation), use it
+ * - Otherwise, derive from element types using literal form analysis
+ * - Default to number[] (double[]) for ergonomics when type cannot be determined
+ *
+ * @param node - The TypeScript array literal expression
+ * @param ctx - ProgramContext for type system and binding access
+ * @param expectedType - Expected type from context (e.g., `const a: number[] = [1,2,3]`).
+ *                       Pass `undefined` explicitly when no contextual type exists.
+ */
+export declare const convertArrayLiteral: (node: ts.ArrayLiteralExpression, ctx: ProgramContext, expectedType: IrType | undefined) => IrArrayExpression;
+//# sourceMappingURL=array-literals.d.ts.map

package/dist/ir/converters/expressions/array-literals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-literals.d.ts","sourceRoot":"","sources":["../../../../src/ir/converters/expressions/array-literals.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAgB,MAAM,gBAAgB,CAAC;AAYzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,OAEG,CAAC;AAmNtD,eAAO,MAAM,0BAA0B,GACrC,cAAc,MAAM,GAAG,SAAS,EAChC,KAAK,cAAc,KAClB,OAAO,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,GAAG,SA0H3C,CAAC;AA0BF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,GAC9B,MAAM,EAAE,CAAC,sBAAsB,EAC/B,KAAK,cAAc,EACnB,cAAc,MAAM,GAAG,SAAS,KAC/B,iBA8DF,CAAC"}

package/dist/ir/converters/expressions/array-literals.js

@@ -0,0 +1,356 @@
+/**
+ * Array literal expression converters
+ */
+import * as ts from "typescript";
+import { containsTypeParameter, typesEqual, } from "../../types/ir-substitution.js";
+import { referenceTypeIdentity, stableIrTypeKeyIfDeterministic, } from "../../types/type-ops.js";
+import { getSourceSpan } from "./helpers.js";
+import { convertExpression } from "../../expression-converter.js";
+export const isNullishPrimitive = (type) => type.kind === "primitiveType" &&
+    (type.name === "null" || type.name === "undefined");
+/**
+ * Compute the element type for an array literal from its elements' types.
+ *
+ * Rules:
+ * 1. All numeric literals with same intent → use that intent (int, long, double)
+ * 2. Mixed Int32/Int64 → Int64
+ * 3. Any Double present → double
+ * 4. String literals → string
+ * 5. Boolean literals → boolean
+ * 6. Mixed or complex → fall back to TS inference
+ */
+const computeArrayElementType = (elements, fallbackType) => {
+    const mergeElementTypes = (types) => {
+        if (types.length === 0)
+            return undefined;
+        if (types.some((type) => type.kind === "anyType")) {
+            return { kind: "anyType" };
+        }
+        if (types.some((type) => type.kind === "unknownType")) {
+            return { kind: "unknownType" };
+        }
+        const first = types[0];
+        if (first && types.every((t) => typesEqual(t, first))) {
+            return first;
+        }
+        return {
+            kind: "unionType",
+            types,
+        };
+    };
+    const extractSpreadElementTypes = (type) => {
+        if (!type)
+            return undefined;
+        if (type.kind === "arrayType") {
+            return [type.elementType];
+        }
+        if (type.kind === "tupleType") {
+            return type.elementTypes.filter((element) => element !== undefined);
+        }
+        if (type.kind === "unionType") {
+            const members = [];
+            for (const member of type.types) {
+                const extracted = extractSpreadElementTypes(member);
+                if (!extracted)
+                    return undefined;
+                members.push(...extracted);
+            }
+            return members;
+        }
+        if (type.kind === "referenceType" &&
+            type.typeArguments &&
+            type.typeArguments.length > 0) {
+            const simpleName = type.name.split(".").pop() ?? type.name;
+            switch (simpleName) {
+                case "Array":
+                case "ReadonlyArray":
+                case "Iterable":
+                case "IterableIterator":
+                case "Iterator":
+                case "AsyncIterable":
+                case "AsyncIterableIterator":
+                case "Generator":
+                case "AsyncGenerator":
+                case "Set":
+                case "ReadonlySet":
+                case "IEnumerable":
+                case "IReadOnlyList":
+                case "List":
+                    return type.typeArguments[0] ? [type.typeArguments[0]] : undefined;
+                case "Map":
+                case "ReadonlyMap":
+                    return type.typeArguments[0] && type.typeArguments[1]
+                        ? [
+                            {
+                                kind: "tupleType",
+                                elementTypes: [type.typeArguments[0], type.typeArguments[1]],
+                            },
+                        ]
+                        : undefined;
+                default:
+                    return undefined;
+            }
+        }
+        return undefined;
+    };
+    // Filter out holes and spreads for type analysis
+    const regularElements = elements.filter((e) => e !== undefined && e.kind !== "spread");
+    const spreadElements = elements.filter((e) => e !== undefined && e.kind === "spread");
+    if (regularElements.length === 0 && spreadElements.length === 0) {
+        // Empty array - use fallback
+        return fallbackType;
+    }
+    // Check if all elements are numeric literals
+    const numericIntents = [];
+    let allNumericLiterals = true;
+    let allStringLiterals = true;
+    let allBooleanLiterals = true;
+    for (const elem of regularElements) {
+        if (elem.kind === "literal") {
+            if (typeof elem.value === "number" && elem.numericIntent) {
+                numericIntents.push(elem.numericIntent);
+                allStringLiterals = false;
+                allBooleanLiterals = false;
+            }
+            else if (typeof elem.value === "string") {
+                allNumericLiterals = false;
+                allBooleanLiterals = false;
+            }
+            else if (typeof elem.value === "boolean") {
+                allNumericLiterals = false;
+                allStringLiterals = false;
+            }
+            else {
+                // null or other literal
+                allNumericLiterals = false;
+                allStringLiterals = false;
+                allBooleanLiterals = false;
+            }
+        }
+        else {
+            // Non-literal element - can't determine type deterministically from literals
+            allNumericLiterals = false;
+            allStringLiterals = false;
+            allBooleanLiterals = false;
+        }
+    }
+    const hasOnlyRegularElements = regularElements.length > 0 && spreadElements.length === 0;
+    // All numeric literals - determine widest type
+    if (hasOnlyRegularElements &&
+        allNumericLiterals &&
+        numericIntents.length > 0) {
+        // Any Double → number (emits as "double" in C#)
+        if (numericIntents.includes("Double") ||
+            numericIntents.includes("Single")) {
+            return { kind: "primitiveType", name: "number" };
+        }
+        // Any Int64/UInt64 → fall back to TS inference (no primitive for long)
+        if (numericIntents.includes("Int64") || numericIntents.includes("UInt64")) {
+            return fallbackType;
+        }
+        // All Int32 or smaller → int
+        return { kind: "primitiveType", name: "int" };
+    }
+    // All string literals
+    if (hasOnlyRegularElements && allStringLiterals) {
+        return { kind: "primitiveType", name: "string" };
+    }
+    // All boolean literals
+    if (hasOnlyRegularElements && allBooleanLiterals) {
+        return { kind: "primitiveType", name: "boolean" };
+    }
+    // Mixed or complex - fall back to TS inference
+    // If all elements have a deterministically known IR type and they match, use it.
+    // This enables arrays like `[wrap(1), wrap(2)]` to infer `Container<int>[]`
+    // instead of defaulting to `number[]`.
+    const knownTypes = [];
+    for (const elem of regularElements) {
+        const t = elem.inferredType;
+        if (!t) {
+            return fallbackType;
+        }
+        knownTypes.push(t);
+    }
+    for (const spread of spreadElements) {
+        const spreadTypes = extractSpreadElementTypes(spread.expression.inferredType);
+        if (!spreadTypes) {
+            return fallbackType;
+        }
+        knownTypes.push(...spreadTypes);
+    }
+    const merged = mergeElementTypes(knownTypes);
+    if (merged) {
+        return merged;
+    }
+    return fallbackType;
+};
+export const normalizeExpectedArrayType = (expectedType, ctx) => {
+    if (!expectedType)
+        return undefined;
+    const matchesRecursiveElementTarget = (left, right) => {
+        if (ctx.typeSystem.typesEqual(left, right)) {
+            return true;
+        }
+        if (left.kind === "referenceType" &&
+            right.kind === "referenceType" &&
+            (left.typeArguments?.length ?? 0) === (right.typeArguments?.length ?? 0)) {
+            const leftIdentity = referenceTypeIdentity(left);
+            const rightIdentity = referenceTypeIdentity(right);
+            if (leftIdentity === undefined ||
+                rightIdentity === undefined ||
+                leftIdentity !== rightIdentity) {
+                return false;
+            }
+            const leftArgs = left.typeArguments ?? [];
+            const rightArgs = right.typeArguments ?? [];
+            return leftArgs.every((arg, index) => {
+                const rightArg = rightArgs[index];
+                return !!rightArg && matchesRecursiveElementTarget(arg, rightArg);
+            });
+        }
+        return false;
+    };
+    const normalizeCandidate = (member) => {
+        if (member.kind === "arrayType") {
+            return member;
+        }
+        if (member.kind === "referenceType" &&
+            member.typeArguments &&
+            member.typeArguments.length > 0) {
+            const simpleName = member.name.split(".").pop() ?? member.name;
+            switch (simpleName) {
+                case "Array":
+                case "ReadonlyArray":
+                case "Iterable":
+                case "IterableIterator":
+                case "Iterator":
+                case "AsyncIterable":
+                case "AsyncIterableIterator":
+                case "Generator":
+                case "AsyncGenerator":
+                case "Set":
+                case "ReadonlySet":
+                case "IEnumerable":
+                case "IReadOnlyList":
+                case "List": {
+                    const elementType = member.typeArguments[0];
+                    return elementType
+                        ? {
+                            kind: "arrayType",
+                            elementType,
+                        }
+                        : undefined;
+                }
+                default:
+                    return undefined;
+            }
+        }
+        return undefined;
+    };
+    const directCandidate = normalizeCandidate(expectedType);
+    if (directCandidate) {
+        return directCandidate;
+    }
+    const candidateMap = new Map();
+    for (const member of ctx.typeSystem
+        .collectNarrowingCandidates(expectedType)
+        .filter((candidate) => !!candidate && !isNullishPrimitive(candidate))) {
+        const normalized = normalizeCandidate(member);
+        if (!normalized || containsTypeParameter(normalized))
+            continue;
+        const key = stableIrTypeKeyIfDeterministic(normalized);
+        if (!key)
+            continue;
+        candidateMap.set(key, normalized);
+    }
+    const candidates = [...candidateMap.values()];
+    if (candidates.length === 1) {
+        return candidates[0];
+    }
+    const selfRecursiveCandidates = candidates.filter((candidate) => matchesRecursiveElementTarget(candidate.elementType, expectedType));
+    if (selfRecursiveCandidates.length === 1) {
+        return selfRecursiveCandidates[0];
+    }
+    const widestCandidates = candidates.filter((candidate) => candidates.every((other) => ctx.typeSystem.isAssignableTo(other.elementType, candidate.elementType)));
+    return widestCandidates.length === 1 ? widestCandidates[0] : undefined;
+};
+const normalizeExpectedTupleType = (expectedType, ctx) => {
+    if (!expectedType)
+        return undefined;
+    const candidates = ctx.typeSystem
+        .collectNarrowingCandidates(expectedType)
+        .filter((candidate) => !!candidate && !isNullishPrimitive(candidate))
+        .filter((candidate) => candidate.kind === "tupleType" && !containsTypeParameter(candidate));
+    if (candidates.length !== 1) {
+        return undefined;
+    }
+    return candidates[0];
+};
+/**
+ * Convert array literal expression
+ *
+ * DETERMINISTIC TYPING:
+ * - If expectedType is provided (from LHS annotation), use it
+ * - Otherwise, derive from element types using literal form analysis
+ * - Default to number[] (double[]) for ergonomics when type cannot be determined
+ *
+ * @param node - The TypeScript array literal expression
+ * @param ctx - ProgramContext for type system and binding access
+ * @param expectedType - Expected type from context (e.g., `const a: number[] = [1,2,3]`).
+ *                       Pass `undefined` explicitly when no contextual type exists.
+ */
+export const convertArrayLiteral = (node, ctx, expectedType) => {
+    const contextualTupleType = normalizeExpectedTupleType(expectedType, ctx);
+    const contextualArrayType = normalizeExpectedArrayType(expectedType, ctx);
+    // Determine element expected type from array expected type
+    // Convert all elements, passing expected element type for contextual typing
+    const elements = node.elements.map((elem, index) => {
+        const expectedElementType = contextualTupleType?.elementTypes[index] ??
+            contextualArrayType?.elementType;
+        if (ts.isOmittedExpression(elem)) {
+            return undefined; // Hole in sparse array
+        }
+        if (ts.isSpreadElement(elem)) {
+            // Spread element - convert and derive type from expression
+            const spreadExpr = convertExpression(elem.expression, ctx, contextualTupleType ?? expectedType);
+            return {
+                kind: "spread",
+                expression: spreadExpr,
+                inferredType: spreadExpr.inferredType,
+                sourceSpan: getSourceSpan(elem),
+            };
+        }
+        return convertExpression(elem, ctx, expectedElementType);
+    });
+    // DETERMINISTIC TYPING: Determine inferredType using priority:
+    // 1. Expected type from context (e.g., LHS annotation, parameter type)
+    // 2. Literal-form inference (derive from element types)
+    // 3. Default: number[] (double[]) for ergonomics
+    const inferredType = contextualTupleType
+        ? contextualTupleType
+        : contextualArrayType
+            ? contextualArrayType
+            : (() => {
+                // No expected type - derive from element types
+                const elementType = computeArrayElementType(elements, undefined);
+                if (elementType) {
+                    return { kind: "arrayType", elementType };
+                }
+                // Default to number[] (double[]) for ergonomics
+                // This matches Alice's guidance: untyped arrays default to double[]
+                return {
+                    kind: "arrayType",
+                    elementType: {
+                        kind: "primitiveType",
+                        name: "number",
+                    },
+                };
+            })();
+    return {
+        kind: "array",
+        elements,
+        inferredType,
+        sourceSpan: getSourceSpan(node),
+    };
+};
+//# sourceMappingURL=array-literals.js.map