@tsonic/frontend 0.0.67 → 0.0.68

package/dist/ir/converters/expressions/collections.js

@@ -2,11 +2,14 @@
  * Collection expression converters (arrays and objects)
  */
 import * as ts from "typescript";
-import { typesEqual } from "../../types/ir-substitution.js";
+import { containsTypeParameter, typesEqual, } from "../../types/ir-substitution.js";
 import { getSourceSpan, getContextualType } from "./helpers.js";
 import { convertExpression } from "../../expression-converter.js";
-import { checkSynthesisEligibility, } from "../anonymous-synthesis.js";
+import { checkSynthesisEligibility } from "../anonymous-synthesis.js";
 import { createDiagnostic } from "../../../types/diagnostic.js";
+import { convertAccessorProperty } from "../statements/declarations/classes/properties.js";
+import { convertBindingName } from "../../syntax/binding-patterns.js";
+import { createObjectLiteralMethodArgumentPrelude } from "../../../object-literal-method-runtime.js";
 /**
  * Compute the element type for an array literal from its elements' types.
  *
@@ -19,9 +22,78 @@ import { createDiagnostic } from "../../../types/diagnostic.js";
  * 6. Mixed or complex → fall back to TS inference
  */
 const computeArrayElementType = (elements, fallbackType) => {
+    const mergeElementTypes = (types) => {
+        if (types.length === 0)
+            return undefined;
+        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 "JSArray":
+                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");
-    if (regularElements.length === 0) {
+    const spreadElements = elements.filter((e) => e !== undefined && e.kind === "spread");
+    if (regularElements.length === 0 && spreadElements.length === 0) {
         // Empty array - use fallback
         return fallbackType;
     }
@@ -59,8 +131,11 @@ const computeArrayElementType = (elements, fallbackType) => {
             allBooleanLiterals = false;
         }
     }
+    const hasOnlyRegularElements = regularElements.length > 0 && spreadElements.length === 0;
     // All numeric literals - determine widest type
-    if (allNumericLiterals && numericIntents.length > 0) {
+    if (hasOnlyRegularElements &&
+        allNumericLiterals &&
+        numericIntents.length > 0) {
         // Any Double → number (emits as "double" in C#)
         if (numericIntents.includes("Double") ||
             numericIntents.includes("Single")) {
@@ -74,11 +149,11 @@ const computeArrayElementType = (elements, fallbackType) => {
         return { kind: "primitiveType", name: "int" };
     }
     // All string literals
-    if (allStringLiterals) {
+    if (hasOnlyRegularElements && allStringLiterals) {
         return { kind: "primitiveType", name: "string" };
     }
     // All boolean literals
-    if (allBooleanLiterals) {
+    if (hasOnlyRegularElements && allBooleanLiterals) {
         return { kind: "primitiveType", name: "boolean" };
     }
     // Mixed or complex - fall back to TS inference
@@ -93,9 +168,16 @@ const computeArrayElementType = (elements, fallbackType) => {
         }
         knownTypes.push(t);
     }
-    const first = knownTypes[0];
-    if (first && knownTypes.every((t) => typesEqual(first, t))) {
-        return first;
+    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;
 };
@@ -113,8 +195,11 @@ const computeArrayElementType = (elements, fallbackType) => {
  *                       Pass `undefined` explicitly when no contextual type exists.
  */
 export const convertArrayLiteral = (node, ctx, expectedType) => {
+    const contextualArrayType = expectedType?.kind === "arrayType" && !containsTypeParameter(expectedType)
+        ? expectedType
+        : undefined;
     // Determine element expected type from array expected type
-    const expectedElementType = expectedType?.kind === "arrayType" ? expectedType.elementType : undefined;
+    const expectedElementType = contextualArrayType?.elementType;
     // Convert all elements, passing expected element type for contextual typing
     const elements = node.elements.map((elem) => {
         if (ts.isOmittedExpression(elem)) {
@@ -136,8 +221,8 @@ export const convertArrayLiteral = (node, ctx, expectedType) => {
     // 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 = expectedType?.kind === "arrayType"
-        ? expectedType
+    const inferredType = contextualArrayType
+        ? contextualArrayType
         : (() => {
             // No expected type - derive from element types
             const elementType = computeArrayElementType(elements, undefined);
@@ -191,6 +276,249 @@ const getPropertyExpectedType = (propName, expectedType, ctx) => {
     }
     return undefined;
 };
+const unwrapDeterministicKeyExpression = (expr) => {
+    let current = expr;
+    for (;;) {
+        if (ts.isParenthesizedExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (ts.isAsExpression(current) ||
+            ts.isTypeAssertionExpression(current) ||
+            ts.isSatisfiesExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        return current;
+    }
+};
+const tryResolveDeterministicObjectKeyNameFromSyntax = (expr, ctx, seenSymbols = new Set()) => {
+    const current = unwrapDeterministicKeyExpression(expr);
+    if (ts.isStringLiteral(current) ||
+        ts.isNoSubstitutionTemplateLiteral(current) ||
+        ts.isNumericLiteral(current)) {
+        return String(current.text);
+    }
+    if (!ts.isIdentifier(current)) {
+        return undefined;
+    }
+    const symbol = ctx.checker.getSymbolAtLocation(current);
+    if (!symbol || seenSymbols.has(symbol)) {
+        return undefined;
+    }
+    seenSymbols.add(symbol);
+    const visitDeclarations = (target) => {
+        for (const decl of target.getDeclarations() ?? []) {
+            if (ts.isVariableDeclaration(decl) &&
+                decl.initializer &&
+                ts.isVariableDeclarationList(decl.parent) &&
+                (decl.parent.flags & ts.NodeFlags.Const) !== 0) {
+                const resolved = tryResolveDeterministicObjectKeyNameFromSyntax(decl.initializer, ctx, seenSymbols);
+                if (resolved !== undefined)
+                    return resolved;
+            }
+        }
+        return undefined;
+    };
+    const direct = visitDeclarations(symbol);
+    if (direct !== undefined)
+        return direct;
+    if ((symbol.flags & ts.SymbolFlags.Alias) !== 0) {
+        const aliased = ctx.checker.getAliasedSymbol(symbol);
+        if (!seenSymbols.has(aliased)) {
+            seenSymbols.add(aliased);
+            return visitDeclarations(aliased);
+        }
+    }
+    return undefined;
+};
+const resolveObjectLiteralMemberKey = (name, ctx) => {
+    if (ts.isIdentifier(name) ||
+        ts.isStringLiteral(name) ||
+        ts.isNoSubstitutionTemplateLiteral(name) ||
+        ts.isNumericLiteral(name)) {
+        const keyName = String(name.text);
+        return { key: keyName, keyName };
+    }
+    if (!ts.isComputedPropertyName(name)) {
+        return { key: "", keyName: undefined };
+    }
+    const keyName = tryResolveDeterministicObjectKeyNameFromSyntax(name.expression, ctx);
+    const computedKey = convertExpression(unwrapDeterministicKeyExpression(name.expression), ctx, undefined);
+    return { key: keyName ?? computedKey, keyName };
+};
+const methodUsesObjectLiteralThis = (method) => {
+    let found = false;
+    const visit = (current) => {
+        if (found)
+            return;
+        if (current.kind === ts.SyntaxKind.ThisKeyword) {
+            found = true;
+            return;
+        }
+        if (ts.isFunctionExpression(current) ||
+            ts.isFunctionDeclaration(current) ||
+            ts.isMethodDeclaration(current) ||
+            ts.isGetAccessorDeclaration(current) ||
+            ts.isSetAccessorDeclaration(current)) {
+            if (current !== method) {
+                return;
+            }
+        }
+        ts.forEachChild(current, visit);
+    };
+    if (method.body) {
+        visit(method.body);
+    }
+    return found;
+};
+const isNullishPrimitive = (type) => type.kind === "primitiveType" &&
+    (type.name === "null" || type.name === "undefined");
+const normalizeExpectedFunctionType = (expectedType, ctx) => {
+    if (!expectedType)
+        return undefined;
+    if (expectedType.kind === "functionType")
+        return expectedType;
+    const delegated = ctx.typeSystem.delegateToFunctionType(expectedType);
+    if (delegated)
+        return delegated;
+    if (expectedType.kind !== "unionType")
+        return undefined;
+    const candidates = expectedType.types
+        .filter((member) => !!member && !isNullishPrimitive(member))
+        .map((member) => member.kind === "functionType"
+        ? member
+        : ctx.typeSystem.delegateToFunctionType(member))
+        .filter((member) => member !== undefined);
+    return candidates.length === 1 ? candidates[0] : undefined;
+};
+const getExpectedFunctionParameterTypes = (expectedType, ctx) => {
+    const fnType = normalizeExpectedFunctionType(expectedType, ctx);
+    return fnType?.parameters.map((param) => param.type);
+};
+const convertObjectLiteralMethodParameters = (parameters, ctx, expectedType) => {
+    const expectedParamTypes = getExpectedFunctionParameterTypes(expectedType, ctx);
+    return parameters.map((param, index) => {
+        const explicitType = param.type
+            ? ctx.typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(param.type))
+            : undefined;
+        const paramType = explicitType ?? expectedParamTypes?.[index];
+        return {
+            kind: "parameter",
+            pattern: convertBindingName(param.name, ctx),
+            type: paramType,
+            initializer: param.initializer
+                ? convertExpression(param.initializer, ctx, paramType)
+                : undefined,
+            isOptional: !!param.questionToken,
+            isRest: !!param.dotDotDotToken,
+            passing: "value",
+        };
+    });
+};
+const buildObjectLiteralMethodFunctionType = (method, ctx, expectedType) => {
+    const expectedFnType = normalizeExpectedFunctionType(expectedType, ctx);
+    const parameters = convertObjectLiteralMethodParameters(method.parameters, ctx, expectedFnType ?? expectedType);
+    const declaredReturnType = method.type
+        ? ctx.typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(method.type))
+        : undefined;
+    return {
+        kind: "functionType",
+        parameters,
+        returnType: declaredReturnType ??
+            expectedFnType?.returnType ?? { kind: "unknownType" },
+    };
+};
+const getSynthesizedPropertyType = (expr, widenNumericLiterals) => {
+    if (widenNumericLiterals &&
+        expr.kind === "literal" &&
+        typeof expr.value === "number") {
+        return { kind: "primitiveType", name: "number" };
+    }
+    return expr.inferredType;
+};
+const getProvisionalAccessorPropertyType = (getter, setter, expectedType, ctx) => {
+    const getterType = getter?.type
+        ? ctx.typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(getter.type))
+        : undefined;
+    const setterValueParam = setter?.parameters[0];
+    const setterType = setterValueParam?.type !== undefined
+        ? ctx.typeSystem.typeFromSyntax(ctx.binding.captureTypeSyntax(setterValueParam.type))
+        : undefined;
+    return getterType ?? setterType ?? expectedType;
+};
+const collectSynthesizedObjectMembers = (properties, pendingMethods, pendingAccessors, widenNumericLiterals) => {
+    const synthesizedMembers = [];
+    for (const prop of properties) {
+        if (prop.kind === "property") {
+            const keyName = typeof prop.key === "string"
+                ? prop.key
+                : prop.key.kind === "literal" && typeof prop.key.value === "string"
+                    ? prop.key.value
+                    : undefined;
+            if (!keyName) {
+                return {
+                    ok: false,
+                    failureReason: "Only identifier and computed string-literal keys are supported",
+                };
+            }
+            const propType = getSynthesizedPropertyType(prop.value, widenNumericLiterals);
+            if (!propType ||
+                propType.kind === "unknownType" ||
+                propType.kind === "anyType") {
+                return {
+                    ok: false,
+                    failureReason: `Property '${keyName}' type cannot be recovered deterministically`,
+                };
+            }
+            synthesizedMembers.push({
+                kind: "propertySignature",
+                name: keyName,
+                type: propType,
+                isOptional: false,
+                isReadonly: false,
+            });
+            continue;
+        }
+        const spreadType = prop.expression.inferredType;
+        if (spreadType?.kind !== "objectType") {
+            return {
+                ok: false,
+                failureReason: "Spread sources must have a deterministically known object literal shape",
+            };
+        }
+        for (const member of spreadType.members) {
+            if (member.kind === "propertySignature") {
+                synthesizedMembers.push(member);
+            }
+        }
+    }
+    for (const method of pendingMethods) {
+        synthesizedMembers.push({
+            kind: "propertySignature",
+            name: method.keyName,
+            type: method.functionType,
+            isOptional: false,
+            isReadonly: false,
+        });
+    }
+    for (const accessor of pendingAccessors) {
+        if (!accessor.propertyType) {
+            return {
+                ok: false,
+                failureReason: `Accessor '${accessor.memberName}' type cannot be recovered deterministically`,
+            };
+        }
+        synthesizedMembers.push({
+            kind: "propertySignature",
+            name: accessor.memberName,
+            type: accessor.propertyType,
+            isOptional: false,
+            isReadonly: false,
+        });
+    }
+    return { ok: true, members: synthesizedMembers };
+};
 /**
  * Convert object literal expression
  *
@@ -201,6 +529,9 @@ const getPropertyExpectedType = (propName, expectedType, ctx) => {
  */
 export const convertObjectLiteral = (node, ctx, expectedType) => {
     const properties = [];
+    const behaviorMembers = [];
+    const pendingMethods = [];
+    const accessorGroups = new Map();
     // Contextual type priority:
     // 1) expectedType threaded from the parent converter (return, assignment, parameter, etc.)
     // 2) AST-based contextual typing from explicit TypeNodes (getContextualType)
@@ -242,27 +573,18 @@ export const convertObjectLiteral = (node, ctx, expectedType) => {
         ts.isShorthandPropertyAssignment(p));
     const shouldLowerToDictionary = isObjectLikeContext && isPlainObjectLiteralAst;
     const dictionaryValueExpectedType = { kind: "unknownType" };
+    const getObjectLiteralPropertyExpectedType = (keyName) => keyName
+        ? (getPropertyExpectedType(keyName, expectedType, ctx) ??
+            (shouldLowerToDictionary ? dictionaryValueExpectedType : undefined))
+        : shouldLowerToDictionary
+            ? dictionaryValueExpectedType
+            : undefined;
     // Track if we have any spreads (needed for emitter IIFE lowering)
     let hasSpreads = false;
     node.properties.forEach((prop) => {
         if (ts.isPropertyAssignment(prop)) {
-            const keyName = ts.isIdentifier(prop.name)
-                ? prop.name.text
-                : ts.isStringLiteral(prop.name)
-                    ? prop.name.text
-                    : undefined;
-            const key = ts.isComputedPropertyName(prop.name)
-                ? convertExpression(prop.name.expression, ctx, undefined)
-                : ts.isIdentifier(prop.name)
-                    ? prop.name.text
-                    : String(prop.name.text);
-            // Look up property expected type from parent expected type
-            const propExpectedType = keyName
-                ? (getPropertyExpectedType(keyName, expectedType, ctx) ??
-                    (shouldLowerToDictionary ? dictionaryValueExpectedType : undefined))
-                : shouldLowerToDictionary
-                    ? dictionaryValueExpectedType
-                    : undefined;
+            const { key, keyName } = resolveObjectLiteralMemberKey(prop.name, ctx);
+            const propExpectedType = getObjectLiteralPropertyExpectedType(keyName);
             properties.push({
                 kind: "property",
                 key,
@@ -305,32 +627,44 @@ export const convertObjectLiteral = (node, ctx, expectedType) => {
             });
         }
         else if (ts.isMethodDeclaration(prop)) {
-            const keyName = ts.isIdentifier(prop.name)
-                ? prop.name.text
-                : ts.isStringLiteral(prop.name)
-                    ? prop.name.text
-                    : undefined;
-            const key = ts.isComputedPropertyName(prop.name)
-                ? convertExpression(prop.name.expression, ctx, undefined)
-                : ts.isIdentifier(prop.name)
-                    ? prop.name.text
-                    : String(prop.name.text);
-            const propExpectedType = keyName
-                ? (getPropertyExpectedType(keyName, expectedType, ctx) ??
-                    (shouldLowerToDictionary ? dictionaryValueExpectedType : undefined))
-                : shouldLowerToDictionary
-                    ? dictionaryValueExpectedType
-                    : undefined;
-            const methodModifiers = prop.modifiers?.filter(ts.isModifier);
-            const methodAsFunctionExpr = ts.setTextRange(ts.factory.createFunctionExpression(methodModifiers, prop.asteriskToken, undefined, prop.typeParameters, prop.parameters, prop.type, prop.body ?? ts.factory.createBlock([], true)), prop);
-            properties.push({
-                kind: "property",
+            const { key, keyName } = resolveObjectLiteralMemberKey(prop.name, ctx);
+            if (!keyName) {
+                ctx.diagnostics.push(createDiagnostic("TSN7403", "error", "Object literal cannot be synthesized: computed method key is not a deterministically known string/number literal", getSourceSpan(prop), "Use an identifier, string literal key, or explicit type annotation."));
+                return;
+            }
+            const propExpectedType = getObjectLiteralPropertyExpectedType(keyName);
+            pendingMethods.push({
                 key,
-                value: convertExpression(methodAsFunctionExpr, ctx, propExpectedType),
-                shorthand: false,
+                keyName,
+                node: prop,
+                propExpectedType,
+                capturesObjectLiteralThis: methodUsesObjectLiteralThis(prop),
+                functionType: buildObjectLiteralMethodFunctionType(prop, ctx, propExpectedType),
             });
         }
+        else if (ts.isGetAccessorDeclaration(prop) ||
+            ts.isSetAccessorDeclaration(prop)) {
+            const { keyName: memberName } = resolveObjectLiteralMemberKey(prop.name, ctx);
+            if (!memberName) {
+                ctx.diagnostics.push(createDiagnostic("TSN7403", "error", "Object literal cannot be synthesized: computed accessor key is not a deterministically known string/number literal", getSourceSpan(prop), "Use an identifier, string literal key, or explicit type annotation."));
+                return;
+            }
+            const existing = accessorGroups.get(memberName) ?? {};
+            if (ts.isGetAccessorDeclaration(prop)) {
+                existing.getter = prop;
+            }
+            else {
+                existing.setter = prop;
+            }
+            accessorGroups.set(memberName, existing);
+        }
     });
+    const pendingAccessors = Array.from(accessorGroups.entries()).map(([memberName, group]) => ({
+        memberName,
+        getter: group.getter,
+        setter: group.setter,
+        propertyType: getProvisionalAccessorPropertyType(group.getter, group.setter, getObjectLiteralPropertyExpectedType(memberName), ctx),
+    }));
     let contextualType = contextualCandidate;
     if (isObjectLikeContext) {
         contextualType = shouldLowerToDictionary
@@ -349,90 +683,60 @@ export const convertObjectLiteral = (node, ctx, expectedType) => {
             ctx.diagnostics.push(createDiagnostic("TSN7403", "error", `Object literal cannot be synthesized: ${eligibility.reason}`, getSourceSpan(node), "Use an explicit type annotation, or restructure to use only identifier keys, string literal keys, spread identifiers with type annotations, and function-valued properties."));
         }
         else {
-            // Extract property info from already-converted properties (AST-based)
-            const propInfos = [];
-            let canSynthesize = true;
-            let synthesisFailureReason;
-            for (const prop of properties) {
-                if (prop.kind === "property") {
-                    // Get property name (identifier or computed string-literal keys).
-                    const keyName = typeof prop.key === "string"
-                        ? prop.key
-                        : prop.key.kind === "literal" &&
-                            typeof prop.key.value === "string"
-                            ? prop.key.value
-                            : undefined;
-                    if (!keyName) {
-                        canSynthesize = false;
-                        synthesisFailureReason =
-                            "Only identifier and computed string-literal keys are supported";
-                        break;
-                    }
-                    // Get type from converted expression's inferredType
-                    const propType = prop.value.inferredType;
-                    if (!propType ||
-                        propType.kind === "unknownType" ||
-                        propType.kind === "anyType") {
-                        // Cannot synthesize if property type is unknown/any
-                        canSynthesize = false;
-                        synthesisFailureReason = `Property '${keyName}' type cannot be recovered deterministically`;
-                        break;
-                    }
-                    propInfos.push({
-                        name: keyName,
-                        type: propType,
-                        optional: false,
-                        readonly: false,
-                    });
-                }
-                else if (prop.kind === "spread") {
-                    // For spreads, merge properties from the spread source's objectType
-                    const spreadType = prop.expression.inferredType;
-                    if (spreadType?.kind === "objectType") {
-                        for (const member of spreadType.members) {
-                            if (member.kind === "propertySignature") {
-                                propInfos.push({
-                                    name: member.name,
-                                    type: member.type,
-                                    optional: member.isOptional,
-                                    readonly: member.isReadonly,
-                                });
-                            }
-                        }
-                    }
-                    else {
-                        canSynthesize = false;
-                        synthesisFailureReason =
-                            "Spread sources must have a deterministically known object literal shape";
-                        break;
-                    }
-                }
-            }
-            if (canSynthesize) {
-                // DETERMINISTIC: synthesize an objectType shape from the AST, then allow the
-                // anonymous-type-lowering pass to generate a nominal type (class) for emission.
+            const synthesized = collectSynthesizedObjectMembers(properties, pendingMethods, pendingAccessors, pendingAccessors.length > 0);
+            if (synthesized.ok && synthesized.members) {
                 contextualType = {
                     kind: "objectType",
-                    members: propInfos.map((p) => ({
-                        kind: "propertySignature",
-                        name: p.name,
-                        type: p.type,
-                        isOptional: p.optional,
-                        isReadonly: p.readonly,
-                    })),
+                    members: synthesized.members,
                 };
             }
             else {
-                ctx.diagnostics.push(createDiagnostic("TSN7403", "error", `Object literal cannot be synthesized: ${synthesisFailureReason ?? "not supported in this context"}`, getSourceSpan(node), "Use an explicit type annotation, or restructure to use only identifier keys, string literal keys, spread identifiers with type annotations, and function-valued properties."));
+                ctx.diagnostics.push(createDiagnostic("TSN7403", "error", `Object literal cannot be synthesized: ${synthesized.failureReason ?? "not supported in this context"}`, getSourceSpan(node), "Use an explicit type annotation, or restructure to use only identifier keys, string literal keys, spread identifiers with type annotations, and function-valued properties."));
             }
         }
     }
+    const objectLiteralThisType = contextualType && contextualType.kind !== "dictionaryType"
+        ? contextualType
+        : undefined;
+    const objectBehaviorContext = objectLiteralThisType
+        ? { ...ctx, objectLiteralThisType }
+        : ctx;
+    for (const pendingMethod of pendingMethods) {
+        const methodPrelude = createObjectLiteralMethodArgumentPrelude(pendingMethod.node);
+        const methodBody = pendingMethod.node.body
+            ? methodPrelude.length > 0
+                ? ts.factory.updateBlock(pendingMethod.node.body, [
+                    ...methodPrelude,
+                    ...pendingMethod.node.body.statements,
+                ])
+                : pendingMethod.node.body
+            : ts.factory.createBlock(methodPrelude, true);
+        const methodModifiers = pendingMethod.node.modifiers?.filter(ts.isModifier);
+        const methodAsFunctionExpr = ts.setTextRange(ts.factory.createFunctionExpression(methodModifiers, pendingMethod.node.asteriskToken, undefined, pendingMethod.node.typeParameters, pendingMethod.node.parameters, pendingMethod.node.type, methodBody), pendingMethod.node);
+        const convertedValue = convertExpression(methodAsFunctionExpr, objectBehaviorContext, pendingMethod.propExpectedType);
+        properties.push({
+            kind: "property",
+            key: pendingMethod.key,
+            value: convertedValue.kind === "functionExpression" &&
+                pendingMethod.capturesObjectLiteralThis
+                ? {
+                    ...convertedValue,
+                    capturesObjectLiteralThis: true,
+                }
+                : convertedValue,
+            shorthand: false,
+        });
+    }
+    for (const pendingAccessor of pendingAccessors) {
+        behaviorMembers.push(convertAccessorProperty(pendingAccessor.memberName, pendingAccessor.getter, pendingAccessor.setter, objectBehaviorContext, undefined));
+    }
     // DETERMINISTIC TYPING: Object's inferredType comes from contextualType
     // (which may be from LHS annotation or synthesized type).
     // We don't derive from properties because that would require TS inference.
     return {
         kind: "object",
         properties,
+        behaviorMembers: behaviorMembers.length > 0 ? behaviorMembers : undefined,
         inferredType: contextualType, // Use contextual type if available
         sourceSpan: getSourceSpan(node),
         contextualType,