@tsonic/emitter 0.0.62 → 0.0.64

package/dist/patterns.js

@@ -1,408 +1,644 @@
 /**
- * Pattern Lowering Module
+ * Pattern lowering (AST-only).
  *
- * Transforms destructuring patterns into sequences of C# variable declarations.
- * This module is used by variable declarations, for-of loops, and function parameters.
- *
- * Example transformations:
- *
- * Array pattern:
- *   const [a, b, c] = arr;
- *   =>
- *   var __t0 = arr;
- *   var a = __t0[0];
- *   var b = __t0[1];
- *   var c = __t0[2];
- *
- * Array pattern with rest:
- *   const [first, ...rest] = arr;
- *   =>
- *   var __t0 = arr;
- *   var first = __t0[0];
- *   var rest = Tsonic.Runtime.ArrayHelpers.Slice(__t0, 1);
- *
- * Object pattern:
- *   const { name, age } = person;
- *   =>
- *   var __t0 = person;
- *   var name = __t0.name;
- *   var age = __t0.age;
- *
- * Object pattern with rest:
- *   const { name, ...rest } = person;
- *   =>
- *   var __t0 = person;
- *   var name = __t0.name;
- *   var rest = new __Rest_xxxx { age = __t0.age, email = __t0.email };
- */
-import { emitType } from "./types/emitter.js";
-import { escapeCSharpIdentifier } from "./emitter-types/identifiers.js";
-import { allocateLocalName, emitRemappedLocalName, registerLocalName, } from "./core/local-names.js";
-/**
- * Generate a unique temporary variable name
+ * Handles destructuring for:
+ * - local declarations
+ * - static/module-level field declarations
+ * - assignment expressions
  */
+import { emitTypeAst } from "./types/emitter.js";
+import { emitExpressionAst } from "./expression-emitter.js";
+import { emitCSharpName } from "./naming-policy.js";
+import { allocateLocalName, emitRemappedLocalName, registerLocalName, } from "./core/format/local-names.js";
+const objectTypeAst = { kind: "identifierType", name: "object" };
 const generateTemp = (prefix, ctx) => {
     const tempId = ctx.tempVarId ?? 0;
     const name = `__${prefix}${tempId}`;
-    const newCtx = { ...ctx, tempVarId: tempId + 1 };
-    return [name, newCtx];
+    return [name, { ...ctx, tempVarId: tempId + 1 }];
 };
-/**
- * Lower an identifier pattern to a simple variable declaration
- */
-const lowerIdentifier = (name, inputExpr, type, indent, ctx) => {
-    // In static context, we can't use 'var' - need explicit type with modifiers
-    if (ctx.isStatic) {
-        const escapedName = escapeCSharpIdentifier(name);
-        const typeStr = type ? emitType(type, ctx)[0] : "object";
-        const stmt = `${indent}private static readonly ${typeStr} ${escapedName} = ${inputExpr};`;
-        return { statements: [stmt], context: ctx };
+const emitDefaultExprAst = (expr, ctx) => {
+    if (expr.kind === "literal") {
+        if (typeof expr.value === "string") {
+            return [{ kind: "literalExpression", text: `"${expr.value}"` }, ctx];
+        }
+        if (typeof expr.value === "number") {
+            return [{ kind: "literalExpression", text: String(expr.value) }, ctx];
+        }
+        if (typeof expr.value === "boolean") {
+            return [
+                { kind: "literalExpression", text: expr.value ? "true" : "false" },
+                ctx,
+            ];
+        }
+        if (expr.value === null) {
+            return [{ kind: "literalExpression", text: "null" }, ctx];
+        }
+    }
+    if (expr.kind === "identifier") {
+        return [
+            {
+                kind: "identifierExpression",
+                identifier: emitRemappedLocalName(expr.name, ctx),
+            },
+            ctx,
+        ];
+    }
+    return emitExpressionAst(expr, ctx);
+};
+const getPropertyType = (type, key, ctx) => {
+    if (!type)
+        return undefined;
+    if (type.kind === "objectType") {
+        const prop = type.members.find((m) => m.kind === "propertySignature" && m.name === key);
+        return prop?.kind === "propertySignature" ? prop.type : undefined;
+    }
+    if (type.kind === "referenceType" && type.structuralMembers) {
+        const prop = type.structuralMembers.find((m) => m.kind === "propertySignature" && m.name === key);
+        return prop?.kind === "propertySignature" ? prop.type : undefined;
+    }
+    if (type.kind === "referenceType") {
+        const localType = ctx.localTypes?.get(type.name);
+        if (!localType)
+            return undefined;
+        if (localType.kind === "interface") {
+            const prop = localType.members.find((m) => m.kind === "propertySignature" && m.name === key);
+            return prop?.kind === "propertySignature" ? prop.type : undefined;
+        }
+        if (localType.kind === "class") {
+            const prop = localType.members.find((m) => m.kind === "propertyDeclaration" && m.name === key);
+            return prop?.kind === "propertyDeclaration" ? prop.type : undefined;
+        }
+        if (localType.kind === "typeAlias") {
+            return getPropertyType(localType.type, key, ctx);
+        }
     }
+    return undefined;
+};
+const lowerIdentifierAst = (name, inputExpr, type, ctx) => {
     const alloc = allocateLocalName(name, ctx);
     const localName = alloc.emittedName;
     let currentCtx = alloc.context;
-    // Local context: use var when type not available
-    let typeStr = "var";
+    let typeAst = { kind: "varType" };
     if (type) {
-        const [emittedType, next] = emitType(type, currentCtx);
-        typeStr = emittedType;
+        const [emittedType, next] = emitTypeAst(type, currentCtx);
+        typeAst = emittedType;
         currentCtx = next;
     }
-    const stmt = `${indent}${typeStr} ${localName} = ${inputExpr};`;
+    const stmt = {
+        kind: "localDeclarationStatement",
+        modifiers: [],
+        type: typeAst,
+        declarators: [{ name: localName, initializer: inputExpr }],
+    };
     currentCtx = registerLocalName(name, localName, currentCtx);
     return { statements: [stmt], context: currentCtx };
 };
-/**
- * Lower an array pattern to a sequence of indexed accesses
- */
-const lowerArrayPattern = (pattern, inputExpr, elementType, indent, ctx, arrayType) => {
+const lowerArrayPatternAst = (pattern, inputExpr, elementType, ctx) => {
     const statements = [];
     let currentCtx = ctx;
-    // Create temporary for the input to avoid re-evaluation
-    let [tempName, ctx1] = generateTemp("arr", currentCtx);
-    currentCtx = ctx1;
-    if (!ctx.isStatic) {
-        const alloc = allocateLocalName(tempName, currentCtx);
-        tempName = alloc.emittedName;
-        currentCtx = alloc.context;
-    }
-    // In static context, we can't use 'var' - need explicit type
-    if (ctx.isStatic && arrayType) {
-        const [typeStr, ctx2] = emitType(arrayType, currentCtx);
-        currentCtx = ctx2;
-        statements.push(`${indent}private static readonly ${typeStr} ${tempName} = ${inputExpr};`);
-    }
-    else if (ctx.isStatic) {
-        // Static without type - use object as fallback
-        statements.push(`${indent}private static readonly object ${tempName} = ${inputExpr};`);
-    }
-    else {
-        statements.push(`${indent}var ${tempName} = ${inputExpr};`);
-    }
-    // Process each element
+    const [rawTempName, nextCtx] = generateTemp("arr", currentCtx);
+    currentCtx = nextCtx;
+    const alloc = allocateLocalName(rawTempName, currentCtx);
+    const tempName = alloc.emittedName;
+    currentCtx = alloc.context;
+    statements.push({
+        kind: "localDeclarationStatement",
+        modifiers: [],
+        type: { kind: "varType" },
+        declarators: [{ name: tempName, initializer: inputExpr }],
+    });
+    const tempId = {
+        kind: "identifierExpression",
+        identifier: tempName,
+    };
     let index = 0;
     for (const elem of pattern.elements) {
         if (!elem) {
-            // Hole in pattern - skip this index
             index++;
             continue;
         }
         if (elem.isRest) {
-            // Rest element: use ArrayHelpers.Slice
-            const result = lowerPattern(elem.pattern, `Tsonic.Runtime.ArrayHelpers.Slice(${tempName}, ${index})`, elementType ? { kind: "arrayType", elementType } : undefined, indent, currentCtx);
-            statements.push(...result.statements);
-            currentCtx = result.context;
-            // Rest must be last, so break
+            const sliceExpr = {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: {
+                        kind: "identifierExpression",
+                        identifier: "Tsonic.Runtime.ArrayHelpers",
+                    },
+                    memberName: "Slice",
+                },
+                arguments: [tempId, { kind: "literalExpression", text: String(index) }],
+            };
+            const rest = lowerPatternAst(elem.pattern, sliceExpr, elementType ? { kind: "arrayType", elementType } : undefined, currentCtx);
+            statements.push(...rest.statements);
+            currentCtx = rest.context;
             break;
         }
-        // Regular element: index access
-        const accessExpr = `${tempName}[${index}]`;
-        // Handle default value
+        const accessExpr = {
+            kind: "elementAccessExpression",
+            expression: tempId,
+            arguments: [{ kind: "literalExpression", text: String(index) }],
+        };
         let valueExpr = accessExpr;
         if (elem.defaultExpr) {
-            // For nullable types: value ?? default
-            // For now, use simple null-coalescing (assumes nullable element type)
-            const defaultValue = emitDefaultExpr(elem.defaultExpr, currentCtx);
-            valueExpr = `${accessExpr} ?? ${defaultValue}`;
+            const [defaultAst, defaultCtx] = emitDefaultExprAst(elem.defaultExpr, currentCtx);
+            currentCtx = defaultCtx;
+            valueExpr = {
+                kind: "binaryExpression",
+                operatorToken: "??",
+                left: accessExpr,
+                right: defaultAst,
+            };
         }
-        const result = lowerPattern(elem.pattern, valueExpr, elementType, indent, currentCtx);
-        statements.push(...result.statements);
-        currentCtx = result.context;
+        const nested = lowerPatternAst(elem.pattern, valueExpr, elementType, currentCtx);
+        statements.push(...nested.statements);
+        currentCtx = nested.context;
         index++;
     }
     return { statements, context: currentCtx };
 };
-/**
- * Lower an object pattern to a sequence of property accesses
- */
-const lowerObjectPattern = (pattern, inputExpr, inputType, indent, ctx) => {
+const lowerObjectPatternAst = (pattern, inputExpr, inputType, ctx) => {
     const statements = [];
     let currentCtx = ctx;
-    // Create temporary for the input to avoid re-evaluation
-    let [tempName, ctx1] = generateTemp("obj", currentCtx);
-    currentCtx = ctx1;
-    if (!ctx.isStatic) {
-        const alloc = allocateLocalName(tempName, currentCtx);
-        tempName = alloc.emittedName;
-        currentCtx = alloc.context;
-    }
-    // In static context, we can't use 'var' - need explicit type with modifiers
-    if (ctx.isStatic && inputType) {
-        const [typeStr, ctx2] = emitType(inputType, currentCtx);
-        currentCtx = ctx2;
-        statements.push(`${indent}private static readonly ${typeStr} ${tempName} = ${inputExpr};`);
-    }
-    else if (ctx.isStatic) {
-        // Static without type - use object as fallback
-        statements.push(`${indent}private static readonly object ${tempName} = ${inputExpr};`);
-    }
-    else {
-        statements.push(`${indent}var ${tempName} = ${inputExpr};`);
-    }
-    // Process each property
+    const [rawTempName, nextCtx] = generateTemp("obj", currentCtx);
+    currentCtx = nextCtx;
+    const alloc = allocateLocalName(rawTempName, currentCtx);
+    const tempName = alloc.emittedName;
+    currentCtx = alloc.context;
+    statements.push({
+        kind: "localDeclarationStatement",
+        modifiers: [],
+        type: { kind: "varType" },
+        declarators: [{ name: tempName, initializer: inputExpr }],
+    });
+    const tempId = {
+        kind: "identifierExpression",
+        identifier: tempName,
+    };
     for (const prop of pattern.properties) {
         if (prop.kind === "rest") {
-            // Rest property: create new synthetic object with remaining props
-            if (prop.restShapeMembers && prop.restSynthTypeName) {
-                // Generate object initializer for rest
-                const initProps = prop.restShapeMembers
-                    .filter((m) => m.kind === "propertySignature")
-                    .map((m) => `${m.name} = ${tempName}.${m.name}`)
-                    .join(", ");
-                const restExpr = `new ${prop.restSynthTypeName} { ${initProps} }`;
-                const result = lowerPattern(prop.pattern, restExpr, undefined, // Type is the synthetic type
-                indent, currentCtx);
-                statements.push(...result.statements);
-                currentCtx = result.context;
-            }
-            else {
+            if (!prop.restShapeMembers || !prop.restSynthTypeName) {
                 throw new Error("Object rest destructuring requires rest shape information from the frontend (restShapeMembers/restSynthTypeName).");
             }
+            const initMembers = prop.restShapeMembers
+                .filter((m) => m.kind === "propertySignature")
+                .map((m) => ({
+                kind: "assignmentExpression",
+                operatorToken: "=",
+                left: {
+                    kind: "identifierExpression",
+                    identifier: m.name,
+                },
+                right: {
+                    kind: "memberAccessExpression",
+                    expression: tempId,
+                    memberName: m.name,
+                },
+            }));
+            const restExpr = {
+                kind: "objectCreationExpression",
+                type: { kind: "identifierType", name: prop.restSynthTypeName },
+                arguments: [],
+                initializer: initMembers,
+            };
+            const rest = lowerPatternAst(prop.pattern, restExpr, undefined, currentCtx);
+            statements.push(...rest.statements);
+            currentCtx = rest.context;
             continue;
         }
-        // Regular property
-        const propAccessExpr = `${tempName}.${prop.key}`;
-        // Handle default value
+        const propAccessExpr = {
+            kind: "memberAccessExpression",
+            expression: tempId,
+            memberName: prop.key,
+        };
         let valueExpr = propAccessExpr;
         if (prop.defaultExpr) {
-            const defaultValue = emitDefaultExpr(prop.defaultExpr, currentCtx);
-            valueExpr = `${propAccessExpr} ?? ${defaultValue}`;
+            const [defaultAst, defaultCtx] = emitDefaultExprAst(prop.defaultExpr, currentCtx);
+            currentCtx = defaultCtx;
+            valueExpr = {
+                kind: "binaryExpression",
+                operatorToken: "??",
+                left: propAccessExpr,
+                right: defaultAst,
+            };
         }
-        // Get property type if available
         const propType = getPropertyType(inputType, prop.key, currentCtx);
-        const result = lowerPattern(prop.value, valueExpr, propType, indent, currentCtx);
-        statements.push(...result.statements);
-        currentCtx = result.context;
+        const nested = lowerPatternAst(prop.value, valueExpr, propType, currentCtx);
+        statements.push(...nested.statements);
+        currentCtx = nested.context;
     }
     return { statements, context: currentCtx };
 };
-/**
- * Get property type from an object/interface type
- */
-const getPropertyType = (type, key, ctx) => {
-    if (!type)
-        return undefined;
-    if (type.kind === "objectType") {
-        const prop = type.members.find((m) => m.kind === "propertySignature" && m.name === key);
-        if (prop && prop.kind === "propertySignature") {
-            return prop.type;
+export const lowerPatternAst = (pattern, inputExpr, type, ctx) => {
+    switch (pattern.kind) {
+        case "identifierPattern":
+            return lowerIdentifierAst(pattern.name, inputExpr, type, ctx);
+        case "arrayPattern": {
+            const elementType = type?.kind === "arrayType" ? type.elementType : undefined;
+            return lowerArrayPatternAst(pattern, inputExpr, elementType, ctx);
         }
+        case "objectPattern":
+            return lowerObjectPatternAst(pattern, inputExpr, type, ctx);
     }
-    if (type.kind === "referenceType" && type.structuralMembers) {
-        const prop = type.structuralMembers.find((m) => m.kind === "propertySignature" && m.name === key);
-        if (prop && prop.kind === "propertySignature") {
-            return prop.type;
-        }
+};
+const createStaticField = (name, type, initializer) => ({
+    kind: "fieldDeclaration",
+    attributes: [],
+    modifiers: ["private", "static", "readonly"],
+    type,
+    name,
+    initializer,
+});
+const lowerIdentifierStaticAst = (name, inputExpr, type, ctx) => {
+    let currentCtx = ctx;
+    let typeAst = objectTypeAst;
+    if (type) {
+        const [emittedType, next] = emitTypeAst(type, currentCtx);
+        typeAst = emittedType;
+        currentCtx = next;
     }
-    if (type.kind === "referenceType") {
-        const localType = ctx.localTypes?.get(type.name);
-        if (!localType)
-            return undefined;
-        if (localType.kind === "interface") {
-            const prop = localType.members.find((m) => m.kind === "propertySignature" && m.name === key);
-            if (prop && prop.kind === "propertySignature") {
-                return prop.type;
-            }
-            return undefined;
+    return {
+        members: [
+            createStaticField(emitCSharpName(name, "fields", ctx), typeAst, inputExpr),
+        ],
+        context: currentCtx,
+    };
+};
+const lowerArrayPatternStaticAst = (pattern, inputExpr, elementType, arrayType, ctx) => {
+    const members = [];
+    let currentCtx = ctx;
+    const [rawTempName, nextCtx] = generateTemp("arr", currentCtx);
+    currentCtx = nextCtx;
+    const tempName = emitCSharpName(rawTempName, "fields", currentCtx);
+    let tempTypeAst = objectTypeAst;
+    if (arrayType) {
+        const [emittedType, typeCtx] = emitTypeAst(arrayType, currentCtx);
+        tempTypeAst = emittedType;
+        currentCtx = typeCtx;
+    }
+    members.push(createStaticField(tempName, tempTypeAst, inputExpr));
+    const tempExpr = {
+        kind: "identifierExpression",
+        identifier: tempName,
+    };
+    let index = 0;
+    for (const elem of pattern.elements) {
+        if (!elem) {
+            index++;
+            continue;
         }
-        if (localType.kind === "class") {
-            const prop = localType.members.find((m) => m.kind === "propertyDeclaration" && m.name === key);
-            if (prop && prop.kind === "propertyDeclaration") {
-                return prop.type;
-            }
-            return undefined;
+        if (elem.isRest) {
+            const restExpr = {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: {
+                        kind: "identifierExpression",
+                        identifier: "Tsonic.Runtime.ArrayHelpers",
+                    },
+                    memberName: "Slice",
+                },
+                arguments: [
+                    tempExpr,
+                    { kind: "literalExpression", text: String(index) },
+                ],
+            };
+            const rest = lowerPatternToStaticMembersAst(elem.pattern, restExpr, elementType ? { kind: "arrayType", elementType } : undefined, currentCtx);
+            members.push(...rest.members);
+            currentCtx = rest.context;
+            break;
         }
-        if (localType.kind === "typeAlias") {
-            return getPropertyType(localType.type, key, ctx);
+        const accessExpr = {
+            kind: "elementAccessExpression",
+            expression: tempExpr,
+            arguments: [{ kind: "literalExpression", text: String(index) }],
+        };
+        let valueExpr = accessExpr;
+        if (elem.defaultExpr) {
+            const [defaultAst, defaultCtx] = emitDefaultExprAst(elem.defaultExpr, currentCtx);
+            currentCtx = defaultCtx;
+            valueExpr = {
+                kind: "binaryExpression",
+                operatorToken: "??",
+                left: accessExpr,
+                right: defaultAst,
+            };
         }
+        const nested = lowerPatternToStaticMembersAst(elem.pattern, valueExpr, elementType, currentCtx);
+        members.push(...nested.members);
+        currentCtx = nested.context;
+        index++;
     }
-    return undefined;
+    return { members, context: currentCtx };
 };
-/**
- * Emit a default expression (simplified - just literals for now)
- */
-const emitDefaultExpr = (expr, ctx) => {
-    // Simplified default expression emission
-    if (expr.kind === "literal") {
-        if (typeof expr.value === "string") {
-            return `"${expr.value}"`;
-        }
-        if (typeof expr.value === "number") {
-            return String(expr.value);
-        }
-        if (typeof expr.value === "boolean") {
-            return expr.value ? "true" : "false";
+const lowerObjectPatternStaticAst = (pattern, inputExpr, inputType, ctx) => {
+    const members = [];
+    let currentCtx = ctx;
+    const [rawTempName, nextCtx] = generateTemp("obj", currentCtx);
+    currentCtx = nextCtx;
+    const tempName = emitCSharpName(rawTempName, "fields", currentCtx);
+    let tempTypeAst = objectTypeAst;
+    if (inputType) {
+        const [emittedType, typeCtx] = emitTypeAst(inputType, currentCtx);
+        tempTypeAst = emittedType;
+        currentCtx = typeCtx;
+    }
+    members.push(createStaticField(tempName, tempTypeAst, inputExpr));
+    const tempExpr = {
+        kind: "identifierExpression",
+        identifier: tempName,
+    };
+    for (const prop of pattern.properties) {
+        if (prop.kind === "rest") {
+            if (!prop.restShapeMembers || !prop.restSynthTypeName) {
+                throw new Error("Object rest destructuring requires rest shape information from the frontend (restShapeMembers/restSynthTypeName).");
+            }
+            const initMembers = prop.restShapeMembers
+                .filter((m) => m.kind === "propertySignature")
+                .map((m) => ({
+                kind: "assignmentExpression",
+                operatorToken: "=",
+                left: {
+                    kind: "identifierExpression",
+                    identifier: m.name,
+                },
+                right: {
+                    kind: "memberAccessExpression",
+                    expression: tempExpr,
+                    memberName: m.name,
+                },
+            }));
+            const restExpr = {
+                kind: "objectCreationExpression",
+                type: { kind: "identifierType", name: prop.restSynthTypeName },
+                arguments: [],
+                initializer: initMembers,
+            };
+            const rest = lowerPatternToStaticMembersAst(prop.pattern, restExpr, undefined, currentCtx);
+            members.push(...rest.members);
+            currentCtx = rest.context;
+            continue;
         }
-        if (expr.value === null) {
-            return "null";
+        const accessExpr = {
+            kind: "memberAccessExpression",
+            expression: tempExpr,
+            memberName: prop.key,
+        };
+        let valueExpr = accessExpr;
+        if (prop.defaultExpr) {
+            const [defaultAst, defaultCtx] = emitDefaultExprAst(prop.defaultExpr, currentCtx);
+            currentCtx = defaultCtx;
+            valueExpr = {
+                kind: "binaryExpression",
+                operatorToken: "??",
+                left: accessExpr,
+                right: defaultAst,
+            };
         }
+        const propType = getPropertyType(inputType, prop.key, currentCtx);
+        const nested = lowerPatternToStaticMembersAst(prop.value, valueExpr, propType, currentCtx);
+        members.push(...nested.members);
+        currentCtx = nested.context;
     }
-    if (expr.kind === "identifier") {
-        return emitRemappedLocalName(expr.name, ctx);
-    }
-    throw new Error(`Unsupported destructuring default expression kind '${expr.kind}'. ` +
-        "Only literals and identifiers are supported (airplane-grade: no silent placeholder emission).");
+    return { members, context: currentCtx };
 };
-/**
- * Lower a pattern to a sequence of C# statements
- *
- * @param pattern - The pattern to lower (identifier, array, or object)
- * @param inputExpr - The C# expression being destructured
- * @param type - The type of the input expression (for type annotations)
- * @param indent - Indentation prefix for generated code
- * @param ctx - The current emitter context
- * @returns The generated statements and updated context
- */
-export const lowerPattern = (pattern, inputExpr, type, indent, ctx) => {
+export const lowerPatternToStaticMembersAst = (pattern, inputExpr, type, ctx) => {
     switch (pattern.kind) {
         case "identifierPattern":
-            return lowerIdentifier(pattern.name, inputExpr, type, indent, ctx);
+            return lowerIdentifierStaticAst(pattern.name, inputExpr, type, ctx);
         case "arrayPattern": {
-            // Get element type from array type, and pass full array type for static context
             const elementType = type?.kind === "arrayType" ? type.elementType : undefined;
-            return lowerArrayPattern(pattern, inputExpr, elementType, indent, ctx, type);
+            return lowerArrayPatternStaticAst(pattern, inputExpr, elementType, type, ctx);
         }
         case "objectPattern":
-            return lowerObjectPattern(pattern, inputExpr, type, indent, ctx);
-        default:
-            // Unknown pattern kind
-            return {
-                statements: [`${indent}// Unsupported pattern kind`],
-                context: ctx,
-            };
+            return lowerObjectPatternStaticAst(pattern, inputExpr, type, ctx);
     }
 };
-/**
- * Lower a pattern for a for-of loop variable
- * Similar to lowerPattern but handles the iteration context
- */
-export const lowerForOfPattern = (pattern, iteratorVar, elementType, indent, ctx) => {
-    // For simple identifier patterns, no lowering needed
-    if (pattern.kind === "identifierPattern") {
-        // The for-of loop itself declares the variable
-        return { statements: [], context: ctx };
+const isRuntimeRepresentableType = (type) => {
+    if (type.kind === "anyType" || type.kind === "unknownType")
+        return false;
+    if (type.kind === "objectType")
+        return false;
+    if (type.kind === "unionType") {
+        return type.types.every(isRuntimeRepresentableType);
     }
-    // For complex patterns, lower to statements inside the loop body
-    return lowerPattern(pattern, iteratorVar, elementType, indent, ctx);
+    return true;
 };
-/**
- * Lower a parameter pattern for function definitions
- * Generates statements to go at the beginning of the function body
- */
-export const lowerParameterPattern = (pattern, paramName, paramType, indent, ctx) => {
-    // For simple identifier patterns, no lowering needed
-    if (pattern.kind === "identifierPattern") {
-        return { statements: [], context: ctx };
+const resolveAssignmentResultTypeAst = (type, ctx) => {
+    if (!type || !isRuntimeRepresentableType(type)) {
+        return [objectTypeAst, ctx];
     }
-    // For complex patterns, generate statements to destructure the synthetic param
-    return lowerPattern(pattern, paramName, paramType, indent, ctx);
+    return emitTypeAst(type, ctx);
 };
-/**
- * Lower an assignment pattern to a C# expression
- *
- * In JavaScript, destructuring assignment is an expression that returns the RHS:
- *   const result = ([a, b] = arr);  // result === arr
- *
- * We emit this as a parenthesized sequence expression:
- *   ((__t = rhs), (a = __t[0]), (b = __t[1]), __t)
- *
- * @param pattern - The pattern being assigned to
- * @param rhsExpr - The C# expression for the right-hand side
- * @param type - The type of the RHS expression
- * @param ctx - The current emitter context
- * @returns The expression and updated context
- */
-export const lowerAssignmentPattern = (pattern, rhsExpr, type, ctx) => {
-    // For identifier pattern, just emit simple assignment
+const lowerAssignmentPatternStatementsAst = (pattern, inputExpr, type, ctx) => {
     if (pattern.kind === "identifierPattern") {
-        const escapedName = emitRemappedLocalName(pattern.name, ctx);
         return {
-            expression: `${escapedName} = ${rhsExpr}`,
+            statements: [
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "assignmentExpression",
+                        operatorToken: "=",
+                        left: {
+                            kind: "identifierExpression",
+                            identifier: emitRemappedLocalName(pattern.name, ctx),
+                        },
+                        right: inputExpr,
+                    },
+                },
+            ],
             context: ctx,
         };
     }
-    // For complex patterns, generate sequence expression
-    const [tempName, ctx1] = generateTemp("t", ctx);
-    let currentCtx = ctx1;
-    // Collect assignment expressions
-    const assignments = [];
+    let currentCtx = ctx;
+    const statements = [];
+    const [rawTempName, nextCtx] = generateTemp("t", currentCtx);
+    currentCtx = nextCtx;
+    const alloc = allocateLocalName(rawTempName, currentCtx);
+    const tempName = alloc.emittedName;
+    currentCtx = alloc.context;
+    statements.push({
+        kind: "localDeclarationStatement",
+        modifiers: [],
+        type: { kind: "varType" },
+        declarators: [{ name: tempName, initializer: inputExpr }],
+    });
+    const tempExpr = {
+        kind: "identifierExpression",
+        identifier: tempName,
+    };
     if (pattern.kind === "arrayPattern") {
         const elementType = type?.kind === "arrayType" ? type.elementType : undefined;
         let index = 0;
         for (const elem of pattern.elements) {
             if (!elem) {
-                // Hole in pattern - skip
                 index++;
                 continue;
             }
             if (elem.isRest) {
-                // Rest element
-                const result = lowerAssignmentPatternElement(elem.pattern, `Tsonic.Runtime.ArrayHelpers.Slice(${tempName}, ${index})`, elementType ? { kind: "arrayType", elementType } : undefined, currentCtx);
-                assignments.push(result.expression);
-                currentCtx = result.context;
+                const restExpr = {
+                    kind: "invocationExpression",
+                    expression: {
+                        kind: "memberAccessExpression",
+                        expression: {
+                            kind: "identifierExpression",
+                            identifier: "Tsonic.Runtime.ArrayHelpers",
+                        },
+                        memberName: "Slice",
+                    },
+                    arguments: [
+                        tempExpr,
+                        { kind: "literalExpression", text: String(index) },
+                    ],
+                };
+                const rest = lowerAssignmentPatternStatementsAst(elem.pattern, restExpr, elementType ? { kind: "arrayType", elementType } : undefined, currentCtx);
+                statements.push(...rest.statements);
+                currentCtx = rest.context;
                 break;
             }
-            // Regular element
-            const result = lowerAssignmentPatternElement(elem.pattern, `${tempName}[${index}]`, elementType, currentCtx);
-            assignments.push(result.expression);
-            currentCtx = result.context;
+            const accessExpr = {
+                kind: "elementAccessExpression",
+                expression: tempExpr,
+                arguments: [{ kind: "literalExpression", text: String(index) }],
+            };
+            let valueExpr = accessExpr;
+            if (elem.defaultExpr) {
+                const [defaultAst, defaultCtx] = emitDefaultExprAst(elem.defaultExpr, currentCtx);
+                currentCtx = defaultCtx;
+                valueExpr = {
+                    kind: "binaryExpression",
+                    operatorToken: "??",
+                    left: accessExpr,
+                    right: defaultAst,
+                };
+            }
+            const nested = lowerAssignmentPatternStatementsAst(elem.pattern, valueExpr, elementType, currentCtx);
+            statements.push(...nested.statements);
+            currentCtx = nested.context;
             index++;
         }
+        return { statements, context: currentCtx };
     }
-    else if (pattern.kind === "objectPattern") {
-        for (const prop of pattern.properties) {
-            if (prop.kind === "rest") {
-                // Rest property - would need synthetic type
-                if (prop.pattern.kind === "identifierPattern") {
-                    const escapedName = emitRemappedLocalName(prop.pattern.name, currentCtx);
-                    assignments.push(`/* ${escapedName} = rest of ${tempName} - needs synthetic type */`);
-                }
-                continue;
+    for (const prop of pattern.properties) {
+        if (prop.kind === "rest") {
+            if (!prop.restShapeMembers || !prop.restSynthTypeName) {
+                throw new Error("Object rest destructuring requires rest shape information from the frontend (restShapeMembers/restSynthTypeName).");
             }
-            // Regular property
-            const propType = getPropertyType(type, prop.key, currentCtx);
-            const result = lowerAssignmentPatternElement(prop.value, `${tempName}.${prop.key}`, propType, currentCtx);
-            assignments.push(result.expression);
-            currentCtx = result.context;
+            const initMembers = prop.restShapeMembers
+                .filter((m) => m.kind === "propertySignature")
+                .map((m) => ({
+                kind: "assignmentExpression",
+                operatorToken: "=",
+                left: {
+                    kind: "identifierExpression",
+                    identifier: m.name,
+                },
+                right: {
+                    kind: "memberAccessExpression",
+                    expression: tempExpr,
+                    memberName: m.name,
+                },
+            }));
+            const restExpr = {
+                kind: "objectCreationExpression",
+                type: { kind: "identifierType", name: prop.restSynthTypeName },
+                arguments: [],
+                initializer: initMembers,
+            };
+            const rest = lowerAssignmentPatternStatementsAst(prop.pattern, restExpr, undefined, currentCtx);
+            statements.push(...rest.statements);
+            currentCtx = rest.context;
+            continue;
+        }
+        const accessExpr = {
+            kind: "memberAccessExpression",
+            expression: tempExpr,
+            memberName: prop.key,
+        };
+        let valueExpr = accessExpr;
+        if (prop.defaultExpr) {
+            const [defaultAst, defaultCtx] = emitDefaultExprAst(prop.defaultExpr, currentCtx);
+            currentCtx = defaultCtx;
+            valueExpr = {
+                kind: "binaryExpression",
+                operatorToken: "??",
+                left: accessExpr,
+                right: defaultAst,
+            };
         }
+        const propType = getPropertyType(type, prop.key, currentCtx);
+        const nested = lowerAssignmentPatternStatementsAst(prop.value, valueExpr, propType, currentCtx);
+        statements.push(...nested.statements);
+        currentCtx = nested.context;
     }
-    // Build sequence expression: (__t = rhs, a = __t[0], ..., __t)
-    const allParts = [`${tempName} = ${rhsExpr}`, ...assignments, tempName];
-    const expression = `(${allParts.join(", ")})`;
-    return { expression, context: currentCtx };
+    return { statements, context: currentCtx };
 };
-/**
- * Helper to lower a single element/property in an assignment pattern
- */
-const lowerAssignmentPatternElement = (pattern, inputExpr, type, ctx) => {
+export const lowerAssignmentPatternAst = (pattern, rhsExpr, rhsType, ctx) => {
     if (pattern.kind === "identifierPattern") {
-        const escapedName = emitRemappedLocalName(pattern.name, ctx);
         return {
-            expression: `${escapedName} = ${inputExpr}`,
+            expression: {
+                kind: "assignmentExpression",
+                operatorToken: "=",
+                left: {
+                    kind: "identifierExpression",
+                    identifier: emitRemappedLocalName(pattern.name, ctx),
+                },
+                right: rhsExpr,
+            },
             context: ctx,
         };
     }
-    // Nested pattern - recurse
-    return lowerAssignmentPattern(pattern, inputExpr, type, ctx);
+    let currentCtx = ctx;
+    const [resultTypeAst, typeCtx] = resolveAssignmentResultTypeAst(rhsType, currentCtx);
+    currentCtx = typeCtx;
+    const [rawResultName, nextCtx] = generateTemp("assign", currentCtx);
+    currentCtx = nextCtx;
+    const alloc = allocateLocalName(rawResultName, currentCtx);
+    const resultName = alloc.emittedName;
+    currentCtx = alloc.context;
+    const nested = lowerAssignmentPatternStatementsAst(pattern, {
+        kind: "identifierExpression",
+        identifier: resultName,
+    }, rhsType, currentCtx);
+    currentCtx = nested.context;
+    const lambdaStatements = [
+        {
+            kind: "localDeclarationStatement",
+            modifiers: [],
+            type: resultTypeAst,
+            declarators: [{ name: resultName, initializer: rhsExpr }],
+        },
+        ...nested.statements,
+        {
+            kind: "returnStatement",
+            expression: { kind: "identifierExpression", identifier: resultName },
+        },
+    ];
+    const iifeExpr = {
+        kind: "invocationExpression",
+        expression: {
+            kind: "parenthesizedExpression",
+            expression: {
+                kind: "castExpression",
+                type: {
+                    kind: "identifierType",
+                    name: "global::System.Func",
+                    typeArguments: [resultTypeAst],
+                },
+                expression: {
+                    kind: "parenthesizedExpression",
+                    expression: {
+                        kind: "lambdaExpression",
+                        isAsync: false,
+                        parameters: [],
+                        body: { kind: "blockStatement", statements: lambdaStatements },
+                    },
+                },
+            },
+        },
+        arguments: [],
+    };
+    return { expression: iifeExpr, context: currentCtx };
 };
 //# sourceMappingURL=patterns.js.map