@tsonic/emitter 0.0.74 → 0.0.75

package/dist/patterns.js

@@ -1,817 +1,11 @@
 /**
- * Pattern lowering (AST-only).
+ * Pattern lowering (AST-only) -- facade.
  *
  * 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";
-import { booleanLiteral, decimalIntegerLiteral, identifierExpression, identifierType, nullLiteral, parseNumericLiteral, stringLiteral, } from "./core/format/backend-ast/builders.js";
-const objectTypeAst = identifierType("object");
-const tupleElementMemberName = (index) => index < 7 ? `Item${index + 1}` : "Rest";
-const emitTupleElementAccessAst = (inputExpr, index) => {
-    if (index < 7) {
-        return {
-            kind: "memberAccessExpression",
-            expression: inputExpr,
-            memberName: tupleElementMemberName(index),
-        };
-    }
-    return emitTupleElementAccessAst({
-        kind: "memberAccessExpression",
-        expression: inputExpr,
-        memberName: "Rest",
-    }, index - 7);
-};
-const getTupleElementType = (tupleType, index) => {
-    const direct = tupleType.elementTypes[index];
-    if (direct)
-        return direct;
-    if (index < 7)
-        return undefined;
-    const rest = tupleType.elementTypes.slice(7);
-    if (rest.length === 0)
-        return undefined;
-    return getTupleElementType({
-        kind: "tupleType",
-        elementTypes: rest,
-    }, index - 7);
-};
-const getTupleRestArrayType = (tupleType, startIndex) => {
-    const remaining = tupleType.elementTypes.slice(startIndex);
-    if (remaining.length === 0) {
-        return {
-            kind: "arrayType",
-            elementType: { kind: "unknownType" },
-        };
-    }
-    const [first, ...rest] = remaining;
-    if (!first) {
-        return {
-            kind: "arrayType",
-            elementType: { kind: "unknownType" },
-        };
-    }
-    if (rest.length === 0) {
-        return { kind: "arrayType", elementType: first };
-    }
-    return {
-        kind: "arrayType",
-        elementType: {
-            kind: "unionType",
-            types: remaining.filter((item) => item !== undefined),
-        },
-    };
-};
-const emitTupleRestArrayAst = (inputExpr, tupleType, startIndex) => ({
-    kind: "arrayCreationExpression",
-    elementType: { kind: "varType" },
-    initializer: tupleType.elementTypes
-        .slice(startIndex)
-        .map((_, offset) => emitTupleElementAccessAst(inputExpr, startIndex + offset)),
-});
-const generateTemp = (prefix, ctx) => {
-    const tempId = ctx.tempVarId ?? 0;
-    const name = `__${prefix}${tempId}`;
-    return [name, { ...ctx, tempVarId: tempId + 1 }];
-};
-const emitDefaultExprAst = (expr, ctx) => {
-    if (expr.kind === "literal") {
-        if (typeof expr.value === "string") {
-            return [stringLiteral(expr.value), ctx];
-        }
-        if (typeof expr.value === "number") {
-            return [parseNumericLiteral(String(expr.value)), ctx];
-        }
-        if (typeof expr.value === "boolean") {
-            return [booleanLiteral(expr.value), ctx];
-        }
-        if (expr.value === null) {
-            return [nullLiteral(), 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;
-    let typeAst = { kind: "varType" };
-    if (type) {
-        const [emittedType, next] = emitTypeAst(type, currentCtx);
-        typeAst = emittedType;
-        currentCtx = next;
-    }
-    const stmt = {
-        kind: "localDeclarationStatement",
-        modifiers: [],
-        type: typeAst,
-        declarators: [{ name: localName, initializer: inputExpr }],
-    };
-    currentCtx = registerLocalName(name, localName, currentCtx);
-    return { statements: [stmt], context: currentCtx };
-};
-const lowerArrayPatternAst = (pattern, inputExpr, elementType, ctx) => {
-    const statements = [];
-    let currentCtx = ctx;
-    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) {
-            index++;
-            continue;
-        }
-        if (elem.isRest) {
-            const sliceExpr = {
-                kind: "invocationExpression",
-                expression: {
-                    kind: "memberAccessExpression",
-                    expression: identifierExpression("Tsonic.Runtime.ArrayHelpers"),
-                    memberName: "Slice",
-                },
-                arguments: [tempId, decimalIntegerLiteral(index)],
-            };
-            const rest = lowerPatternAst(elem.pattern, sliceExpr, elementType ? { kind: "arrayType", elementType } : undefined, currentCtx);
-            statements.push(...rest.statements);
-            currentCtx = rest.context;
-            break;
-        }
-        const accessExpr = {
-            kind: "elementAccessExpression",
-            expression: tempId,
-            arguments: [decimalIntegerLiteral(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 = lowerPatternAst(elem.pattern, valueExpr, elementType, currentCtx);
-        statements.push(...nested.statements);
-        currentCtx = nested.context;
-        index++;
-    }
-    return { statements, context: currentCtx };
-};
-const lowerTuplePatternAst = (pattern, inputExpr, tupleType, ctx) => {
-    const statements = [];
-    let currentCtx = ctx;
-    const [rawTempName, nextCtx] = generateTemp("tuple", 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,
-    };
-    let index = 0;
-    for (const elem of pattern.elements) {
-        if (!elem) {
-            index++;
-            continue;
-        }
-        if (elem.isRest) {
-            const restExpr = emitTupleRestArrayAst(tempExpr, tupleType, index);
-            const rest = lowerPatternAst(elem.pattern, restExpr, getTupleRestArrayType(tupleType, index), currentCtx);
-            statements.push(...rest.statements);
-            currentCtx = rest.context;
-            break;
-        }
-        const accessExpr = emitTupleElementAccessAst(tempExpr, 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 = lowerPatternAst(elem.pattern, valueExpr, getTupleElementType(tupleType, index), currentCtx);
-        statements.push(...nested.statements);
-        currentCtx = nested.context;
-        index++;
-    }
-    return { statements, context: currentCtx };
-};
-const lowerObjectPatternAst = (pattern, inputExpr, inputType, ctx) => {
-    const statements = [];
-    let currentCtx = ctx;
-    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") {
-            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: identifierType(prop.restSynthTypeName),
-                arguments: [],
-                initializer: initMembers,
-            };
-            const rest = lowerPatternAst(prop.pattern, restExpr, undefined, currentCtx);
-            statements.push(...rest.statements);
-            currentCtx = rest.context;
-            continue;
-        }
-        const propAccessExpr = {
-            kind: "memberAccessExpression",
-            expression: tempId,
-            memberName: prop.key,
-        };
-        let valueExpr = propAccessExpr;
-        if (prop.defaultExpr) {
-            const [defaultAst, defaultCtx] = emitDefaultExprAst(prop.defaultExpr, currentCtx);
-            currentCtx = defaultCtx;
-            valueExpr = {
-                kind: "binaryExpression",
-                operatorToken: "??",
-                left: propAccessExpr,
-                right: defaultAst,
-            };
-        }
-        const propType = getPropertyType(inputType, prop.key, currentCtx);
-        const nested = lowerPatternAst(prop.value, valueExpr, propType, currentCtx);
-        statements.push(...nested.statements);
-        currentCtx = nested.context;
-    }
-    return { statements, context: currentCtx };
-};
-export const lowerPatternAst = (pattern, inputExpr, type, ctx) => {
-    switch (pattern.kind) {
-        case "identifierPattern":
-            return lowerIdentifierAst(pattern.name, inputExpr, type, ctx);
-        case "arrayPattern": {
-            if (type?.kind === "tupleType") {
-                return lowerTuplePatternAst(pattern, inputExpr, type, ctx);
-            }
-            const elementType = type?.kind === "arrayType" ? type.elementType : undefined;
-            return lowerArrayPatternAst(pattern, inputExpr, elementType, ctx);
-        }
-        case "objectPattern":
-            return lowerObjectPatternAst(pattern, inputExpr, type, ctx);
-    }
-};
-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;
-    }
-    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 (elem.isRest) {
-            const restExpr = {
-                kind: "invocationExpression",
-                expression: {
-                    kind: "memberAccessExpression",
-                    expression: identifierExpression("Tsonic.Runtime.ArrayHelpers"),
-                    memberName: "Slice",
-                },
-                arguments: [tempExpr, decimalIntegerLiteral(index)],
-            };
-            const rest = lowerPatternToStaticMembersAst(elem.pattern, restExpr, elementType ? { kind: "arrayType", elementType } : undefined, currentCtx);
-            members.push(...rest.members);
-            currentCtx = rest.context;
-            break;
-        }
-        const accessExpr = {
-            kind: "elementAccessExpression",
-            expression: tempExpr,
-            arguments: [decimalIntegerLiteral(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 { members, context: currentCtx };
-};
-const lowerTuplePatternStaticAst = (pattern, inputExpr, tupleType, ctx) => {
-    const members = [];
-    let currentCtx = ctx;
-    const [rawTempName, nextCtx] = generateTemp("tuple", currentCtx);
-    currentCtx = nextCtx;
-    const tempName = emitCSharpName(rawTempName, "fields", currentCtx);
-    members.push(createStaticField(tempName, { kind: "varType" }, inputExpr));
-    const tempExpr = {
-        kind: "identifierExpression",
-        identifier: tempName,
-    };
-    let index = 0;
-    for (const elem of pattern.elements) {
-        if (!elem) {
-            index++;
-            continue;
-        }
-        if (elem.isRest) {
-            const restExpr = emitTupleRestArrayAst(tempExpr, tupleType, index);
-            const rest = lowerPatternToStaticMembersAst(elem.pattern, restExpr, getTupleRestArrayType(tupleType, index), currentCtx);
-            members.push(...rest.members);
-            currentCtx = rest.context;
-            break;
-        }
-        const accessExpr = emitTupleElementAccessAst(tempExpr, 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, getTupleElementType(tupleType, index), currentCtx);
-        members.push(...nested.members);
-        currentCtx = nested.context;
-        index++;
-    }
-    return { members, context: currentCtx };
-};
-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: identifierType(prop.restSynthTypeName),
-                arguments: [],
-                initializer: initMembers,
-            };
-            const rest = lowerPatternToStaticMembersAst(prop.pattern, restExpr, undefined, currentCtx);
-            members.push(...rest.members);
-            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(inputType, prop.key, currentCtx);
-        const nested = lowerPatternToStaticMembersAst(prop.value, valueExpr, propType, currentCtx);
-        members.push(...nested.members);
-        currentCtx = nested.context;
-    }
-    return { members, context: currentCtx };
-};
-export const lowerPatternToStaticMembersAst = (pattern, inputExpr, type, ctx) => {
-    switch (pattern.kind) {
-        case "identifierPattern":
-            return lowerIdentifierStaticAst(pattern.name, inputExpr, type, ctx);
-        case "arrayPattern": {
-            if (type?.kind === "tupleType") {
-                return lowerTuplePatternStaticAst(pattern, inputExpr, type, ctx);
-            }
-            const elementType = type?.kind === "arrayType" ? type.elementType : undefined;
-            return lowerArrayPatternStaticAst(pattern, inputExpr, elementType, type, ctx);
-        }
-        case "objectPattern":
-            return lowerObjectPatternStaticAst(pattern, inputExpr, type, 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);
-    }
-    return true;
-};
-const resolveAssignmentResultTypeAst = (type, ctx) => {
-    if (!type || !isRuntimeRepresentableType(type)) {
-        return [objectTypeAst, ctx];
-    }
-    return emitTypeAst(type, ctx);
-};
-const lowerAssignmentPatternStatementsAst = (pattern, inputExpr, type, ctx) => {
-    if (pattern.kind === "identifierPattern") {
-        return {
-            statements: [
-                {
-                    kind: "expressionStatement",
-                    expression: {
-                        kind: "assignmentExpression",
-                        operatorToken: "=",
-                        left: {
-                            kind: "identifierExpression",
-                            identifier: emitRemappedLocalName(pattern.name, ctx),
-                        },
-                        right: inputExpr,
-                    },
-                },
-            ],
-            context: ctx,
-        };
-    }
-    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") {
-        if (type?.kind === "tupleType") {
-            let index = 0;
-            for (const elem of pattern.elements) {
-                if (!elem) {
-                    index++;
-                    continue;
-                }
-                if (elem.isRest) {
-                    const restExpr = emitTupleRestArrayAst(tempExpr, type, index);
-                    const rest = lowerAssignmentPatternStatementsAst(elem.pattern, restExpr, getTupleRestArrayType(type, index), currentCtx);
-                    statements.push(...rest.statements);
-                    currentCtx = rest.context;
-                    break;
-                }
-                const accessExpr = emitTupleElementAccessAst(tempExpr, 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, getTupleElementType(type, index), currentCtx);
-                statements.push(...nested.statements);
-                currentCtx = nested.context;
-                index++;
-            }
-            return { statements, context: currentCtx };
-        }
-        const elementType = type?.kind === "arrayType" ? type.elementType : undefined;
-        let index = 0;
-        for (const elem of pattern.elements) {
-            if (!elem) {
-                index++;
-                continue;
-            }
-            if (elem.isRest) {
-                const restExpr = {
-                    kind: "invocationExpression",
-                    expression: {
-                        kind: "memberAccessExpression",
-                        expression: identifierExpression("Tsonic.Runtime.ArrayHelpers"),
-                        memberName: "Slice",
-                    },
-                    arguments: [tempExpr, decimalIntegerLiteral(index)],
-                };
-                const rest = lowerAssignmentPatternStatementsAst(elem.pattern, restExpr, elementType ? { kind: "arrayType", elementType } : undefined, currentCtx);
-                statements.push(...rest.statements);
-                currentCtx = rest.context;
-                break;
-            }
-            const accessExpr = {
-                kind: "elementAccessExpression",
-                expression: tempExpr,
-                arguments: [decimalIntegerLiteral(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 };
-    }
-    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: identifierType(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;
-    }
-    return { statements, context: currentCtx };
-};
-export const lowerAssignmentPatternAst = (pattern, rhsExpr, rhsType, ctx) => {
-    if (pattern.kind === "identifierPattern") {
-        return {
-            expression: {
-                kind: "assignmentExpression",
-                operatorToken: "=",
-                left: {
-                    kind: "identifierExpression",
-                    identifier: emitRemappedLocalName(pattern.name, ctx),
-                },
-                right: rhsExpr,
-            },
-            context: 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: identifierType("global::System.Func", [resultTypeAst]),
-                expression: {
-                    kind: "parenthesizedExpression",
-                    expression: {
-                        kind: "lambdaExpression",
-                        isAsync: false,
-                        parameters: [],
-                        body: { kind: "blockStatement", statements: lambdaStatements },
-                    },
-                },
-            },
-        },
-        arguments: [],
-    };
-    return { expression: iifeExpr, context: currentCtx };
-};
+export { lowerPatternAst } from "./patterns/local-lowering.js";
+export { lowerPatternToStaticMembersAst, lowerAssignmentPatternAst, } from "./patterns/static-assignment-lowering.js";
 //# sourceMappingURL=patterns.js.map