@tsonic/frontend 0.0.11 → 0.0.13

package/dist/ir/validation/anonymous-type-lowering-pass.js

@@ -0,0 +1,854 @@
+/**
+ * Anonymous Object Type Lowering Pass
+ *
+ * Transforms anonymous object types (IrObjectType) in type positions into
+ * generated named types (IrReferenceType) with synthetic interface declarations.
+ *
+ * This pass runs BEFORE soundness validation to ensure the emitter never
+ * receives IrObjectType nodes.
+ *
+ * Example transformation:
+ * ```
+ * const config: { value: number } = { value: 42 };
+ * ```
+ * becomes:
+ * ```
+ * interface __Anon_abc123 { value: number }
+ * const config: __Anon_abc123 = { value: 42 };
+ * ```
+ */
+import { createHash } from "crypto";
+/**
+ * Serialize an IrType to a stable string for shape signature
+ */
+const serializeType = (type) => {
+    switch (type.kind) {
+        case "primitiveType":
+            return type.name;
+        case "literalType":
+            return `lit:${typeof type.value}:${String(type.value)}`;
+        case "referenceType":
+            if (type.typeArguments && type.typeArguments.length > 0) {
+                return `ref:${type.name}<${type.typeArguments.map(serializeType).join(",")}>`;
+            }
+            return `ref:${type.name}`;
+        case "arrayType":
+            return `arr:${serializeType(type.elementType)}`;
+        case "tupleType":
+            return `tup:[${type.elementTypes.map(serializeType).join(",")}]`;
+        case "functionType": {
+            const params = type.parameters
+                .map((p) => (p.type ? serializeType(p.type) : "any"))
+                .join(",");
+            return `fn:(${params})=>${serializeType(type.returnType)}`;
+        }
+        case "unionType":
+            return `union:[${type.types.map(serializeType).join("|")}]`;
+        case "typeParameterType":
+            return `tp:${type.name}`;
+        case "voidType":
+            return "void";
+        case "anyType":
+            return "any";
+        case "unknownType":
+            return "unknown";
+        case "neverType":
+            return "never";
+        case "objectType": {
+            // Serialize property signatures
+            const propMembers = type.members
+                .filter((m) => m.kind === "propertySignature")
+                .map((m) => `prop:${m.isReadonly ? "ro:" : ""}${m.name}${m.isOptional ? "?" : ""}:${serializeType(m.type)}`);
+            // Serialize method signatures
+            const methodMembers = type.members
+                .filter((m) => m.kind === "methodSignature")
+                .map((m) => {
+                const params = m.parameters
+                    .map((p) => (p.type ? serializeType(p.type) : "any"))
+                    .join(",");
+                const ret = m.returnType ? serializeType(m.returnType) : "void";
+                return `method:${m.name}(${params})=>${ret}`;
+            });
+            const allMembers = [...propMembers, ...methodMembers].sort().join(";");
+            return `obj:{${allMembers}}`;
+        }
+        case "dictionaryType":
+            return `dict:[${serializeType(type.keyType)}]:${serializeType(type.valueType)}`;
+        case "intersectionType":
+            return `intersection:[${type.types.map(serializeType).join("&")}]`;
+        default:
+            return "unknown";
+    }
+};
+/**
+ * Compute shape signature for an objectType
+ */
+const computeShapeSignature = (objectType) => {
+    return serializeType(objectType);
+};
+/**
+ * Generate a short hash from shape signature
+ */
+const generateShapeHash = (signature) => {
+    return createHash("md5").update(signature).digest("hex").slice(0, 8);
+};
+/**
+ * Convert interface members to class property declarations
+ */
+const interfaceMembersToClassMembers = (members) => {
+    return members
+        .filter((m) => m.kind === "propertySignature")
+        .map((m) => {
+        // For optional properties (title?: string), make type nullable and don't require
+        // For required properties (title: string), use required modifier
+        const isOptional = m.isOptional ?? false;
+        return {
+            kind: "propertyDeclaration",
+            name: m.name,
+            type: m.type,
+            initializer: undefined,
+            isStatic: false,
+            isReadonly: m.isReadonly ?? false,
+            accessibility: "public",
+            isRequired: !isOptional, // C# 11 required modifier - must be set in object initializer
+        };
+    });
+};
+/**
+ * Generate a module-unique hash from file path
+ */
+const generateModuleHash = (filePath) => {
+    return createHash("md5").update(filePath).digest("hex").slice(0, 4);
+};
+/**
+ * Get or create a generated type name for an object type shape
+ */
+const getOrCreateTypeName = (objectType, ctx) => {
+    const signature = computeShapeSignature(objectType);
+    const existing = ctx.shapeToName.get(signature);
+    if (existing) {
+        return existing;
+    }
+    // Generate name with module hash prefix to avoid collisions across modules
+    const moduleHash = generateModuleHash(ctx.moduleFilePath);
+    const shapeHash = generateShapeHash(signature);
+    const name = `__Anon_${moduleHash}_${shapeHash}`;
+    ctx.shapeToName.set(signature, name);
+    // Create a class declaration (not interface) so it can be instantiated
+    const declaration = {
+        kind: "classDeclaration",
+        name,
+        typeParameters: undefined,
+        superClass: undefined,
+        implements: [],
+        members: interfaceMembersToClassMembers(objectType.members),
+        isExported: true, // Public to avoid inconsistent accessibility errors
+        isStruct: false,
+    };
+    ctx.generatedDeclarations.push(declaration);
+    return name;
+};
+/**
+ * Extract the non-undefined/null type from a union type.
+ * For `T | undefined` or `T | null | undefined`, returns T.
+ * For non-union types, returns the type as-is.
+ */
+const stripNullishFromType = (type) => {
+    if (type.kind !== "unionType") {
+        return type;
+    }
+    const nonNullish = type.types.filter((t) => !(t.kind === "primitiveType" &&
+        (t.name === "undefined" || t.name === "null")));
+    if (nonNullish.length === 0) {
+        // All types were nullish, return original
+        return type;
+    }
+    if (nonNullish.length === type.types.length) {
+        // No nullish types were filtered
+        return type;
+    }
+    if (nonNullish.length === 1) {
+        // Safe: we checked length === 1
+        const first = nonNullish[0];
+        if (first !== undefined) {
+            return first;
+        }
+        return type;
+    }
+    // Return a new union with the filtered types
+    return { ...type, types: nonNullish };
+};
+/**
+ * Lower a type, replacing objectType with referenceType
+ */
+const lowerType = (type, ctx) => {
+    switch (type.kind) {
+        case "objectType": {
+            // First, recursively lower any nested object types in members
+            const loweredMembers = type.members.map((m) => {
+                if (m.kind === "propertySignature") {
+                    return {
+                        ...m,
+                        type: lowerType(m.type, ctx),
+                    };
+                }
+                else if (m.kind === "methodSignature") {
+                    return {
+                        ...m,
+                        parameters: m.parameters.map((p) => lowerParameter(p, ctx)),
+                        returnType: m.returnType ? lowerType(m.returnType, ctx) : undefined,
+                    };
+                }
+                return m;
+            });
+            const loweredObjectType = {
+                ...type,
+                members: loweredMembers,
+            };
+            // Generate name for this shape
+            const typeName = getOrCreateTypeName(loweredObjectType, ctx);
+            // Return reference to generated type
+            const refType = {
+                kind: "referenceType",
+                name: typeName,
+                typeArguments: undefined,
+                resolvedClrType: undefined,
+            };
+            return refType;
+        }
+        case "arrayType":
+            return {
+                ...type,
+                elementType: lowerType(type.elementType, ctx),
+            };
+        case "tupleType":
+            return {
+                ...type,
+                elementTypes: type.elementTypes.map((et) => lowerType(et, ctx)),
+            };
+        case "functionType":
+            return {
+                ...type,
+                parameters: type.parameters.map((p) => lowerParameter(p, ctx)),
+                returnType: lowerType(type.returnType, ctx),
+            };
+        case "unionType":
+            return {
+                ...type,
+                types: type.types.map((t) => lowerType(t, ctx)),
+            };
+        case "intersectionType":
+            return {
+                ...type,
+                types: type.types.map((t) => lowerType(t, ctx)),
+            };
+        case "dictionaryType":
+            return {
+                ...type,
+                keyType: lowerType(type.keyType, ctx),
+                valueType: lowerType(type.valueType, ctx),
+            };
+        case "referenceType": {
+            // Lower both typeArguments and structuralMembers
+            const typeArgs = type.typeArguments;
+            const structuralMembers = type.structuralMembers;
+            const hasTypeArgs = typeArgs !== undefined && typeArgs.length > 0;
+            const hasStructuralMembers = structuralMembers !== undefined && structuralMembers.length > 0;
+            if (!hasTypeArgs && !hasStructuralMembers) {
+                return type;
+            }
+            return {
+                ...type,
+                typeArguments: hasTypeArgs
+                    ? typeArgs.map((ta) => lowerType(ta, ctx))
+                    : undefined,
+                structuralMembers: hasStructuralMembers
+                    ? structuralMembers.map((m) => lowerInterfaceMember(m, ctx))
+                    : undefined,
+            };
+        }
+        // These types don't contain nested types
+        case "primitiveType":
+        case "literalType":
+        case "typeParameterType":
+        case "voidType":
+        case "anyType":
+        case "unknownType":
+        case "neverType":
+            return type;
+    }
+};
+/**
+ * Lower a parameter
+ */
+const lowerParameter = (param, ctx) => {
+    return {
+        ...param,
+        type: param.type ? lowerType(param.type, ctx) : undefined,
+        pattern: lowerPattern(param.pattern, ctx),
+        initializer: param.initializer
+            ? lowerExpression(param.initializer, ctx)
+            : undefined,
+    };
+};
+/**
+ * Lower a type parameter
+ */
+const lowerTypeParameter = (tp, ctx) => {
+    return {
+        ...tp,
+        constraint: tp.constraint ? lowerType(tp.constraint, ctx) : undefined,
+        default: tp.default ? lowerType(tp.default, ctx) : undefined,
+        structuralMembers: tp.structuralMembers?.map((m) => lowerInterfaceMember(m, ctx)),
+    };
+};
+/**
+ * Lower an interface member
+ */
+const lowerInterfaceMember = (member, ctx) => {
+    switch (member.kind) {
+        case "propertySignature":
+            return {
+                ...member,
+                type: lowerType(member.type, ctx),
+            };
+        case "methodSignature":
+            return {
+                ...member,
+                typeParameters: member.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
+                parameters: member.parameters.map((p) => lowerParameter(p, ctx)),
+                returnType: member.returnType
+                    ? lowerType(member.returnType, ctx)
+                    : undefined,
+            };
+    }
+};
+/**
+ * Lower a pattern
+ */
+const lowerPattern = (pattern, ctx) => {
+    switch (pattern.kind) {
+        case "identifierPattern":
+            return {
+                ...pattern,
+                type: pattern.type ? lowerType(pattern.type, ctx) : undefined,
+            };
+        case "arrayPattern":
+            return {
+                ...pattern,
+                elements: pattern.elements.map((e) => e ? lowerPattern(e, ctx) : undefined),
+            };
+        case "objectPattern":
+            return {
+                ...pattern,
+                properties: pattern.properties.map((p) => {
+                    if (p.kind === "property") {
+                        return {
+                            ...p,
+                            value: lowerPattern(p.value, ctx),
+                        };
+                    }
+                    else {
+                        return {
+                            ...p,
+                            pattern: lowerPattern(p.pattern, ctx),
+                        };
+                    }
+                }),
+            };
+    }
+};
+/**
+ * Lower an expression
+ */
+const lowerExpression = (expr, ctx) => {
+    switch (expr.kind) {
+        case "literal":
+        case "identifier":
+        case "this":
+            return expr;
+        case "array":
+            return {
+                ...expr,
+                elements: expr.elements.map((e) => e ? lowerExpression(e, ctx) : undefined),
+            };
+        case "object":
+            return {
+                ...expr,
+                contextualType: expr.contextualType
+                    ? lowerType(expr.contextualType, ctx)
+                    : undefined,
+                properties: expr.properties.map((p) => {
+                    if (p.kind === "property") {
+                        return {
+                            ...p,
+                            key: typeof p.key === "string" ? p.key : lowerExpression(p.key, ctx),
+                            value: lowerExpression(p.value, ctx),
+                        };
+                    }
+                    else {
+                        return {
+                            ...p,
+                            expression: lowerExpression(p.expression, ctx),
+                        };
+                    }
+                }),
+            };
+        case "functionExpression": {
+            const loweredReturnType = expr.returnType
+                ? lowerType(expr.returnType, ctx)
+                : undefined;
+            const bodyCtx = {
+                ...ctx,
+                currentFunctionReturnType: loweredReturnType,
+            };
+            return {
+                ...expr,
+                parameters: expr.parameters.map((p) => lowerParameter(p, ctx)),
+                returnType: loweredReturnType,
+                body: lowerBlockStatement(expr.body, bodyCtx),
+            };
+        }
+        case "arrowFunction": {
+            const loweredReturnType = expr.returnType
+                ? lowerType(expr.returnType, ctx)
+                : undefined;
+            const bodyCtx = {
+                ...ctx,
+                currentFunctionReturnType: loweredReturnType,
+            };
+            // For expression body arrow functions, we need to handle inferredType directly
+            if (expr.body.kind === "blockStatement") {
+                return {
+                    ...expr,
+                    parameters: expr.parameters.map((p) => lowerParameter(p, ctx)),
+                    returnType: loweredReturnType,
+                    body: lowerBlockStatement(expr.body, bodyCtx),
+                };
+            }
+            else {
+                const loweredBody = lowerExpression(expr.body, ctx);
+                // If arrow has expression body and return type, propagate to expression's inferredType
+                const bodyWithType = loweredReturnType && loweredBody.inferredType?.kind === "objectType"
+                    ? { ...loweredBody, inferredType: loweredReturnType }
+                    : loweredBody;
+                return {
+                    ...expr,
+                    parameters: expr.parameters.map((p) => lowerParameter(p, ctx)),
+                    returnType: loweredReturnType,
+                    body: bodyWithType,
+                };
+            }
+        }
+        case "memberAccess":
+            return {
+                ...expr,
+                object: lowerExpression(expr.object, ctx),
+                property: typeof expr.property === "string"
+                    ? expr.property
+                    : lowerExpression(expr.property, ctx),
+            };
+        case "call":
+            return {
+                ...expr,
+                callee: lowerExpression(expr.callee, ctx),
+                arguments: expr.arguments.map((a) => lowerExpression(a, ctx)),
+                typeArguments: expr.typeArguments?.map((ta) => lowerType(ta, ctx)),
+            };
+        case "new":
+            return {
+                ...expr,
+                callee: lowerExpression(expr.callee, ctx),
+                arguments: expr.arguments.map((a) => lowerExpression(a, ctx)),
+                typeArguments: expr.typeArguments?.map((ta) => lowerType(ta, ctx)),
+            };
+        case "update":
+        case "unary":
+        case "await":
+            return {
+                ...expr,
+                expression: lowerExpression(expr.expression, ctx),
+            };
+        case "yield":
+            return {
+                ...expr,
+                expression: expr.expression
+                    ? lowerExpression(expr.expression, ctx)
+                    : undefined,
+            };
+        case "binary":
+        case "logical":
+            return {
+                ...expr,
+                left: lowerExpression(expr.left, ctx),
+                right: lowerExpression(expr.right, ctx),
+            };
+        case "conditional":
+            return {
+                ...expr,
+                condition: lowerExpression(expr.condition, ctx),
+                whenTrue: lowerExpression(expr.whenTrue, ctx),
+                whenFalse: lowerExpression(expr.whenFalse, ctx),
+            };
+        case "assignment":
+            return {
+                ...expr,
+                left: expr.left.kind === "identifierPattern" ||
+                    expr.left.kind === "arrayPattern" ||
+                    expr.left.kind === "objectPattern"
+                    ? lowerPattern(expr.left, ctx)
+                    : lowerExpression(expr.left, ctx),
+                right: lowerExpression(expr.right, ctx),
+            };
+        case "templateLiteral":
+            return {
+                ...expr,
+                expressions: expr.expressions.map((e) => lowerExpression(e, ctx)),
+            };
+        case "spread":
+            return {
+                ...expr,
+                expression: lowerExpression(expr.expression, ctx),
+            };
+        case "numericNarrowing":
+            return {
+                ...expr,
+                expression: lowerExpression(expr.expression, ctx),
+                inferredType: lowerType(expr.inferredType, ctx),
+            };
+    }
+};
+/**
+ * Lower a block statement specifically (for places that need IrBlockStatement)
+ */
+const lowerBlockStatement = (stmt, ctx) => {
+    return {
+        ...stmt,
+        statements: stmt.statements.map((s) => lowerStatement(s, ctx)),
+    };
+};
+/**
+ * Lower a variable declaration specifically (for forStatement initializer)
+ */
+const lowerVariableDeclaration = (stmt, ctx) => {
+    return {
+        ...stmt,
+        declarations: stmt.declarations.map((d) => ({
+            ...d,
+            name: lowerPattern(d.name, ctx),
+            type: d.type ? lowerType(d.type, ctx) : undefined,
+            initializer: d.initializer
+                ? lowerExpression(d.initializer, ctx)
+                : undefined,
+        })),
+    };
+};
+/**
+ * Lower a class member
+ */
+const lowerClassMember = (member, ctx) => {
+    switch (member.kind) {
+        case "methodDeclaration": {
+            const loweredReturnType = member.returnType
+                ? lowerType(member.returnType, ctx)
+                : undefined;
+            const bodyCtx = {
+                ...ctx,
+                currentFunctionReturnType: loweredReturnType,
+            };
+            return {
+                ...member,
+                typeParameters: member.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
+                parameters: member.parameters.map((p) => lowerParameter(p, ctx)),
+                returnType: loweredReturnType,
+                body: member.body
+                    ? lowerBlockStatement(member.body, bodyCtx)
+                    : undefined,
+            };
+        }
+        case "propertyDeclaration":
+            return {
+                ...member,
+                type: member.type ? lowerType(member.type, ctx) : undefined,
+                initializer: member.initializer
+                    ? lowerExpression(member.initializer, ctx)
+                    : undefined,
+            };
+        case "constructorDeclaration":
+            return {
+                ...member,
+                parameters: member.parameters.map((p) => lowerParameter(p, ctx)),
+                body: member.body ? lowerBlockStatement(member.body, ctx) : undefined,
+            };
+    }
+};
+/**
+ * Lower a statement
+ */
+const lowerStatement = (stmt, ctx) => {
+    switch (stmt.kind) {
+        case "variableDeclaration":
+            return {
+                ...stmt,
+                declarations: stmt.declarations.map((d) => ({
+                    ...d,
+                    name: lowerPattern(d.name, ctx),
+                    type: d.type ? lowerType(d.type, ctx) : undefined,
+                    initializer: d.initializer
+                        ? lowerExpression(d.initializer, ctx)
+                        : undefined,
+                })),
+            };
+        case "functionDeclaration": {
+            // First lower the return type
+            const loweredReturnType = stmt.returnType
+                ? lowerType(stmt.returnType, ctx)
+                : undefined;
+            // Create context with the lowered return type for return statements
+            const bodyCtx = {
+                ...ctx,
+                currentFunctionReturnType: loweredReturnType,
+            };
+            return {
+                ...stmt,
+                typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
+                parameters: stmt.parameters.map((p) => lowerParameter(p, ctx)),
+                returnType: loweredReturnType,
+                body: lowerBlockStatement(stmt.body, bodyCtx),
+            };
+        }
+        case "classDeclaration":
+            return {
+                ...stmt,
+                typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
+                superClass: stmt.superClass
+                    ? lowerExpression(stmt.superClass, ctx)
+                    : undefined,
+                implements: stmt.implements.map((i) => lowerType(i, ctx)),
+                members: stmt.members.map((m) => lowerClassMember(m, ctx)),
+            };
+        case "interfaceDeclaration":
+            return {
+                ...stmt,
+                typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
+                extends: stmt.extends.map((e) => lowerType(e, ctx)),
+                members: stmt.members.map((m) => lowerInterfaceMember(m, ctx)),
+            };
+        case "enumDeclaration":
+            return {
+                ...stmt,
+                members: stmt.members.map((m) => ({
+                    ...m,
+                    initializer: m.initializer
+                        ? lowerExpression(m.initializer, ctx)
+                        : undefined,
+                })),
+            };
+        case "typeAliasDeclaration":
+            // IMPORTANT: Do NOT lower the top-level objectType in a type alias declaration.
+            // The emitter already generates a class with __Alias suffix for these.
+            // We only lower nested objectTypes within the members.
+            if (stmt.type.kind === "objectType") {
+                // Lower nested types within the object type's members, but keep objectType as-is
+                const loweredMembers = stmt.type.members.map((m) => {
+                    if (m.kind === "propertySignature") {
+                        return {
+                            ...m,
+                            type: lowerType(m.type, ctx),
+                        };
+                    }
+                    else if (m.kind === "methodSignature") {
+                        return {
+                            ...m,
+                            parameters: m.parameters.map((p) => lowerParameter(p, ctx)),
+                            returnType: m.returnType
+                                ? lowerType(m.returnType, ctx)
+                                : undefined,
+                        };
+                    }
+                    return m;
+                });
+                return {
+                    ...stmt,
+                    typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
+                    type: {
+                        ...stmt.type,
+                        members: loweredMembers,
+                    },
+                };
+            }
+            // For non-objectType type aliases, lower the type normally
+            return {
+                ...stmt,
+                typeParameters: stmt.typeParameters?.map((tp) => lowerTypeParameter(tp, ctx)),
+                type: lowerType(stmt.type, ctx),
+            };
+        case "expressionStatement":
+            return {
+                ...stmt,
+                expression: lowerExpression(stmt.expression, ctx),
+            };
+        case "returnStatement": {
+            if (!stmt.expression) {
+                return stmt;
+            }
+            const loweredExpr = lowerExpression(stmt.expression, ctx);
+            // If we have a function return type and the expression's inferredType is objectType,
+            // replace it with the lowered type (stripping nullish from union if needed)
+            if (ctx.currentFunctionReturnType &&
+                loweredExpr.inferredType?.kind === "objectType") {
+                // Extract non-nullish part of return type (e.g., { title: string } from { title: string } | undefined)
+                const targetType = stripNullishFromType(ctx.currentFunctionReturnType);
+                return {
+                    ...stmt,
+                    expression: { ...loweredExpr, inferredType: targetType },
+                };
+            }
+            return {
+                ...stmt,
+                expression: loweredExpr,
+            };
+        }
+        case "ifStatement":
+            return {
+                ...stmt,
+                condition: lowerExpression(stmt.condition, ctx),
+                thenStatement: lowerStatement(stmt.thenStatement, ctx),
+                elseStatement: stmt.elseStatement
+                    ? lowerStatement(stmt.elseStatement, ctx)
+                    : undefined,
+            };
+        case "whileStatement":
+            return {
+                ...stmt,
+                condition: lowerExpression(stmt.condition, ctx),
+                body: lowerStatement(stmt.body, ctx),
+            };
+        case "forStatement":
+            return {
+                ...stmt,
+                initializer: stmt.initializer
+                    ? stmt.initializer.kind === "variableDeclaration"
+                        ? lowerVariableDeclaration(stmt.initializer, ctx)
+                        : lowerExpression(stmt.initializer, ctx)
+                    : undefined,
+                condition: stmt.condition
+                    ? lowerExpression(stmt.condition, ctx)
+                    : undefined,
+                update: stmt.update ? lowerExpression(stmt.update, ctx) : undefined,
+                body: lowerStatement(stmt.body, ctx),
+            };
+        case "forOfStatement":
+            return {
+                ...stmt,
+                variable: lowerPattern(stmt.variable, ctx),
+                expression: lowerExpression(stmt.expression, ctx),
+                body: lowerStatement(stmt.body, ctx),
+            };
+        case "switchStatement":
+            return {
+                ...stmt,
+                expression: lowerExpression(stmt.expression, ctx),
+                cases: stmt.cases.map((c) => ({
+                    ...c,
+                    test: c.test ? lowerExpression(c.test, ctx) : undefined,
+                    statements: c.statements.map((s) => lowerStatement(s, ctx)),
+                })),
+            };
+        case "throwStatement":
+            return {
+                ...stmt,
+                expression: lowerExpression(stmt.expression, ctx),
+            };
+        case "tryStatement":
+            return {
+                ...stmt,
+                tryBlock: lowerBlockStatement(stmt.tryBlock, ctx),
+                catchClause: stmt.catchClause
+                    ? {
+                        ...stmt.catchClause,
+                        parameter: stmt.catchClause.parameter
+                            ? lowerPattern(stmt.catchClause.parameter, ctx)
+                            : undefined,
+                        body: lowerBlockStatement(stmt.catchClause.body, ctx),
+                    }
+                    : undefined,
+                finallyBlock: stmt.finallyBlock
+                    ? lowerBlockStatement(stmt.finallyBlock, ctx)
+                    : undefined,
+            };
+        case "blockStatement":
+            return {
+                ...stmt,
+                statements: stmt.statements.map((s) => lowerStatement(s, ctx)),
+            };
+        case "yieldStatement":
+            return {
+                ...stmt,
+                output: stmt.output ? lowerExpression(stmt.output, ctx) : undefined,
+                receiveTarget: stmt.receiveTarget
+                    ? lowerPattern(stmt.receiveTarget, ctx)
+                    : undefined,
+                receivedType: stmt.receivedType
+                    ? lowerType(stmt.receivedType, ctx)
+                    : undefined,
+            };
+        case "generatorReturnStatement":
+            return {
+                ...stmt,
+                expression: stmt.expression
+                    ? lowerExpression(stmt.expression, ctx)
+                    : undefined,
+            };
+        case "breakStatement":
+        case "continueStatement":
+        case "emptyStatement":
+            return stmt;
+    }
+};
+/**
+ * Lower a single module
+ */
+const lowerModule = (module) => {
+    const ctx = {
+        generatedDeclarations: [],
+        shapeToName: new Map(),
+        moduleFilePath: module.filePath,
+    };
+    // Lower all statements in the module body
+    const loweredBody = module.body.map((stmt) => lowerStatement(stmt, ctx));
+    // Lower exports
+    const loweredExports = module.exports.map((exp) => {
+        if (exp.kind === "default") {
+            return {
+                ...exp,
+                expression: lowerExpression(exp.expression, ctx),
+            };
+        }
+        else if (exp.kind === "declaration") {
+            return {
+                ...exp,
+                declaration: lowerStatement(exp.declaration, ctx),
+            };
+        }
+        return exp;
+    });
+    // Prepend generated declarations to module body
+    const newBody = [...ctx.generatedDeclarations, ...loweredBody];
+    return {
+        ...module,
+        body: newBody,
+        exports: loweredExports,
+    };
+};
+/**
+ * Run anonymous type lowering pass on all modules
+ */
+export const runAnonymousTypeLoweringPass = (modules) => {
+    const loweredModules = modules.map((m) => lowerModule(m));
+    return {
+        ok: true,
+        modules: loweredModules,
+    };
+};
+//# sourceMappingURL=anonymous-type-lowering-pass.js.map