@tsonic/emitter 0.0.62 → 0.0.64

package/dist/statements/declarations/functions.js

@@ -1,22 +1,28 @@
 /**
  * Function declaration emission
  */
-import { getIndent, indent, withAsync, withStatic, withScoped, } from "../../types.js";
-import { emitType, emitTypeParameters } from "../../type-emitter.js";
-import { emitBlockStatement } from "../blocks.js";
-import { emitParametersWithDestructuring, generateParameterDestructuring, } from "../classes.js";
+import { withAsync, withStatic } from "../../types.js";
+import { emitTypeAst, emitTypeParametersAst } from "../../type-emitter.js";
+import { emitBlockStatementAst } from "../blocks.js";
+import { emitExpressionAst } from "../../expression-emitter.js";
 import { escapeCSharpIdentifier } from "../../emitter-types/index.js";
+import { lowerPatternAst } from "../../patterns.js";
 import { needsBidirectionalSupport, hasGeneratorReturnType, extractGeneratorTypeArgs, } from "../../generator-wrapper.js";
-import { emitAttributes } from "../../core/attributes.js";
+import { emitAttributes } from "../../core/format/attributes.js";
 import { emitCSharpName, getCSharpName } from "../../naming-policy.js";
-import { allocateLocalName } from "../../core/local-names.js";
+import { allocateLocalName } from "../../core/format/local-names.js";
 const getAsyncBodyReturnType = (isAsync, returnType) => {
     if (!isAsync || !returnType)
         return returnType;
+    const simpleName = returnType.kind === "referenceType"
+        ? returnType.name.includes(".")
+            ? returnType.name.slice(returnType.name.lastIndexOf(".") + 1)
+            : returnType.name
+        : undefined;
     if (returnType.kind === "referenceType" &&
-        (returnType.name === "Promise" ||
-            returnType.name === "Task" ||
-            returnType.name === "ValueTask") &&
+        (simpleName === "Promise" ||
+            simpleName === "Task" ||
+            simpleName === "ValueTask") &&
         returnType.typeArguments?.length === 1) {
         return returnType.typeArguments[0];
     }
@@ -34,8 +40,20 @@ const seedLocalNameMapFromParameters = (params, context) => {
     }
     return { ...context, localNameMap: map, usedLocalNames: used };
 };
+const restoreFunctionScopeContext = (outerContext, innerContext, savedScoped) => ({
+    ...outerContext,
+    ...innerContext,
+    ...savedScoped,
+    indentLevel: outerContext.indentLevel,
+    isStatic: outerContext.isStatic,
+    isAsync: outerContext.isAsync,
+    className: outerContext.className,
+});
 /**
- * Emit a function declaration
+ * Emit a module-level function declaration as CSharpMethodDeclarationAst.
+ *
+ * For generators, builds exchange initialization and wrapper structures
+ * in the method body using AST nodes.
  */
 export const emitFunctionDeclaration = (stmt, context) => {
     const savedScoped = {
@@ -43,106 +61,109 @@ export const emitFunctionDeclaration = (stmt, context) => {
         typeParamConstraints: context.typeParamConstraints,
         typeParameterNameMap: context.typeParameterNameMap,
         returnType: context.returnType,
+        narrowedBindings: context.narrowedBindings,
+        voidResolveNames: context.voidResolveNames,
         localNameMap: context.localNameMap,
         usedLocalNames: context.usedLocalNames,
     };
-    const ind = getIndent(context);
-    const parts = [];
     const csharpBaseName = getCSharpName(stmt.name, "methods", context);
-    // Build type parameter names set FIRST - needed when emitting return type and parameters
-    // Type parameters must be in scope before we emit types that reference them
+    // Build type parameter names set FIRST
     const funcTypeParams = new Set([
         ...(context.typeParameters ?? []),
         ...(stmt.typeParameters?.map((tp) => tp.name) ?? []),
     ]);
-    // Create context with type parameters in scope for signature emission
     const signatureContext = {
         ...context,
         typeParameters: funcTypeParams,
     };
-    // Emit the <T, U> syntax and where clauses EARLY so nullable union emission
-    // can see type parameter constraint kinds when emitting return/parameter types.
-    const [typeParamsStr, whereClauses, typeParamContext] = emitTypeParameters(stmt.typeParameters, signatureContext);
+    // Emit type parameters as AST
+    const [typeParamAsts, constraintAsts, typeParamContext] = emitTypeParametersAst(stmt.typeParameters, signatureContext);
     let currentContext = typeParamContext;
     // Access modifiers
-    //
-    // Top-level (module) functions are emitted as static methods on the module's
-    // container class. When a module also has namespace-level declarations
-    // (classes/interfaces/enums), those types must still be able to call module-local
-    // helpers. `private` would make them inaccessible, so use `internal` for
-    // non-exported module functions.
     const accessibility = stmt.isExported
         ? "public"
         : context.isStatic
             ? "internal"
             : "private";
-    parts.push(accessibility);
-    if (context.isStatic) {
-        parts.push("static");
-    }
-    if (stmt.isAsync && !stmt.isGenerator) {
-        parts.push("async");
-    }
-    // Check if this is a bidirectional generator (has TNext type)
+    const modifiers = [accessibility];
+    if (context.isStatic)
+        modifiers.push("static");
+    // Check generator features
     const isBidirectional = needsBidirectionalSupport(stmt);
     const generatorHasReturnType = stmt.isGenerator && isBidirectional ? hasGeneratorReturnType(stmt) : false;
-    // Return type
+    // Return type AST and async modifier
+    let returnTypeAst;
     if (stmt.isGenerator) {
         if (isBidirectional) {
-            // Bidirectional generators return the wrapper class
             const wrapperName = `${csharpBaseName}_Generator`;
-            parts.push(wrapperName);
+            returnTypeAst = { kind: "identifierType", name: wrapperName };
         }
         else {
-            // Unidirectional generators return IEnumerable<exchange> or IAsyncEnumerable<exchange>
             const exchangeName = `${csharpBaseName}_exchange`;
             if (stmt.isAsync) {
-                parts.push(`async global::System.Collections.Generic.IAsyncEnumerable<${exchangeName}>`);
+                modifiers.push("async");
+                returnTypeAst = {
+                    kind: "identifierType",
+                    name: "global::System.Collections.Generic.IAsyncEnumerable",
+                    typeArguments: [{ kind: "identifierType", name: exchangeName }],
+                };
             }
             else {
-                parts.push(`global::System.Collections.Generic.IEnumerable<${exchangeName}>`);
+                returnTypeAst = {
+                    kind: "identifierType",
+                    name: "global::System.Collections.Generic.IEnumerable",
+                    typeArguments: [{ kind: "identifierType", name: exchangeName }],
+                };
             }
         }
     }
     else if (stmt.returnType) {
-        const [returnType, newContext] = emitType(stmt.returnType, currentContext);
-        currentContext = newContext;
-        // If async and return type is Promise, it's already converted to Task
-        // Don't wrap it again
+        const [retAst, retCtx] = emitTypeAst(stmt.returnType, currentContext);
+        currentContext = retCtx;
+        if (stmt.isAsync) {
+            modifiers.push("async");
+        }
         if (stmt.isAsync &&
             stmt.returnType.kind === "referenceType" &&
             stmt.returnType.name === "Promise") {
-            parts.push(returnType); // Already Task<T> from emitType
+            returnTypeAst = retAst;
+        }
+        else if (stmt.isAsync) {
+            returnTypeAst = {
+                kind: "identifierType",
+                name: "global::System.Threading.Tasks.Task",
+                typeArguments: [retAst],
+            };
         }
         else {
-            parts.push(stmt.isAsync
-                ? `global::System.Threading.Tasks.Task<${returnType}>`
-                : returnType);
+            returnTypeAst = retAst;
         }
     }
     else {
-        parts.push(stmt.isAsync ? "global::System.Threading.Tasks.Task" : "void");
+        if (stmt.isAsync) {
+            modifiers.push("async");
+            returnTypeAst = {
+                kind: "identifierType",
+                name: "global::System.Threading.Tasks.Task",
+            };
+        }
+        else {
+            returnTypeAst = { kind: "identifierType", name: "void" };
+        }
     }
-    // Function name
-    parts.push(emitCSharpName(stmt.name, "methods", context));
-    // Parameters (with destructuring support)
-    const paramsResult = emitParametersWithDestructuring(stmt.parameters, currentContext);
+    // Parameters
+    const paramsResult = buildParameterAsts(stmt.parameters, currentContext);
     currentContext = paramsResult.context;
-    // Function body (not a static context - local variables)
-    // Use withScoped to set typeParameters and returnType for nested expressions
-    let baseBodyContext = seedLocalNameMapFromParameters(stmt.parameters, withAsync(withStatic(indent(currentContext), false), stmt.isAsync));
-    // Reserve generator-internal locals BEFORE emitting the body so user locals can safely
-    // use these names (and get deterministically renamed) without colliding in C#.
+    // Body context setup
+    let baseBodyContext = seedLocalNameMapFromParameters(stmt.parameters, withAsync(withStatic(currentContext, false), stmt.isAsync));
+    // Reserve generator-internal locals
     let generatorExchangeVar = "exchange";
     let generatorIteratorFn = "__iterator";
     let generatorReturnValueVar = "__returnValue";
     if (stmt.isGenerator) {
         const exchangeAlloc = allocateLocalName(generatorExchangeVar, baseBodyContext);
         generatorExchangeVar = exchangeAlloc.emittedName;
-        baseBodyContext = {
-            ...exchangeAlloc.context,
-            generatorExchangeVar,
-        };
+        baseBodyContext = { ...exchangeAlloc.context, generatorExchangeVar };
         if (isBidirectional) {
             const iterAlloc = allocateLocalName(generatorIteratorFn, baseBodyContext);
             generatorIteratorFn = iterAlloc.emittedName;
@@ -150,131 +171,581 @@ export const emitFunctionDeclaration = (stmt, context) => {
             if (generatorHasReturnType) {
                 const retAlloc = allocateLocalName(generatorReturnValueVar, baseBodyContext);
                 generatorReturnValueVar = retAlloc.emittedName;
-                baseBodyContext = {
-                    ...retAlloc.context,
-                    generatorReturnValueVar,
-                };
+                baseBodyContext = { ...retAlloc.context, generatorReturnValueVar };
             }
         }
     }
-    // Generate parameter destructuring statements BEFORE emitting the body so
-    // any renamed locals are visible to the body emitter via localNameMap.
-    const bodyInd = getIndent(baseBodyContext);
-    const [parameterDestructuringStmts, destructuringContext] = paramsResult.destructuringParams.length > 0
-        ? generateParameterDestructuring(paramsResult.destructuringParams, bodyInd, baseBodyContext)
+    // Generate parameter destructuring as AST
+    const [paramDestructuringStmts, destructuringContext] = paramsResult.destructuringParams.length > 0
+        ? generateParameterDestructuringAst(paramsResult.destructuringParams, baseBodyContext)
         : [[], baseBodyContext];
-    // Emit body with scoped typeParameters and returnType
-    // funcTypeParams was already built at the start of this function
-    const [bodyCode] = withScoped(destructuringContext, {
+    // Emit body as AST
+    const bodyReturnType = stmt.isAsync && !stmt.isGenerator
+        ? getAsyncBodyReturnType(stmt.isAsync, stmt.returnType)
+        : stmt.returnType;
+    const bodyContext = {
+        ...destructuringContext,
         typeParameters: funcTypeParams,
-        returnType: stmt.isAsync && !stmt.isGenerator
-            ? getAsyncBodyReturnType(stmt.isAsync, stmt.returnType)
-            : stmt.returnType,
-    }, (scopedCtx) => emitBlockStatement(stmt.body, scopedCtx));
-    // Collect out parameters that need initialization
-    const outParams = [];
-    for (const param of stmt.parameters) {
-        // Use param.passing to detect out parameters (type is already unwrapped by frontend)
-        if (param.passing === "out" && param.pattern.kind === "identifierPattern") {
-            // Get the type for default value
-            let typeName = "object";
-            if (param.type) {
-                const [typeStr] = emitType(param.type, currentContext);
-                typeName = typeStr;
-            }
-            outParams.push({
-                name: escapeCSharpIdentifier(param.pattern.name),
-                type: typeName,
-            });
-        }
-    }
-    // Inject initialization code for generators, out parameters, and destructuring
-    let finalBodyCode = bodyCode;
-    const injectLines = [];
-    // Generate parameter destructuring statements
-    if (parameterDestructuringStmts.length > 0) {
-        injectLines.push(...parameterDestructuringStmts);
-    }
-    // Handle bidirectional generators specially
+        returnType: bodyReturnType,
+    };
+    const [bodyBlock, bodyCtxAfter] = emitBlockStatementAst(stmt.body, bodyContext);
+    // Build final body with injected statements
+    let finalBody;
     if (stmt.isGenerator && isBidirectional) {
+        // Bidirectional generator: build wrapper body
         const exchangeName = `${csharpBaseName}_exchange`;
         const wrapperName = `${csharpBaseName}_Generator`;
         const enumerableType = stmt.isAsync
-            ? `global::System.Collections.Generic.IAsyncEnumerable<${exchangeName}>`
-            : `global::System.Collections.Generic.IEnumerable<${exchangeName}>`;
-        const asyncModifier = stmt.isAsync ? "async " : "";
-        // generatorHasReturnType was computed earlier so we can reserve locals before body emission.
-        const hasReturnType = generatorHasReturnType;
-        // Extract return type for __returnValue variable
-        let returnTypeStr = "object";
-        if (hasReturnType) {
-            const { returnType: extractedReturnType, newContext: typeExtractContext, } = extractGeneratorTypeArgs(stmt.returnType, currentContext);
+            ? {
+                kind: "identifierType",
+                name: "global::System.Collections.Generic.IAsyncEnumerable",
+                typeArguments: [{ kind: "identifierType", name: exchangeName }],
+            }
+            : {
+                kind: "identifierType",
+                name: "global::System.Collections.Generic.IEnumerable",
+                typeArguments: [{ kind: "identifierType", name: exchangeName }],
+            };
+        const wrapperBodyStatements = [];
+        // var exchange = new ExchangeName();
+        wrapperBodyStatements.push({
+            kind: "localDeclarationStatement",
+            modifiers: [],
+            type: { kind: "varType" },
+            declarators: [
+                {
+                    name: generatorExchangeVar,
+                    initializer: {
+                        kind: "objectCreationExpression",
+                        type: { kind: "identifierType", name: exchangeName },
+                        arguments: [],
+                    },
+                },
+            ],
+        });
+        // TReturn __returnValue = default!;
+        if (generatorHasReturnType) {
+            const { returnType: extractedReturnTypeAst, newContext: typeExtractContext, } = extractGeneratorTypeArgs(stmt.returnType, currentContext);
             currentContext = typeExtractContext;
-            returnTypeStr = extractedReturnType;
+            if (!extractedReturnTypeAst) {
+                throw new Error("ICE: Generator marked with non-void return type but no return type AST was extracted.");
+            }
+            wrapperBodyStatements.push({
+                kind: "localDeclarationStatement",
+                modifiers: [],
+                type: extractedReturnTypeAst,
+                declarators: [
+                    {
+                        name: generatorReturnValueVar,
+                        initializer: {
+                            kind: "suppressNullableWarningExpression",
+                            expression: { kind: "defaultExpression" },
+                        },
+                    },
+                ],
+            });
         }
-        // Build the body with local iterator function
-        const iteratorBody = bodyCode
-            .split("\n")
-            .slice(1, -1) // Remove opening and closing braces
-            .map((line) => `    ${line}`) // Add extra indent
-            .join("\n");
-        // Construct the bidirectional generator body
-        const bodyLines = [
-            `${ind}{`,
-            `${bodyInd}var ${generatorExchangeVar} = new ${exchangeName}();`,
+        // Inner local function __iterator()
+        const innerBodyStatements = [
+            ...paramDestructuringStmts,
+            ...bodyBlock.statements,
         ];
-        // Add __returnValue capture if TReturn is not void
-        if (hasReturnType) {
-            bodyLines.push(`${bodyInd}${returnTypeStr} ${generatorReturnValueVar} = default!;`);
+        const iteratorModifiers = stmt.isAsync ? ["async"] : [];
+        wrapperBodyStatements.push({
+            kind: "localFunctionStatement",
+            modifiers: iteratorModifiers,
+            returnType: enumerableType,
+            name: generatorIteratorFn,
+            parameters: [],
+            body: { kind: "blockStatement", statements: innerBodyStatements },
+        });
+        // return new WrapperName(__iterator(), exchange, () => __returnValue);
+        const constructorArgs = [
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: generatorIteratorFn,
+                },
+                arguments: [],
+            },
+            { kind: "identifierExpression", identifier: generatorExchangeVar },
+        ];
+        if (generatorHasReturnType) {
+            constructorArgs.push({
+                kind: "lambdaExpression",
+                isAsync: false,
+                parameters: [],
+                body: {
+                    kind: "identifierExpression",
+                    identifier: generatorReturnValueVar,
+                },
+            });
+        }
+        wrapperBodyStatements.push({
+            kind: "returnStatement",
+            expression: {
+                kind: "objectCreationExpression",
+                type: { kind: "identifierType", name: wrapperName },
+                arguments: constructorArgs,
+            },
+        });
+        finalBody = {
+            kind: "blockStatement",
+            statements: wrapperBodyStatements,
+        };
+    }
+    else {
+        // Non-bidirectional: build body with injected init lines
+        const finalBodyStatements = [];
+        // Parameter destructuring
+        finalBodyStatements.push(...paramDestructuringStmts);
+        // Generator exchange initialization
+        if (stmt.isGenerator) {
+            const exchangeName = `${csharpBaseName}_exchange`;
+            finalBodyStatements.push({
+                kind: "localDeclarationStatement",
+                modifiers: [],
+                type: { kind: "varType" },
+                declarators: [
+                    {
+                        name: generatorExchangeVar,
+                        initializer: {
+                            kind: "objectCreationExpression",
+                            type: { kind: "identifierType", name: exchangeName },
+                            arguments: [],
+                        },
+                    },
+                ],
+            });
         }
-        bodyLines.push(``);
-        bodyLines.push(`${bodyInd}${asyncModifier}${enumerableType} ${generatorIteratorFn}()`);
-        bodyLines.push(`${bodyInd}{`);
-        bodyLines.push(iteratorBody);
-        bodyLines.push(`${bodyInd}}`);
-        bodyLines.push(``);
-        // Wrapper constructor call - pass return value getter if needed
-        if (hasReturnType) {
-            bodyLines.push(`${bodyInd}return new ${wrapperName}(${generatorIteratorFn}(), ${generatorExchangeVar}, () => ${generatorReturnValueVar});`);
+        // Out parameter initializations
+        for (const param of stmt.parameters) {
+            if (param.passing === "out" &&
+                param.pattern.kind === "identifierPattern") {
+                finalBodyStatements.push({
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "assignmentExpression",
+                        operatorToken: "=",
+                        left: {
+                            kind: "identifierExpression",
+                            identifier: escapeCSharpIdentifier(param.pattern.name),
+                        },
+                        right: { kind: "defaultExpression" },
+                    },
+                });
+            }
+        }
+        // Original body statements
+        finalBodyStatements.push(...bodyBlock.statements);
+        finalBody = {
+            kind: "blockStatement",
+            statements: finalBodyStatements,
+        };
+    }
+    // Attributes
+    const [attrs, attrContext] = emitAttributes(stmt.attributes, currentContext);
+    currentContext = attrContext;
+    const methodAst = {
+        kind: "methodDeclaration",
+        attributes: attrs,
+        modifiers,
+        returnType: returnTypeAst,
+        name: emitCSharpName(stmt.name, "methods", context),
+        typeParameters: typeParamAsts.length > 0 ? typeParamAsts : undefined,
+        constraints: constraintAsts.length > 0 ? constraintAsts : undefined,
+        parameters: [...paramsResult.paramAsts],
+        body: finalBody,
+    };
+    return [
+        [methodAst],
+        restoreFunctionScopeContext(context, bodyCtxAfter, savedScoped),
+    ];
+};
+const buildParameterAsts = (parameters, context) => {
+    let currentCtx = context;
+    const paramAsts = [];
+    const destructuringParams = [];
+    let syntheticIndex = 0;
+    for (const param of parameters) {
+        // Type
+        let typeAst = { kind: "identifierType", name: "object" };
+        if (param.type) {
+            const [t, c] = emitTypeAst(param.type, currentCtx);
+            typeAst = t;
+            currentCtx = c;
+        }
+        // Optional: make nullable
+        if (param.isOptional) {
+            typeAst = { kind: "nullableType", underlyingType: typeAst };
+        }
+        // Name
+        let name;
+        const isComplexPattern = param.pattern.kind === "arrayPattern" ||
+            param.pattern.kind === "objectPattern";
+        if (isComplexPattern) {
+            name = `__param${syntheticIndex}`;
+            syntheticIndex++;
+            destructuringParams.push({
+                syntheticName: name,
+                pattern: param.pattern,
+                type: param.type,
+            });
+        }
+        else if (param.pattern.kind === "identifierPattern") {
+            name = escapeCSharpIdentifier(param.pattern.name);
         }
         else {
-            bodyLines.push(`${bodyInd}return new ${wrapperName}(${generatorIteratorFn}(), ${generatorExchangeVar});`);
+            name = "param";
+        }
+        // Modifiers
+        const modifiers = [];
+        if (param.isExtensionReceiver)
+            modifiers.push("this");
+        if (param.passing !== "value")
+            modifiers.push(param.passing);
+        // Default value
+        let defaultValue;
+        if (param.initializer) {
+            const [ast, c] = emitExpressionAst(param.initializer, currentCtx);
+            defaultValue = ast;
+            currentCtx = c;
+        }
+        else if (param.isOptional && !param.isRest) {
+            defaultValue = { kind: "defaultExpression" };
         }
-        bodyLines.push(`${ind}}`);
-        finalBodyCode = bodyLines.join("\n");
+        paramAsts.push({
+            name,
+            type: typeAst,
+            defaultValue,
+            modifiers: modifiers.length > 0 ? modifiers : undefined,
+        });
     }
-    else {
-        // Add generator exchange initialization for unidirectional generators
-        if (stmt.isGenerator) {
+    return { paramAsts, destructuringParams, context: currentCtx };
+};
+/**
+ * Generate parameter destructuring as AST statements.
+ */
+const generateParameterDestructuringAst = (destructuringParams, context) => {
+    let currentContext = context;
+    const statements = [];
+    for (const info of destructuringParams) {
+        const inputExpr = {
+            kind: "identifierExpression",
+            identifier: info.syntheticName,
+        };
+        const result = lowerPatternAst(info.pattern, inputExpr, info.type, currentContext);
+        statements.push(...result.statements);
+        currentContext = result.context;
+    }
+    return [statements, currentContext];
+};
+/**
+ * Emit a local (non-static) function declaration as AST.
+ *
+ * Returns CSharpLocalFunctionStatementAst for regular functions.
+ * For generators, builds exchange initialization and wrapper structures.
+ *
+ * Static function declarations (module-level methods) are handled by
+ * the text-based emitFunctionDeclaration above.
+ */
+export const emitFunctionDeclarationAst = (stmt, context) => {
+    const savedScoped = {
+        typeParameters: context.typeParameters,
+        typeParamConstraints: context.typeParamConstraints,
+        typeParameterNameMap: context.typeParameterNameMap,
+        returnType: context.returnType,
+        narrowedBindings: context.narrowedBindings,
+        voidResolveNames: context.voidResolveNames,
+        localNameMap: context.localNameMap,
+        usedLocalNames: context.usedLocalNames,
+    };
+    const csharpBaseName = getCSharpName(stmt.name, "methods", context);
+    const emittedName = emitCSharpName(stmt.name, "methods", context);
+    // Build type parameter names set
+    const funcTypeParams = new Set([
+        ...(context.typeParameters ?? []),
+        ...(stmt.typeParameters?.map((tp) => tp.name) ?? []),
+    ]);
+    const signatureContext = {
+        ...context,
+        typeParameters: funcTypeParams,
+    };
+    // Build type parameter mapping for scoped emission.
+    const [, , typeParamContext] = emitTypeParametersAst(stmt.typeParameters, signatureContext);
+    let currentContext = typeParamContext;
+    // Type parameter names for AST
+    const typeParamNames = stmt.typeParameters && stmt.typeParameters.length > 0
+        ? stmt.typeParameters.map((tp) => currentContext.typeParameterNameMap?.get(tp.name) ?? tp.name)
+        : undefined;
+    // Check generator features
+    const isBidirectional = needsBidirectionalSupport(stmt);
+    const generatorHasReturnType = stmt.isGenerator && isBidirectional ? hasGeneratorReturnType(stmt) : false;
+    // Modifiers
+    const modifiers = [];
+    if (stmt.isAsync && !stmt.isGenerator) {
+        modifiers.push("async");
+    }
+    // Return type AST
+    let returnTypeAst;
+    if (stmt.isGenerator) {
+        if (isBidirectional) {
+            const wrapperName = `${csharpBaseName}_Generator`;
+            returnTypeAst = { kind: "identifierType", name: wrapperName };
+        }
+        else {
             const exchangeName = `${csharpBaseName}_exchange`;
-            injectLines.push(`${bodyInd}var ${generatorExchangeVar} = new ${exchangeName}();`);
+            if (stmt.isAsync) {
+                modifiers.push("async");
+                returnTypeAst = {
+                    kind: "identifierType",
+                    name: "global::System.Collections.Generic.IAsyncEnumerable",
+                    typeArguments: [{ kind: "identifierType", name: exchangeName }],
+                };
+            }
+            else {
+                returnTypeAst = {
+                    kind: "identifierType",
+                    name: "global::System.Collections.Generic.IEnumerable",
+                    typeArguments: [{ kind: "identifierType", name: exchangeName }],
+                };
+            }
+        }
+    }
+    else if (stmt.returnType) {
+        const [retAst, retCtx] = emitTypeAst(stmt.returnType, currentContext);
+        currentContext = retCtx;
+        if (stmt.isAsync) {
+            modifiers.push("async");
+        }
+        if (stmt.isAsync &&
+            stmt.returnType.kind === "referenceType" &&
+            stmt.returnType.name === "Promise") {
+            returnTypeAst = retAst; // Already Task<T> from emitTypeAst
+        }
+        else if (stmt.isAsync) {
+            returnTypeAst = {
+                kind: "identifierType",
+                name: "global::System.Threading.Tasks.Task",
+                typeArguments: [retAst],
+            };
+        }
+        else {
+            returnTypeAst = retAst;
         }
-        // Add out parameter initializations
-        if (outParams.length > 0) {
-            for (const outParam of outParams) {
-                injectLines.push(`${bodyInd}${outParam.name} = default;`);
+    }
+    else {
+        returnTypeAst = stmt.isAsync
+            ? { kind: "identifierType", name: "global::System.Threading.Tasks.Task" }
+            : { kind: "identifierType", name: "void" };
+    }
+    // Parameters as AST
+    const paramsResult = buildParameterAsts(stmt.parameters, currentContext);
+    currentContext = paramsResult.context;
+    // Body context setup
+    let baseBodyContext = seedLocalNameMapFromParameters(stmt.parameters, withAsync(withStatic(currentContext, false), stmt.isAsync));
+    // Reserve generator-internal locals
+    let generatorExchangeVar = "exchange";
+    let generatorIteratorFn = "__iterator";
+    let generatorReturnValueVar = "__returnValue";
+    if (stmt.isGenerator) {
+        const exchangeAlloc = allocateLocalName(generatorExchangeVar, baseBodyContext);
+        generatorExchangeVar = exchangeAlloc.emittedName;
+        baseBodyContext = { ...exchangeAlloc.context, generatorExchangeVar };
+        if (isBidirectional) {
+            const iterAlloc = allocateLocalName(generatorIteratorFn, baseBodyContext);
+            generatorIteratorFn = iterAlloc.emittedName;
+            baseBodyContext = iterAlloc.context;
+            if (generatorHasReturnType) {
+                const retAlloc = allocateLocalName(generatorReturnValueVar, baseBodyContext);
+                generatorReturnValueVar = retAlloc.emittedName;
+                baseBodyContext = { ...retAlloc.context, generatorReturnValueVar };
             }
         }
-        // Inject lines after opening brace
-        if (injectLines.length > 0) {
-            const lines = bodyCode.split("\n");
-            if (lines.length > 1) {
-                lines.splice(1, 0, ...injectLines, "");
-                finalBodyCode = lines.join("\n");
+    }
+    // Generate parameter destructuring as AST
+    const [paramDestructuringStmts, destructuringContext] = paramsResult.destructuringParams.length > 0
+        ? generateParameterDestructuringAst(paramsResult.destructuringParams, baseBodyContext)
+        : [[], baseBodyContext];
+    // Emit body as AST with scoped typeParameters and returnType
+    const bodyReturnType = stmt.isAsync && !stmt.isGenerator
+        ? getAsyncBodyReturnType(stmt.isAsync, stmt.returnType)
+        : stmt.returnType;
+    const bodyContext = {
+        ...destructuringContext,
+        typeParameters: funcTypeParams,
+        returnType: bodyReturnType,
+    };
+    const [bodyBlock, bodyCtxAfter] = emitBlockStatementAst(stmt.body, bodyContext);
+    // Build final body with injected statements
+    if (stmt.isGenerator && isBidirectional) {
+        // Bidirectional generator: build wrapper body structure
+        const exchangeName = `${csharpBaseName}_exchange`;
+        const wrapperName = `${csharpBaseName}_Generator`;
+        const enumerableType = stmt.isAsync
+            ? {
+                kind: "identifierType",
+                name: "global::System.Collections.Generic.IAsyncEnumerable",
+                typeArguments: [{ kind: "identifierType", name: exchangeName }],
+            }
+            : {
+                kind: "identifierType",
+                name: "global::System.Collections.Generic.IEnumerable",
+                typeArguments: [{ kind: "identifierType", name: exchangeName }],
+            };
+        const wrapperBodyStatements = [];
+        // var exchange = new ExchangeName();
+        wrapperBodyStatements.push({
+            kind: "localDeclarationStatement",
+            modifiers: [],
+            type: { kind: "varType" },
+            declarators: [
+                {
+                    name: generatorExchangeVar,
+                    initializer: {
+                        kind: "objectCreationExpression",
+                        type: { kind: "identifierType", name: exchangeName },
+                        arguments: [],
+                    },
+                },
+            ],
+        });
+        // TReturn __returnValue = default!; (if has return type)
+        if (generatorHasReturnType) {
+            const { returnType: extractedReturnTypeAst, newContext: typeExtractContext, } = extractGeneratorTypeArgs(stmt.returnType, currentContext);
+            currentContext = typeExtractContext;
+            if (!extractedReturnTypeAst) {
+                throw new Error("ICE: Generator marked with non-void return type but no return type AST was extracted.");
             }
+            wrapperBodyStatements.push({
+                kind: "localDeclarationStatement",
+                modifiers: [],
+                type: extractedReturnTypeAst,
+                declarators: [
+                    {
+                        name: generatorReturnValueVar,
+                        initializer: {
+                            kind: "suppressNullableWarningExpression",
+                            expression: { kind: "defaultExpression" },
+                        },
+                    },
+                ],
+            });
+        }
+        // Inner local function __iterator() with original body + exchange init
+        const innerBodyStatements = [
+            ...paramDestructuringStmts,
+            ...bodyBlock.statements,
+        ];
+        const iteratorModifiers = stmt.isAsync ? ["async"] : [];
+        wrapperBodyStatements.push({
+            kind: "localFunctionStatement",
+            modifiers: iteratorModifiers,
+            returnType: enumerableType,
+            name: generatorIteratorFn,
+            parameters: [],
+            body: { kind: "blockStatement", statements: innerBodyStatements },
+        });
+        // return new WrapperName(__iterator(), exchange, () => __returnValue);
+        const constructorArgs = [
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: generatorIteratorFn,
+                },
+                arguments: [],
+            },
+            { kind: "identifierExpression", identifier: generatorExchangeVar },
+        ];
+        if (generatorHasReturnType) {
+            constructorArgs.push({
+                kind: "lambdaExpression",
+                isAsync: false,
+                parameters: [],
+                body: {
+                    kind: "identifierExpression",
+                    identifier: generatorReturnValueVar,
+                },
+            });
         }
+        wrapperBodyStatements.push({
+            kind: "returnStatement",
+            expression: {
+                kind: "objectCreationExpression",
+                type: { kind: "identifierType", name: wrapperName },
+                arguments: constructorArgs,
+            },
+        });
+        const localFn = {
+            kind: "localFunctionStatement",
+            modifiers,
+            returnType: returnTypeAst,
+            name: emittedName,
+            typeParameters: typeParamNames,
+            parameters: [...paramsResult.paramAsts],
+            body: { kind: "blockStatement", statements: wrapperBodyStatements },
+        };
+        return [
+            [localFn],
+            restoreFunctionScopeContext(context, bodyCtxAfter, savedScoped),
+        ];
     }
-    // Emit attributes before the function declaration
-    const [attributesCode, attrContext] = emitAttributes(stmt.attributes, currentContext);
-    currentContext = attrContext;
-    const signature = parts.join(" ");
-    const whereClause = whereClauses.length > 0
-        ? `\n${ind}    ${whereClauses.join(`\n${ind}    `)}`
-        : "";
-    // Build final code with attributes (if any)
-    const attrPrefix = attributesCode ? attributesCode + "\n" : "";
-    const code = `${attrPrefix}${ind}${signature}${typeParamsStr}(${paramsResult.parameterList})${whereClause}\n${finalBodyCode}`;
-    // Return context - no usings tracking needed with global:: FQN approach
-    return [code, { ...currentContext, ...savedScoped }];
+    // Non-bidirectional: build body with injected init lines
+    const finalBodyStatements = [];
+    // Parameter destructuring
+    finalBodyStatements.push(...paramDestructuringStmts);
+    // Generator exchange initialization
+    if (stmt.isGenerator) {
+        const exchangeName = `${csharpBaseName}_exchange`;
+        finalBodyStatements.push({
+            kind: "localDeclarationStatement",
+            modifiers: [],
+            type: { kind: "varType" },
+            declarators: [
+                {
+                    name: generatorExchangeVar,
+                    initializer: {
+                        kind: "objectCreationExpression",
+                        type: { kind: "identifierType", name: exchangeName },
+                        arguments: [],
+                    },
+                },
+            ],
+        });
+    }
+    // Out parameter initializations
+    for (const param of stmt.parameters) {
+        if (param.passing === "out" && param.pattern.kind === "identifierPattern") {
+            finalBodyStatements.push({
+                kind: "expressionStatement",
+                expression: {
+                    kind: "assignmentExpression",
+                    operatorToken: "=",
+                    left: {
+                        kind: "identifierExpression",
+                        identifier: escapeCSharpIdentifier(param.pattern.name),
+                    },
+                    right: { kind: "defaultExpression" },
+                },
+            });
+        }
+    }
+    // Original body statements
+    finalBodyStatements.push(...bodyBlock.statements);
+    const localFn = {
+        kind: "localFunctionStatement",
+        modifiers,
+        returnType: returnTypeAst,
+        name: emittedName,
+        typeParameters: typeParamNames,
+        parameters: [...paramsResult.paramAsts],
+        body: { kind: "blockStatement", statements: finalBodyStatements },
+    };
+    return [
+        [localFn],
+        restoreFunctionScopeContext(context, bodyCtxAfter, savedScoped),
+    ];
 };
 //# sourceMappingURL=functions.js.map