@tsonic/emitter 0.0.62 → 0.0.63

package/dist/expressions/collections.js

@@ -1,10 +1,11 @@
 /**
  * Collection expression emitters (arrays and objects)
  */
-import { emitType } from "../type-emitter.js";
-import { emitExpression } from "../expression-emitter.js";
-import { getPropertyType, stripNullish, resolveTypeAlias, selectUnionMemberForObjectLiteral, } from "../core/type-resolution.js";
+import { emitTypeAst } from "../type-emitter.js";
+import { emitExpressionAst } from "../expression-emitter.js";
+import { getPropertyType, stripNullish, resolveTypeAlias, selectUnionMemberForObjectLiteral, } from "../core/semantic/type-resolution.js";
 import { emitCSharpName } from "../naming-policy.js";
+import { extractCalleeNameFromAst } from "../core/format/backend-ast/utils.js";
 const bucketFromMemberKind = (kind) => {
     switch (kind) {
         case "method":
@@ -95,9 +96,16 @@ const emitObjectMemberName = (receiverType, memberName, context) => {
     const kind = getMemberKind(receiverType, memberName, context);
     return emitCSharpName(memberName, bucketFromMemberKind(kind), context);
 };
+const getDeterministicObjectKeyName = (key) => {
+    if (typeof key === "string")
+        return key;
+    if (key.kind === "literal" && typeof key.value === "string") {
+        return key.value;
+    }
+    return undefined;
+};
 /**
  * Escape a string for use in a C# string literal.
- * Handles backslashes, quotes, newlines, carriage returns, and tabs.
  */
 const escapeCSharpString = (str) => str
     .replace(/\\/g, "\\\\")
@@ -106,11 +114,10 @@ const escapeCSharpString = (str) => str
     .replace(/\r/g, "\\r")
     .replace(/\t/g, "\\t");
 /**
- * Emit an array literal
+ * Emit an array literal as CSharpExpressionAst
  */
 export const emitArray = (expr, context, expectedType) => {
     // Resolve type alias to check for tuple types
-    // (e.g., type Point = [number, number] → resolve Point to the tuple type)
     const resolvedExpectedType = expectedType
         ? resolveTypeAlias(expectedType, context)
         : undefined;
@@ -118,25 +125,27 @@ export const emitArray = (expr, context, expectedType) => {
     if (resolvedExpectedType?.kind === "tupleType") {
         return emitTupleLiteral(expr, context, resolvedExpectedType);
     }
-    // Check if inferred type is a tuple (already resolved in frontend)
+    // Check if inferred type is a tuple
     if (expr.inferredType?.kind === "tupleType") {
         return emitTupleLiteral(expr, context, expr.inferredType);
     }
     let currentContext = context;
-    const elements = [];
-    // Determine element type from expected type or inferred type
-    // We track both the IR type (for threading to elements) and C# string (for emission)
-    let elementType = "object";
+    const elementAsts = [];
+    // Determine element type as AST
+    let elementTypeAst = {
+        kind: "predefinedType",
+        keyword: "object",
+    };
+    let elementTypeResolved = false;
     let expectedElementType = undefined;
-    // Priority 1: Use explicit type annotation if provided (e.g., const arr: number[] = [1, 2, 3])
-    // This ensures the array type matches the declared variable type
-    // IMPORTANT: Resolve aliases and strip nullish to handle type Longs = long[] etc.
+    // Priority 1: Use explicit type annotation
     if (expectedType) {
         const resolvedExpected = resolveTypeAlias(stripNullish(expectedType), context);
         if (resolvedExpected.kind === "arrayType") {
             expectedElementType = resolvedExpected.elementType;
-            const [elemTypeStr, newContext] = emitType(resolvedExpected.elementType, currentContext);
-            elementType = elemTypeStr;
+            const [typeAst, newContext] = emitTypeAst(resolvedExpected.elementType, currentContext);
+            elementTypeAst = typeAst;
+            elementTypeResolved = true;
             currentContext = newContext;
         }
         else if (resolvedExpected.kind === "referenceType" &&
@@ -146,139 +155,155 @@ export const emitArray = (expr, context, expectedType) => {
             const firstArg = resolvedExpected.typeArguments[0];
             if (firstArg) {
                 expectedElementType = firstArg;
-                const [elemTypeStr, newContext] = emitType(firstArg, currentContext);
-                elementType = elemTypeStr;
+                const [typeAst, newContext] = emitTypeAst(firstArg, currentContext);
+                elementTypeAst = typeAst;
+                elementTypeResolved = true;
                 currentContext = newContext;
             }
         }
     }
-    // Priority 2: If no explicit type, infer from literals (e.g., const arr = [1, 2, 3])
-    // All integers → int, any decimal → double, all strings → string, all bools → bool
-    if (elementType === "object") {
+    // Priority 2: Infer from literals
+    if (!elementTypeResolved) {
         const definedElements = expr.elements.filter((el) => el !== undefined);
         if (definedElements.length > 0) {
             const allLiterals = definedElements.every((el) => el.kind === "literal");
             if (allLiterals) {
                 const literals = definedElements;
-                // Check if all are numbers
                 const allNumbers = literals.every((lit) => typeof lit.value === "number");
                 if (allNumbers) {
-                    // Infer int vs long vs double from numericIntent (based on raw lexeme)
-                    // Any Double → double, any Int64 → long, otherwise → int
                     const hasDouble = literals.some((lit) => lit.numericIntent === "Double");
                     const hasLong = literals.some((lit) => lit.numericIntent === "Int64");
                     if (hasDouble) {
-                        elementType = "double";
+                        elementTypeAst = { kind: "predefinedType", keyword: "double" };
+                        elementTypeResolved = true;
                     }
                     else if (hasLong) {
-                        elementType = "long";
+                        elementTypeAst = { kind: "predefinedType", keyword: "long" };
+                        elementTypeResolved = true;
                     }
                     else {
-                        elementType = "int";
+                        elementTypeAst = { kind: "predefinedType", keyword: "int" };
+                        elementTypeResolved = true;
                     }
                 }
-                // Check if all are strings
                 else if (literals.every((lit) => typeof lit.value === "string")) {
-                    elementType = "string";
+                    elementTypeAst = { kind: "predefinedType", keyword: "string" };
+                    elementTypeResolved = true;
                 }
-                // Check if all are booleans
                 else if (literals.every((lit) => typeof lit.value === "boolean")) {
-                    elementType = "bool";
+                    elementTypeAst = { kind: "predefinedType", keyword: "bool" };
+                    elementTypeResolved = true;
                 }
             }
         }
     }
-    // Priority 3: Fall back to inferred type from expression
-    // IMPORTANT: Also set expectedElementType so literals get proper suffixes
-    if (elementType === "object") {
+    // Priority 3: Fall back to inferred type
+    if (!elementTypeResolved) {
         if (expr.inferredType && expr.inferredType.kind === "arrayType") {
             expectedElementType = expr.inferredType.elementType;
-            const [elemTypeStr, newContext] = emitType(expr.inferredType.elementType, currentContext);
-            elementType = elemTypeStr;
+            const [typeAst, newContext] = emitTypeAst(expr.inferredType.elementType, currentContext);
+            elementTypeAst = typeAst;
             currentContext = newContext;
         }
     }
-    // Check if array contains only spread elements (e.g., [...arr1, ...arr2])
+    // Check if array contains only spread elements
     const allSpreads = expr.elements.every((el) => el !== undefined && el.kind === "spread");
     if (allSpreads && expr.elements.length > 0) {
-        // Emit as chained Enumerable.Concat calls using explicit static invocation
-        // Note: Concat returns IEnumerable<T>, so wrap in Enumerable.ToList() at the end
+        // Emit as chained Enumerable.Concat calls + ToArray()
         const spreadElements = expr.elements.filter((el) => el !== undefined && el.kind === "spread");
         const firstSpread = spreadElements[0];
         if (!firstSpread) {
-            // Should never happen due to allSpreads check, but satisfy TypeScript
-            return [{ text: "new object[0]" }, currentContext];
+            return [
+                {
+                    kind: "arrayCreationExpression",
+                    elementType: { kind: "predefinedType", keyword: "object" },
+                    sizeExpression: { kind: "literalExpression", text: "0" },
+                },
+                currentContext,
+            ];
         }
-        const [firstFrag, firstContext] = emitExpression(firstSpread.expression, currentContext);
+        const [firstAst, firstContext] = emitExpressionAst(firstSpread.expression, currentContext);
         currentContext = firstContext;
-        let result = firstFrag.text;
+        // Build chain of Concat calls
+        let concatAst = firstAst;
         for (let i = 1; i < spreadElements.length; i++) {
             const spread = spreadElements[i];
             if (spread) {
-                const [spreadFrag, newContext] = emitExpression(spread.expression, currentContext);
-                // Use explicit static call for extension method
-                result = `global::System.Linq.Enumerable.Concat(${result}, ${spreadFrag.text})`;
+                const [spreadAst, newContext] = emitExpressionAst(spread.expression, currentContext);
+                concatAst = {
+                    kind: "invocationExpression",
+                    expression: {
+                        kind: "identifierExpression",
+                        identifier: "global::System.Linq.Enumerable.Concat",
+                    },
+                    arguments: [concatAst, spreadAst],
+                };
                 currentContext = newContext;
             }
         }
-        // Always emit native array via ToArray()
+        // Wrap in ToArray()
         return [
-            { text: `global::System.Linq.Enumerable.ToArray(${result})` },
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: "global::System.Linq.Enumerable.ToArray",
+                },
+                arguments: [concatAst],
+            },
             currentContext,
         ];
     }
     // Regular array or mixed spreads/elements
     for (const element of expr.elements) {
         if (element === undefined) {
-            // Sparse array hole - fill with default value
-            elements.push("default");
+            // Sparse array hole
+            elementAsts.push({ kind: "defaultExpression" });
         }
         else if (element.kind === "spread") {
             // Spread mixed with other elements - not yet supported
-            elements.push("/* ...spread */");
+            elementAsts.push({
+                kind: "identifierExpression",
+                identifier: "/* ...spread */",
+            });
         }
         else {
-            const [elemFrag, newContext] = emitExpression(element, currentContext, expectedElementType);
-            elements.push(elemFrag.text);
+            const [elemAst, newContext] = emitExpressionAst(element, currentContext, expectedElementType);
+            elementAsts.push(elemAst);
             currentContext = newContext;
         }
     }
     // Always emit native CLR array
-    // Use new T[] { } syntax for non-empty arrays (explicit type for correct suffix handling)
-    // Use Array.Empty<T>() for empty arrays (cached singleton, no allocation)
-    const text = elements.length === 0
-        ? `global::System.Array.Empty<${elementType}>()`
-        : `new ${elementType}[] { ${elements.join(", ")} }`;
-    return [{ text }, currentContext];
+    if (elementAsts.length === 0) {
+        // Array.Empty<T>() for empty arrays
+        return [
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: "global::System.Array.Empty",
+                },
+                arguments: [],
+                typeArguments: [elementTypeAst],
+            },
+            currentContext,
+        ];
+    }
+    // new T[] { elem1, elem2, ... }
+    return [
+        {
+            kind: "arrayCreationExpression",
+            elementType: elementTypeAst,
+            initializer: elementAsts,
+        },
+        currentContext,
+    ];
 };
 /**
- * Emit an object literal
- *
- * Handles three cases based on contextual type and structure:
- * 1. Dictionary type (Record<K,V> or index signature) → Dictionary<string, T> initializer
- * 2. Object with spreads → IIFE pattern: (() => { var __tmp = new T(); ... return __tmp; })()
- * 3. Nominal type (interface, class) → new TypeName { prop = value, ... }
- *
- * Anonymous object types should be caught by validation (TSN7403) before reaching here.
- *
- * @param expr - The object expression
- * @param context - Emitter context
- * @param expectedType - Optional expected type (for property type resolution in generic contexts)
+ * Emit an object literal as CSharpExpressionAst
  */
 export const emitObject = (expr, context, expectedType) => {
     let currentContext = context;
-    // Use expectedType if provided, fall back to contextualType.
-    //
-    // IMPORTANT: Do not allow non-instantiable expected types (unknown/object/any)
-    // to override a synthesized contextual type (TSN7403 anonymous object synthesis).
-    //
-    // Example:
-    //   function f(x: unknown): void {}
-    //   f({ ok: true })
-    //
-    // The object literal is synthesized to a nominal `__Anon_*` type, but the call
-    // argument's expectedType is still `unknown`. We must instantiate the synthesized
-    // type, not `new object { ok = true }` (invalid C#).
     const effectiveType = (() => {
         if (!expectedType)
             return expr.contextualType;
@@ -295,154 +320,214 @@ export const emitObject = (expr, context, expectedType) => {
     if (effectiveType?.kind === "dictionaryType") {
         return emitDictionaryLiteral(expr, currentContext, effectiveType);
     }
-    // Check for contextual type (from return type, variable annotation, etc.)
-    // Strip null/undefined from type - `new T? { ... }` is invalid C#, use `new T { ... }`
     const strippedType = effectiveType
         ? stripNullish(effectiveType)
         : undefined;
     // Handle union type aliases: select the best-matching union member
-    // e.g., for `type Result<T,E> = { ok: true; value: T } | { ok: false; error: E }`
-    // we want to emit `new Result__0<T,E> { ... }` not `new Result<T,E> { ... }`
     const instantiationType = (() => {
         if (!strippedType)
             return undefined;
         const resolved = resolveTypeAlias(strippedType, currentContext);
         if (resolved.kind !== "unionType")
             return strippedType;
-        // Extract only plain string keys from the literal
         const literalKeys = expr.properties
             .filter((p) => p.kind === "property" && typeof p.key === "string")
             .map((p) => p.key);
-        // If any property is not a plain string key, cannot match
         if (literalKeys.length !== expr.properties.length)
             return strippedType;
         const selected = selectUnionMemberForObjectLiteral(resolved, literalKeys, currentContext);
         return selected ?? strippedType;
     })();
-    const [typeName, typeContext] = resolveContextualType(instantiationType, currentContext);
+    const [typeAst, typeContext] = resolveContextualTypeAst(instantiationType, currentContext);
     currentContext = typeContext;
-    if (!typeName) {
-        // ICE: Validation (TSN7403) should have caught anonymous object literals
+    if (!typeAst) {
         throw new Error("ICE: Object literal without contextual type reached emitter - validation missed TSN7403");
     }
-    // Safety net: strip trailing `?` from type name (e.g., `Option<T>?` → `Option<T>`)
-    // `new T? { ... }` is never valid C# syntax
-    const safeTypeName = typeName.endsWith("?")
-        ? typeName.slice(0, -1)
-        : typeName;
-    // Check if object has spreads - use IIFE pattern for spread lowering
+    // Strip nullable wrapper for object construction
+    const safeTypeAst = typeAst.kind === "nullableType" ? typeAst.underlyingType : typeAst;
+    // Check if object has spreads - use IIFE pattern
     if (expr.hasSpreads) {
-        return emitObjectWithSpreads(expr, currentContext, effectiveType, safeTypeName, instantiationType);
+        return emitObjectWithSpreads(expr, currentContext, effectiveType, safeTypeAst, instantiationType);
     }
-    // Regular object literal with nominal type - no spreads
-    const properties = [];
+    // Regular object literal with nominal type
+    const initializerAsts = [];
     for (const prop of expr.properties) {
         if (prop.kind === "spread") {
-            // Should not reach here if hasSpreads is correctly set
             throw new Error("ICE: Spread in object literal but hasSpreads is false");
         }
         else {
-            const key = typeof prop.key === "string"
-                ? emitObjectMemberName(instantiationType, prop.key, currentContext)
-                : "/* computed */";
-            // Resolve property type from contextual type for generic null→default handling
-            const propertyExpectedType = typeof prop.key === "string"
-                ? getPropertyType(instantiationType ?? effectiveType, prop.key, currentContext)
-                : undefined;
-            const [valueFrag, newContext] = emitExpression(prop.value, currentContext, propertyExpectedType);
-            properties.push(`${key} = ${valueFrag.text}`);
+            const keyName = getDeterministicObjectKeyName(prop.key);
+            if (!keyName) {
+                throw new Error("ICE: Unsupported computed property key reached nominal object emission");
+            }
+            const key = emitObjectMemberName(instantiationType, keyName, currentContext);
+            const propertyExpectedType = getPropertyType(instantiationType ?? effectiveType, keyName, currentContext);
+            const [valueAst, newContext] = emitExpressionAst(prop.value, currentContext, propertyExpectedType);
+            initializerAsts.push({
+                kind: "assignmentExpression",
+                operatorToken: "=",
+                left: { kind: "identifierExpression", identifier: key },
+                right: valueAst,
+            });
             currentContext = newContext;
         }
     }
-    const text = `new ${safeTypeName} { ${properties.join(", ")} }`;
-    return [{ text }, currentContext];
+    return [
+        {
+            kind: "objectCreationExpression",
+            type: safeTypeAst,
+            arguments: [],
+            initializer: initializerAsts,
+        },
+        currentContext,
+    ];
 };
 /**
  * Emit an object literal with spreads using IIFE pattern.
- *
- * Input:  { ...base, y: 2 }
- * Output: ((global::System.Func<T>)(() => { var __tmp = new T(); __tmp.x = base.x; __tmp.y = 2.0; return __tmp; }))()
- *
- * Properties are set in order: spread properties first, then explicit properties.
- * Later properties override earlier ones (JavaScript semantics).
  */
-const emitObjectWithSpreads = (expr, context, effectiveType, typeName, targetType) => {
+const emitObjectWithSpreads = (expr, context, effectiveType, typeAst, targetType) => {
     let currentContext = context;
-    const assignments = [];
+    const bodyStatements = [];
+    // var __tmp = new TypeName()
+    const initStatement = {
+        kind: "localDeclarationStatement",
+        modifiers: [],
+        type: { kind: "varType" },
+        declarators: [
+            {
+                name: "__tmp",
+                initializer: {
+                    kind: "objectCreationExpression",
+                    type: typeAst,
+                    arguments: [],
+                },
+            },
+        ],
+    };
+    bodyStatements.push(initStatement);
     for (const prop of expr.properties) {
         if (prop.kind === "spread") {
-            // Spread: copy all properties from spread source
-            const [spreadAssignments, newContext] = emitSpreadPropertyCopies(targetType, prop.expression, currentContext);
-            assignments.push(...spreadAssignments);
+            const [spreadStatements, newContext] = emitSpreadPropertyCopyStatements(targetType, prop.expression, currentContext);
+            bodyStatements.push(...spreadStatements);
             currentContext = newContext;
         }
         else {
-            // Explicit property assignment
-            const key = typeof prop.key === "string"
-                ? emitObjectMemberName(targetType, prop.key, currentContext)
-                : "/* computed */";
-            const propertyExpectedType = typeof prop.key === "string"
-                ? getPropertyType(targetType ?? effectiveType, prop.key, currentContext)
-                : undefined;
-            const [valueFrag, newContext] = emitExpression(prop.value, currentContext, propertyExpectedType);
-            assignments.push(`__tmp.${key} = ${valueFrag.text}`);
+            const keyName = getDeterministicObjectKeyName(prop.key);
+            if (!keyName) {
+                throw new Error("ICE: Unsupported computed property key reached spread object emission");
+            }
+            const key = emitObjectMemberName(targetType, keyName, currentContext);
+            const propertyExpectedType = getPropertyType(targetType ?? effectiveType, keyName, currentContext);
+            const [valueAst, newContext] = emitExpressionAst(prop.value, currentContext, propertyExpectedType);
+            bodyStatements.push({
+                kind: "expressionStatement",
+                expression: {
+                    kind: "assignmentExpression",
+                    operatorToken: "=",
+                    left: {
+                        kind: "memberAccessExpression",
+                        expression: { kind: "identifierExpression", identifier: "__tmp" },
+                        memberName: key,
+                    },
+                    right: valueAst,
+                },
+            });
             currentContext = newContext;
         }
     }
-    // Build IIFE: ((Func<T>)(() => { var __tmp = new T(); ...; return __tmp; }))()
-    const body = [
-        `var __tmp = new ${typeName}()`,
-        ...assignments,
-        "return __tmp",
-    ].join("; ");
-    const text = `((global::System.Func<${typeName}>)(() => { ${body}; }))()`;
-    return [{ text }, currentContext];
+    // return __tmp
+    bodyStatements.push({
+        kind: "returnStatement",
+        expression: { kind: "identifierExpression", identifier: "__tmp" },
+    });
+    // IIFE: ((System.Func<T>)(() => { body }))()
+    const funcTypeAst = {
+        kind: "identifierType",
+        name: "global::System.Func",
+        typeArguments: [typeAst],
+    };
+    const lambdaAst = {
+        kind: "lambdaExpression",
+        isAsync: false,
+        parameters: [],
+        body: { kind: "blockStatement", statements: bodyStatements },
+    };
+    const castAst = {
+        kind: "castExpression",
+        type: funcTypeAst,
+        expression: {
+            kind: "parenthesizedExpression",
+            expression: lambdaAst,
+        },
+    };
+    return [
+        {
+            kind: "invocationExpression",
+            expression: {
+                kind: "parenthesizedExpression",
+                expression: castAst,
+            },
+            arguments: [],
+        },
+        currentContext,
+    ];
 };
 /**
- * Emit property copy assignments from a spread source.
- *
- * For `...base` where base has type { x: number, y: string }:
- * Returns ["__tmp.x = base.x", "__tmp.y = base.y"]
+ * Emit property copy assignments from a spread source as AST statements.
  */
-const emitSpreadPropertyCopies = (targetType, spreadExpr, context) => {
+const emitSpreadPropertyCopyStatements = (targetType, spreadExpr, context) => {
     let currentContext = context;
-    const assignments = [];
-    // Get the spread expression's type to know which properties to copy
+    const statements = [];
     const spreadType = spreadExpr.inferredType;
     if (!spreadType) {
-        // No type info - emit a warning comment
-        const [exprFrag, newContext] = emitExpression(spreadExpr, currentContext);
-        assignments.push(`/* spread: ${exprFrag.text} (no type info) */`);
-        return [assignments, newContext];
+        const [exprAst, newContext] = emitExpressionAst(spreadExpr, currentContext);
+        const exprText = extractCalleeNameFromAst(exprAst);
+        statements.push({
+            kind: "expressionStatement",
+            expression: {
+                kind: "identifierExpression",
+                identifier: `/* spread: ${exprText} (no type info) */`,
+            },
+        });
+        return [statements, newContext];
     }
-    // Emit the spread source expression
-    const [sourceFrag, sourceContext] = emitExpression(spreadExpr, currentContext);
+    const [sourceAst, sourceContext] = emitExpressionAst(spreadExpr, currentContext);
     currentContext = sourceContext;
-    const sourceExpr = sourceFrag.text;
-    // Extract properties from the spread type
     const propertyNames = getObjectTypePropertyNames(spreadType, currentContext);
     for (const propName of propertyNames) {
         const targetMember = emitObjectMemberName(targetType, propName, currentContext);
         const sourceMember = emitObjectMemberName(spreadType, propName, currentContext);
-        assignments.push(`__tmp.${targetMember} = ${sourceExpr}.${sourceMember}`);
+        statements.push({
+            kind: "expressionStatement",
+            expression: {
+                kind: "assignmentExpression",
+                operatorToken: "=",
+                left: {
+                    kind: "memberAccessExpression",
+                    expression: { kind: "identifierExpression", identifier: "__tmp" },
+                    memberName: targetMember,
+                },
+                right: {
+                    kind: "memberAccessExpression",
+                    expression: sourceAst,
+                    memberName: sourceMember,
+                },
+            },
+        });
     }
-    return [assignments, currentContext];
+    return [statements, currentContext];
 };
 /**
  * Get property names from an object-like type.
- * Handles objectType, referenceType (to interfaces/classes), and resolved type aliases.
  */
 const getObjectTypePropertyNames = (type, context) => {
     const resolved = resolveTypeAlias(stripNullish(type), context);
-    // Direct object type
     if (resolved.kind === "objectType") {
         return resolved.members
             .filter((m) => m.kind === "propertySignature")
             .map((m) => m.name);
     }
-    // Reference type - check type aliases registry
     if (resolved.kind === "referenceType") {
-        // Check localTypes for class/interface/typeAlias members
         const localType = context.localTypes?.get(resolved.name);
         if (localType?.kind === "interface") {
             return localType.members
@@ -460,7 +545,6 @@ const getObjectTypePropertyNames = (type, context) => {
                 .filter((m) => m.kind === "propertySignature")
                 .map((m) => m.name);
         }
-        // Cross-module: fall back to global member kind index when available
         const receiverFqn = resolveReceiverTypeFqn(resolved, context);
         if (receiverFqn) {
             const perType = context.options.typeMemberIndex?.get(receiverFqn);
@@ -475,125 +559,125 @@ const getObjectTypePropertyNames = (type, context) => {
             }
         }
     }
-    // Unknown type structure - return empty
     return [];
 };
 /**
- * Emit a dictionary literal using C# collection initializer syntax.
- *
- * Input:  const d: Record<string, number> = { a: 1, b: 2 };
- * Output: new Dictionary<string, double> { ["a"] = 1.0, ["b"] = 2.0 }
+ * Emit a dictionary literal as CSharpExpressionAst
  */
 const emitDictionaryLiteral = (expr, context, dictType) => {
     let currentContext = context;
-    // Get key and value type strings
-    const [keyTypeStr, ctx1] = emitDictKeyType(dictType.keyType, currentContext);
-    const [valueTypeStr, ctx2] = emitType(dictType.valueType, ctx1);
+    const keyTypeAst = emitDictKeyTypeAst(dictType.keyType);
+    const [valueTypeAst, ctx2] = emitTypeAst(dictType.valueType, currentContext);
     currentContext = ctx2;
-    // Emit dictionary entries
-    const entries = [];
+    const dictTypeAst = {
+        kind: "identifierType",
+        name: "global::System.Collections.Generic.Dictionary",
+        typeArguments: [keyTypeAst, valueTypeAst],
+    };
+    const initializerAsts = [];
     for (const prop of expr.properties) {
         if (prop.kind === "spread") {
-            // Spread in dictionary literal - not supported
             throw new Error("ICE: Spread in dictionary literal not supported");
         }
         else {
-            // Key must be a string literal for dictionary initialization
             if (typeof prop.key !== "string") {
                 throw new Error("ICE: Computed property key in dictionary literal - validation gap");
             }
-            // Pass dictionary value type as expectedType for generic null→default handling
-            const [valueFrag, newContext] = emitExpression(prop.value, currentContext, dictType.valueType);
-            entries.push(`["${escapeCSharpString(prop.key)}"] = ${valueFrag.text}`);
+            const [valueAst, newContext] = emitExpressionAst(prop.value, currentContext, dictType.valueType);
+            // Dictionary initializer: ["key"] = value
+            initializerAsts.push({
+                kind: "assignmentExpression",
+                operatorToken: "=",
+                left: {
+                    kind: "identifierExpression",
+                    identifier: `["${escapeCSharpString(prop.key)}"]`,
+                },
+                right: valueAst,
+            });
             currentContext = newContext;
         }
     }
-    const text = entries.length === 0
-        ? `new global::System.Collections.Generic.Dictionary<${keyTypeStr}, ${valueTypeStr}>()`
-        : `new global::System.Collections.Generic.Dictionary<${keyTypeStr}, ${valueTypeStr}> { ${entries.join(", ")} }`;
-    return [{ text }, currentContext];
+    return [
+        {
+            kind: "objectCreationExpression",
+            type: dictTypeAst,
+            arguments: [],
+            initializer: initializerAsts.length > 0 ? initializerAsts : undefined,
+        },
+        currentContext,
+    ];
 };
 /**
- * Emit dictionary key type.
- * Allowed: string, number (→ double).
- * Enforced by TSN7413.
+ * Emit dictionary key type as AST.
  */
-const emitDictKeyType = (keyType, context) => {
+const emitDictKeyTypeAst = (keyType) => {
     if (keyType.kind === "primitiveType") {
         switch (keyType.name) {
             case "string":
-                return ["string", context];
+                return { kind: "predefinedType", keyword: "string" };
             case "number":
-                return ["double", context];
+                return { kind: "predefinedType", keyword: "double" };
         }
     }
-    // ICE: Unsupported key type (should have been caught by TSN7413)
+    if (keyType.kind === "referenceType" && keyType.name === "object") {
+        return { kind: "predefinedType", keyword: "object" };
+    }
     throw new Error(`ICE: Unsupported dictionary key type reached emitter - validation missed TSN7413. Got: ${JSON.stringify(keyType)}`);
 };
 /**
- * Resolve contextual type to C# type string.
- * Uses emitType to properly handle generic type arguments.
- * For imported types, qualifies using importBindings.
+ * Resolve contextual type to C# type AST.
  */
-const resolveContextualType = (contextualType, context) => {
+const resolveContextualTypeAst = (contextualType, context) => {
     if (!contextualType) {
         return [undefined, context];
     }
-    // For reference types, check if imported and qualify if needed
     if (contextualType.kind === "referenceType") {
         const typeName = contextualType.name;
         const importBinding = context.importBindings?.get(typeName);
         if (importBinding && importBinding.kind === "type") {
-            // Imported type - use qualified name from binding
-            // Emit type arguments if present
             if (contextualType.typeArguments &&
                 contextualType.typeArguments.length > 0) {
                 let currentContext = context;
-                const typeArgStrs = [];
+                const typeArgAsts = [];
                 for (const typeArg of contextualType.typeArguments) {
-                    const [typeArgStr, newContext] = emitType(typeArg, currentContext);
-                    typeArgStrs.push(typeArgStr);
+                    const [typeArgAst, newContext] = emitTypeAst(typeArg, currentContext);
+                    typeArgAsts.push(typeArgAst);
                     currentContext = newContext;
                 }
                 return [
-                    `${importBinding.clrName}<${typeArgStrs.join(", ")}>`,
+                    {
+                        kind: "identifierType",
+                        name: importBinding.clrName,
+                        typeArguments: typeArgAsts,
+                    },
                     currentContext,
                 ];
             }
-            return [importBinding.clrName, context];
+            return [{ kind: "identifierType", name: importBinding.clrName }, context];
         }
-        // Local type - use emitType to handle type arguments
-        const [typeStr, newContext] = emitType(contextualType, context);
-        return [typeStr, newContext];
     }
-    // For other types, use standard emitType
-    const [typeStr, newContext] = emitType(contextualType, context);
-    return [typeStr, newContext];
+    return emitTypeAst(contextualType, context);
 };
 /**
- * Emit a tuple literal as ValueTuple.
+ * Emit a tuple literal as CSharpExpressionAst
  *
  * Input:  const t: [string, number] = ["hello", 42];
  * Output: ("hello", 42.0)
- *
- * C# ValueTuple has implicit tuple literal syntax with parentheses.
  */
 const emitTupleLiteral = (expr, context, tupleType) => {
     let currentContext = context;
-    const elements = [];
+    const elemAsts = [];
     const definedElements = expr.elements.filter((el) => el !== undefined);
-    // Emit each element with its expected type from the tuple type
     for (let i = 0; i < definedElements.length; i++) {
         const element = definedElements[i];
         const expectedElementType = tupleType.elementTypes[i];
         if (element) {
-            const [elemFrag, newContext] = emitExpression(element, currentContext, expectedElementType);
-            elements.push(elemFrag.text);
+            const [elemAst, newContext] = emitExpressionAst(element, currentContext, expectedElementType);
+            elemAsts.push(elemAst);
             currentContext = newContext;
         }
     }
-    // Emit as tuple literal: (elem1, elem2, ...)
-    const text = `(${elements.join(", ")})`;
-    return [{ text }, currentContext];
+    // C# tuple literal: (elem1, elem2, ...)
+    return [{ kind: "tupleExpression", elements: elemAsts }, currentContext];
 };
 //# sourceMappingURL=collections.js.map