@tsonic/emitter 0.0.74 → 0.0.75

package/dist/core/format/backend-ast/printer.js

@@ -1,1398 +1,20 @@
 /**
- * Backend AST Printer
+ * Backend AST Printer – Public API Facade
  *
  * Converts typed C# AST nodes into deterministic C# source text.
  * Pure and stateless - no parsing, no string heuristics.
  *
  * Parenthesization is derived from operator precedence tables,
  * not from advisory metadata on fragments.
- */
-const escapeCSharpStringLiteral = (value) => value
-    .replace(/\\/g, "\\\\")
-    .replace(/"/g, '\\"')
-    .replace(/\n/g, "\\n")
-    .replace(/\r/g, "\\r")
-    .replace(/\t/g, "\\t");
-const escapeCSharpCharLiteral = (value) => {
-    switch (value) {
-        case "'":
-            return "\\'";
-        case "\\":
-            return "\\\\";
-        case "\n":
-            return "\\n";
-        case "\r":
-            return "\\r";
-        case "\t":
-            return "\\t";
-        case "\0":
-            return "\\0";
-        default:
-            return value;
-    }
-};
-const printTrivia = (trivia) => {
-    switch (trivia.kind) {
-        case "singleLineCommentTrivia":
-            return `// ${trivia.text}`;
-        case "blankLineTrivia":
-            return "";
-        default: {
-            const exhaustive = trivia;
-            throw new Error(`ICE: Unhandled trivia kind '${exhaustive.kind}' in printTrivia`);
-        }
-    }
-};
-const nameMayPrintColon = (name) => name.aliasQualifier !== undefined;
-const typeMayPrintColon = (type) => {
-    switch (type.kind) {
-        case "predefinedType":
-        case "varType":
-            return false;
-        case "identifierType":
-            return type.typeArguments?.some(typeMayPrintColon) === true;
-        case "qualifiedIdentifierType":
-            return (nameMayPrintColon(type.name) ||
-                type.typeArguments?.some(typeMayPrintColon) === true);
-        case "nullableType":
-            return typeMayPrintColon(type.underlyingType);
-        case "arrayType":
-            return typeMayPrintColon(type.elementType);
-        case "pointerType":
-            return typeMayPrintColon(type.elementType);
-        case "tupleType":
-            return type.elements.some((element) => typeMayPrintColon(element.type));
-        default: {
-            const exhaustive = type;
-            throw new Error(`ICE: Unhandled type AST kind '${exhaustive.kind}' in typeMayPrintColon`);
-        }
-    }
-};
-const patternMayPrintColon = (pattern) => {
-    switch (pattern.kind) {
-        case "typePattern":
-        case "declarationPattern":
-            return typeMayPrintColon(pattern.type);
-        case "varPattern":
-        case "discardPattern":
-            return false;
-        case "constantPattern":
-            return expressionMayPrintColon(pattern.expression);
-        case "negatedPattern":
-            return patternMayPrintColon(pattern.pattern);
-        default: {
-            const exhaustive = pattern;
-            throw new Error(`ICE: Unhandled pattern AST kind '${exhaustive.kind}' in patternMayPrintColon`);
-        }
-    }
-};
-const expressionMayPrintColon = (expr) => {
-    switch (expr.kind) {
-        case "conditionalExpression":
-            return true;
-        case "identifierExpression":
-            return false;
-        case "qualifiedIdentifierExpression":
-            return nameMayPrintColon(expr.name);
-        case "typeReferenceExpression":
-            return typeMayPrintColon(expr.type);
-        case "parenthesizedExpression":
-        case "awaitExpression":
-        case "throwExpression":
-        case "suppressNullableWarningExpression":
-        case "argumentModifierExpression":
-            return expressionMayPrintColon(expr.expression);
-        case "prefixUnaryExpression":
-        case "postfixUnaryExpression":
-            return expressionMayPrintColon(expr.operand);
-        case "memberAccessExpression":
-        case "conditionalMemberAccessExpression":
-            return expressionMayPrintColon(expr.expression);
-        case "elementAccessExpression":
-        case "conditionalElementAccessExpression":
-            return (expressionMayPrintColon(expr.expression) ||
-                expr.arguments.some(expressionMayPrintColon));
-        case "implicitElementAccessExpression":
-            return expr.arguments.some(expressionMayPrintColon);
-        case "invocationExpression":
-            return (expressionMayPrintColon(expr.expression) ||
-                expr.arguments.some(expressionMayPrintColon) ||
-                expr.typeArguments?.some(typeMayPrintColon) === true);
-        case "objectCreationExpression":
-            return (typeMayPrintColon(expr.type) ||
-                expr.arguments.some(expressionMayPrintColon) ||
-                expr.initializer?.some(expressionMayPrintColon) === true);
-        case "arrayCreationExpression":
-            return (typeMayPrintColon(expr.elementType) ||
-                (expr.sizeExpression
-                    ? expressionMayPrintColon(expr.sizeExpression)
-                    : false) ||
-                expr.initializer?.some(expressionMayPrintColon) === true);
-        case "stackAllocArrayCreationExpression":
-            return (typeMayPrintColon(expr.elementType) ||
-                expressionMayPrintColon(expr.sizeExpression));
-        case "assignmentExpression":
-        case "binaryExpression":
-            return (expressionMayPrintColon(expr.left) ||
-                expressionMayPrintColon(expr.right));
-        case "castExpression":
-            return (typeMayPrintColon(expr.type) || expressionMayPrintColon(expr.expression));
-        case "asExpression":
-            return (typeMayPrintColon(expr.type) || expressionMayPrintColon(expr.expression));
-        case "isExpression":
-            return (expressionMayPrintColon(expr.expression) ||
-                patternMayPrintColon(expr.pattern));
-        case "defaultExpression":
-            return expr.type ? typeMayPrintColon(expr.type) : false;
-        case "sizeOfExpression":
-        case "typeofExpression":
-            return typeMayPrintColon(expr.type);
-        case "lambdaExpression":
-            return expr.parameters.some((p) => p.type ? typeMayPrintColon(p.type) : false);
-        case "interpolatedStringExpression":
-            return expr.parts.some((part) => part.kind === "interpolation" &&
-                expressionMayPrintColon(part.expression));
-        case "switchExpression":
-            return (expressionMayPrintColon(expr.governingExpression) ||
-                expr.arms.some((arm) => patternMayPrintColon(arm.pattern) ||
-                    (arm.whenClause
-                        ? expressionMayPrintColon(arm.whenClause)
-                        : false) ||
-                    expressionMayPrintColon(arm.expression)));
-        case "tupleExpression":
-            return expr.elements.some(expressionMayPrintColon);
-        case "nullLiteralExpression":
-        case "booleanLiteralExpression":
-        case "stringLiteralExpression":
-        case "charLiteralExpression":
-        case "numericLiteralExpression":
-            return false;
-        default: {
-            const exhaustive = expr;
-            throw new Error(`ICE: Unhandled expression AST kind '${exhaustive.kind}' in expressionMayPrintColon`);
-        }
-    }
-};
-const needsPrefixUnarySeparator = (operatorToken, operand) => {
-    if (operatorToken !== "-" && operatorToken !== "+") {
-        return false;
-    }
-    const unwrapped = operand.kind === "parenthesizedExpression" ? operand.expression : operand;
-    return (unwrapped.kind === "prefixUnaryExpression" &&
-        unwrapped.operatorToken === operatorToken);
-};
-const printNumericLiteral = (expr) => {
-    const suffix = expr.suffix ?? "";
-    const hasRealParts = expr.fractionalPart !== undefined || expr.exponentDigits !== undefined;
-    if (hasRealParts) {
-        const fractional = expr.fractionalPart !== undefined ? `.${expr.fractionalPart}` : "";
-        const exponent = expr.exponentDigits !== undefined
-            ? `e${expr.exponentSign ?? ""}${expr.exponentDigits}`
-            : "";
-        return `${expr.wholePart}${fractional}${exponent}${suffix}`;
-    }
-    switch (expr.base) {
-        case "decimal":
-            return `${expr.wholePart}${suffix}`;
-        case "hexadecimal":
-            return `0x${expr.wholePart}${suffix}`;
-        case "binary":
-            return `0b${expr.wholePart}${suffix}`;
-        default: {
-            const exhaustive = expr.base;
-            throw new Error(`ICE: Unhandled numeric literal base '${exhaustive}'`);
-        }
-    }
-};
-// ============================================================
-// C# reserved keywords for identifier escaping
-// ============================================================
-const CSHARP_KEYWORDS = new Set([
-    "abstract",
-    "as",
-    "bool",
-    "break",
-    "byte",
-    "case",
-    "catch",
-    "char",
-    "checked",
-    "class",
-    "const",
-    "continue",
-    "decimal",
-    "default",
-    "delegate",
-    "do",
-    "double",
-    "else",
-    "enum",
-    "event",
-    "explicit",
-    "extern",
-    "finally",
-    "fixed",
-    "float",
-    "for",
-    "foreach",
-    "goto",
-    "if",
-    "implicit",
-    "in",
-    "int",
-    "interface",
-    "internal",
-    "is",
-    "lock",
-    "long",
-    "namespace",
-    "new",
-    "null",
-    "object",
-    "operator",
-    "out",
-    "override",
-    "params",
-    "private",
-    "protected",
-    "public",
-    "readonly",
-    "ref",
-    "return",
-    "sbyte",
-    "sealed",
-    "short",
-    "sizeof",
-    "stackalloc",
-    "static",
-    "string",
-    "struct",
-    "switch",
-    "throw",
-    "try",
-    "typeof",
-    "uint",
-    "ulong",
-    "unchecked",
-    "unsafe",
-    "ushort",
-    "using",
-    "virtual",
-    "void",
-    "volatile",
-    "while",
-]);
-/**
- * C# predefined type keywords that should NOT be escaped with @
- * when used in type position (they are the type name itself).
- */
-const PREDEFINED_TYPE_KEYWORDS = new Set([
-    "bool",
-    "byte",
-    "char",
-    "decimal",
-    "double",
-    "float",
-    "int",
-    "long",
-    "object",
-    "sbyte",
-    "short",
-    "string",
-    "uint",
-    "ulong",
-    "ushort",
-    "void",
-    "nint",
-    "nuint",
-]);
-/**
- * Escape a C# identifier if it's a keyword.
- * Preserves predefined type keywords when used as types.
- */
-const escapeIdentifier = (name) => CSHARP_KEYWORDS.has(name) ? `@${name}` : name;
-/**
- * Escape segments in a qualified name AST.
- */
-const escapeQualifiedName = (name, preservePredefinedTypeKeywords = false) => {
-    const escaped = [...name.segments]
-        .map((segment) => CSHARP_KEYWORDS.has(segment) &&
-        !(preservePredefinedTypeKeywords && PREDEFINED_TYPE_KEYWORDS.has(segment))
-        ? `@${segment}`
-        : segment)
-        .join(".");
-    return name.aliasQualifier ? `${name.aliasQualifier}::${escaped}` : escaped;
-};
-// ============================================================
-// Operator precedence for parenthesization
-// ============================================================
-/**
- * C# operator precedence levels (higher = binds tighter).
- * Used by the printer to insert parentheses only when necessary.
- */
-const getOperatorPrecedence = (op) => {
-    switch (op) {
-        // Assignment operators (lowest)
-        case "=":
-        case "+=":
-        case "-=":
-        case "*=":
-        case "/=":
-        case "%=":
-        case "&=":
-        case "|=":
-        case "^=":
-        case "<<=":
-        case ">>=":
-        case "??=":
-            return 1;
-        // Conditional ternary
-        // (handled separately, not via this function)
-        // Null-coalescing
-        case "??":
-            return 3;
-        // Logical OR
-        case "||":
-            return 4;
-        // Logical AND
-        case "&&":
-            return 5;
-        // Bitwise OR
-        case "|":
-            return 6;
-        // Bitwise XOR
-        case "^":
-            return 7;
-        // Bitwise AND
-        case "&":
-            return 8;
-        // Equality
-        case "==":
-        case "!=":
-            return 9;
-        // Relational (includes is, as - handled separately)
-        case "<":
-        case ">":
-        case "<=":
-        case ">=":
-            return 10;
-        // Shift
-        case "<<":
-        case ">>":
-            return 11;
-        // Additive
-        case "+":
-        case "-":
-            return 12;
-        // Multiplicative
-        case "*":
-        case "/":
-        case "%":
-            return 13;
-        default:
-            return 0;
-    }
-};
-/**
- * Get the effective precedence of an expression for parenthesization decisions.
- */
-const getExpressionPrecedence = (expr) => {
-    switch (expr.kind) {
-        case "assignmentExpression":
-            return 1;
-        case "conditionalExpression":
-            return 2;
-        case "binaryExpression":
-            return getOperatorPrecedence(expr.operatorToken);
-        case "isExpression":
-        case "asExpression":
-            return 10; // Relational level
-        case "prefixUnaryExpression":
-            return 14; // Unary prefix
-        case "postfixUnaryExpression":
-            return 15; // Unary postfix
-        case "castExpression":
-            return 14; // Cast is at unary level
-        case "awaitExpression":
-            return 14; // Await is at unary level
-        // Primary expressions (highest precedence)
-        case "nullLiteralExpression":
-        case "booleanLiteralExpression":
-        case "stringLiteralExpression":
-        case "charLiteralExpression":
-        case "numericLiteralExpression":
-        case "identifierExpression":
-        case "qualifiedIdentifierExpression":
-        case "typeReferenceExpression":
-        case "parenthesizedExpression":
-        case "memberAccessExpression":
-        case "conditionalMemberAccessExpression":
-        case "elementAccessExpression":
-        case "conditionalElementAccessExpression":
-        case "implicitElementAccessExpression":
-        case "invocationExpression":
-        case "objectCreationExpression":
-        case "arrayCreationExpression":
-        case "stackAllocArrayCreationExpression":
-        case "defaultExpression":
-        case "sizeOfExpression":
-        case "typeofExpression":
-        case "interpolatedStringExpression":
-        case "suppressNullableWarningExpression":
-        case "switchExpression":
-            return 16;
-        case "argumentModifierExpression":
-            return 16; // Argument modifier is used in argument position only
-        case "tupleExpression":
-            return 16; // Tuple literals are primary expressions
-        case "lambdaExpression":
-            return 0; // Lambda needs parens almost everywhere
-        case "throwExpression":
-            return 0; // Throw expression is very low precedence
-        default:
-            return 0;
-    }
-};
-/**
- * Whether an expression needs parenthesization when used as an operand
- * of a binary expression with the given parent precedence.
- */
-const needsParensInBinary = (child, parentPrecedence, isRightOperand) => {
-    const childPrec = getExpressionPrecedence(child);
-    if (childPrec < parentPrecedence)
-        return true;
-    // For same-precedence, right-associative operators (assignment)
-    // don't need parens on the right side
-    if (childPrec === parentPrecedence && isRightOperand) {
-        // Assignment is right-associative
-        if (child.kind === "assignmentExpression") {
-            return false;
-        }
-        // Associative operators at exclusive precedence levels: grouping doesn't
-        // change semantics, so right-side parens are unnecessary.
-        // Each of these operators is the sole occupant of its precedence level,
-        // so same-prec right child must be the same operator.
-        if (child.kind === "binaryExpression" &&
-            (child.operatorToken === "&&" ||
-                child.operatorToken === "||" ||
-                child.operatorToken === "|" ||
-                child.operatorToken === "&" ||
-                child.operatorToken === "^")) {
-            return false;
-        }
-        // Left-associative (and ?? for readability): right operand at same precedence needs parens
-        return true;
-    }
-    return false;
-};
-/**
- * Wrap expression text in parens if needed for the given context.
- */
-const parenthesizeIfNeeded = (expr, parentPrecedence, isRightOperand, indent) => {
-    const text = printExpression(expr, indent);
-    return needsParensInBinary(expr, parentPrecedence, isRightOperand)
-        ? `(${text})`
-        : text;
-};
-// ============================================================
-// Type Printer
-// ============================================================
-export const printType = (type) => {
-    switch (type.kind) {
-        case "predefinedType":
-            return type.keyword;
-        case "identifierType": {
-            if (type.name.includes(".") || type.name.includes("::")) {
-                throw new Error(`ICE: Simple identifierType '${type.name}' contains qualification. Use qualifiedIdentifierType AST instead.`);
-            }
-            const name = escapeIdentifier(type.name);
-            if (!type.typeArguments || type.typeArguments.length === 0) {
-                return name;
-            }
-            const args = type.typeArguments.map(printType).join(", ");
-            return `${name}<${args}>`;
-        }
-        case "qualifiedIdentifierType": {
-            const name = escapeQualifiedName(type.name, true);
-            if (!type.typeArguments || type.typeArguments.length === 0) {
-                return name;
-            }
-            const args = type.typeArguments.map(printType).join(", ");
-            return `${name}<${args}>`;
-        }
-        case "nullableType":
-            return `${printType(type.underlyingType)}?`;
-        case "arrayType": {
-            const elem = printType(type.elementType);
-            if (type.rank === 1) {
-                return `${elem}[]`;
-            }
-            const commas = ",".repeat(type.rank - 1);
-            return `${elem}[${commas}]`;
-        }
-        case "pointerType":
-            return `${printType(type.elementType)}*`;
-        case "tupleType": {
-            const elems = type.elements
-                .map((e) => e.name ? `${printType(e.type)} ${e.name}` : printType(e.type))
-                .join(", ");
-            return `(${elems})`;
-        }
-        case "varType":
-            return "var";
-        default: {
-            const exhaustiveCheck = type;
-            throw new Error(`ICE: Unhandled type AST kind: ${exhaustiveCheck.kind}`);
-        }
-    }
-};
-// ============================================================
-// Expression Printer
-// ============================================================
-export const printExpression = (expr, indent = "") => {
-    switch (expr.kind) {
-        case "nullLiteralExpression":
-            return "null";
-        case "booleanLiteralExpression":
-            return expr.value ? "true" : "false";
-        case "stringLiteralExpression":
-            return `"${escapeCSharpStringLiteral(expr.value)}"`;
-        case "charLiteralExpression":
-            return `'${escapeCSharpCharLiteral(expr.value)}'`;
-        case "numericLiteralExpression":
-            return printNumericLiteral(expr);
-        case "identifierExpression":
-            if (expr.identifier.includes(".") || expr.identifier.includes("::")) {
-                throw new Error(`ICE: Simple identifierExpression '${expr.identifier}' contains qualification. Use qualifiedIdentifierExpression AST instead.`);
-            }
-            return escapeIdentifier(expr.identifier);
-        case "qualifiedIdentifierExpression":
-            return escapeQualifiedName(expr.name);
-        case "typeReferenceExpression":
-            return printType(expr.type);
-        case "parenthesizedExpression":
-            return `(${printExpression(expr.expression, indent)})`;
-        case "memberAccessExpression":
-            return `${printPrimaryExpression(expr.expression, indent)}.${escapeIdentifier(expr.memberName)}`;
-        case "conditionalMemberAccessExpression":
-            return `${printPrimaryExpression(expr.expression, indent)}?.${escapeIdentifier(expr.memberName)}`;
-        case "elementAccessExpression": {
-            const args = expr.arguments
-                .map((arg) => printExpression(arg, indent))
-                .join(", ");
-            return `${printPrimaryExpression(expr.expression, indent)}[${args}]`;
-        }
-        case "conditionalElementAccessExpression": {
-            const args = expr.arguments
-                .map((arg) => printExpression(arg, indent))
-                .join(", ");
-            return `${printPrimaryExpression(expr.expression, indent)}?[${args}]`;
-        }
-        case "implicitElementAccessExpression": {
-            const args = expr.arguments
-                .map((arg) => printExpression(arg, indent))
-                .join(", ");
-            return `[${args}]`;
-        }
-        case "invocationExpression": {
-            const callee = printPrimaryExpression(expr.expression, indent);
-            const typeArgs = expr.typeArguments && expr.typeArguments.length > 0
-                ? `<${expr.typeArguments.map(printType).join(", ")}>`
-                : "";
-            const args = expr.arguments
-                .map((arg) => printExpression(arg, indent))
-                .join(", ");
-            return `${callee}${typeArgs}(${args})`;
-        }
-        case "objectCreationExpression": {
-            const typeName = printType(expr.type);
-            const args = expr.arguments
-                .map((arg) => printExpression(arg, indent))
-                .join(", ");
-            const init = expr.initializer && expr.initializer.length > 0
-                ? ` { ${expr.initializer.map((item) => printExpression(item, indent)).join(", ")} }`
-                : "";
-            // Omit () when using collection/object initializer with no constructor args
-            // (C# allows `new List<T> { ... }` without parentheses)
-            const argsSection = expr.initializer && expr.initializer.length > 0 && args.length === 0
-                ? ""
-                : `(${args})`;
-            return `new ${typeName}${argsSection}${init}`;
-        }
-        case "arrayCreationExpression": {
-            // varType element type → implicitly-typed new[] { ... }
-            const isImplicit = expr.elementType.kind === "varType";
-            const elemType = isImplicit ? "" : ` ${printType(expr.elementType)}`;
-            if (expr.initializer && expr.initializer.length > 0) {
-                const elems = expr.initializer
-                    .map((item) => printExpression(item, indent))
-                    .join(", ");
-                if (expr.sizeExpression) {
-                    return `new${elemType}[${printExpression(expr.sizeExpression, indent)}] { ${elems} }`;
-                }
-                return `new${elemType}[] { ${elems} }`;
-            }
-            if (expr.sizeExpression) {
-                return `new${elemType}[${printExpression(expr.sizeExpression, indent)}]`;
-            }
-            return `new${elemType}[0]`;
-        }
-        case "stackAllocArrayCreationExpression":
-            return `stackalloc ${printType(expr.elementType)}[${printExpression(expr.sizeExpression, indent)}]`;
-        case "assignmentExpression": {
-            const left = printExpression(expr.left, indent);
-            const right = printExpression(expr.right, indent);
-            return `${left} ${expr.operatorToken} ${right}`;
-        }
-        case "binaryExpression": {
-            const prec = getOperatorPrecedence(expr.operatorToken);
-            const left = parenthesizeIfNeeded(expr.left, prec, false, indent);
-            const right = parenthesizeIfNeeded(expr.right, prec, true, indent);
-            return `${left} ${expr.operatorToken} ${right}`;
-        }
-        case "prefixUnaryExpression": {
-            const operand = printUnaryOperand(expr.operand, true, indent);
-            if (needsPrefixUnarySeparator(expr.operatorToken, expr.operand)) {
-                return `${expr.operatorToken} ${operand}`;
-            }
-            return `${expr.operatorToken}${operand}`;
-        }
-        case "postfixUnaryExpression":
-            return `${printUnaryOperand(expr.operand, false, indent)}${expr.operatorToken}`;
-        case "conditionalExpression": {
-            const cond = printExpression(expr.condition, indent);
-            const whenTrue = printExpression(expr.whenTrue, indent);
-            const whenFalse = printExpression(expr.whenFalse, indent);
-            return `${cond} ? ${whenTrue} : ${whenFalse}`;
-        }
-        case "castExpression": {
-            const typeName = printType(expr.type);
-            const operand = printCastOperand(expr.expression, indent);
-            return `(${typeName})${operand}`;
-        }
-        case "asExpression": {
-            const inner = printExpression(expr.expression, indent);
-            return `${inner} as ${printType(expr.type)}`;
-        }
-        case "isExpression": {
-            const inner = printExpression(expr.expression, indent);
-            const pattern = printPattern(expr.pattern);
-            return `${inner} is ${pattern}`;
-        }
-        case "defaultExpression":
-            return expr.type ? `default(${printType(expr.type)})` : "default";
-        case "sizeOfExpression":
-            return `sizeof(${printType(expr.type)})`;
-        case "awaitExpression":
-            return `await ${printUnaryOperand(expr.expression, true, indent)}`;
-        case "lambdaExpression":
-            return printLambdaExpression(expr, indent);
-        case "interpolatedStringExpression":
-            return printInterpolatedString(expr.parts, indent);
-        case "throwExpression":
-            return `throw ${printExpression(expr.expression, indent)}`;
-        case "suppressNullableWarningExpression":
-            return `${printPrimaryExpression(expr.expression, indent)}!`;
-        case "typeofExpression":
-            return `typeof(${printType(expr.type)})`;
-        case "switchExpression":
-            return printSwitchExpression(expr, indent);
-        case "argumentModifierExpression":
-            return `${expr.modifier} ${printExpression(expr.expression, indent)}`;
-        case "tupleExpression": {
-            const elems = expr.elements
-                .map((element) => printExpression(element, indent))
-                .join(", ");
-            return `(${elems})`;
-        }
-        default: {
-            const exhaustiveCheck = expr;
-            throw new Error(`ICE: Unhandled expression AST kind: ${exhaustiveCheck.kind}`);
-        }
-    }
-};
-/**
- * Print an expression that appears in a "primary" position
- * (before `.member`, `[index]`, `(args)`, etc.).
- * Wraps in parens if needed.
- */
-const printPrimaryExpression = (expr, indent) => {
-    const text = printExpression(expr, indent);
-    const prec = getExpressionPrecedence(expr);
-    // Primary position requires precedence >= 15 (postfix and primary)
-    // or the expression is already a parenthesized/literal/identifier
-    if (prec >= 15)
-        return text;
-    if (expr.kind === "parenthesizedExpression" ||
-        expr.kind === "nullLiteralExpression" ||
-        expr.kind === "booleanLiteralExpression" ||
-        expr.kind === "stringLiteralExpression" ||
-        expr.kind === "charLiteralExpression" ||
-        expr.kind === "numericLiteralExpression" ||
-        expr.kind === "identifierExpression" ||
-        expr.kind === "qualifiedIdentifierExpression" ||
-        expr.kind === "defaultExpression" ||
-        expr.kind === "sizeOfExpression" ||
-        expr.kind === "typeofExpression" ||
-        expr.kind === "interpolatedStringExpression" ||
-        expr.kind === "objectCreationExpression" ||
-        expr.kind === "arrayCreationExpression") {
-        return text;
-    }
-    return `(${text})`;
-};
-/**
- * Print an expression that appears as a unary operand.
- */
-const printUnaryOperand = (expr, isPrefix, indent) => {
-    const text = printExpression(expr, indent);
-    const prec = getExpressionPrecedence(expr);
-    if (isPrefix) {
-        // Prefix unary needs operand to be at least unary precedence
-        return prec >= 14 ? text : `(${text})`;
-    }
-    // Postfix unary needs primary expression
-    return prec >= 15 ? text : `(${text})`;
-};
-/**
- * Print an expression that appears as a cast operand.
- * Special rules: unary minus after cast needs parens to avoid ambiguity.
- */
-const printCastOperand = (expr, indent) => {
-    const text = printExpression(expr, indent);
-    // Cast operand needs at least unary precedence
-    if (getExpressionPrecedence(expr) < 14) {
-        return `(${text})`;
-    }
-    // Special case: negative literals after cast need parens
-    // (int)-1 is ambiguous: could be cast or subtraction
-    if (expr.kind === "prefixUnaryExpression" && expr.operatorToken === "-") {
-        return `(${text})`;
-    }
-    return text;
-};
-const printLambdaExpression = (expr, indent) => {
-    const asyncPrefix = expr.isAsync ? "async " : "";
-    const params = printLambdaParameters(expr.parameters);
-    if (expr.body.kind === "blockStatement") {
-        const bodyIndent = `${indent}    `;
-        return `${asyncPrefix}${params} =>\n${printStatementFlatBlock(expr.body, bodyIndent)}`;
-    }
-    return `${asyncPrefix}${params} => ${printExpression(expr.body, indent)}`;
-};
-const printLambdaParameters = (params) => {
-    const sole = params.length === 1 ? params[0] : undefined;
-    if (sole && !sole.type && !sole.modifier) {
-        return escapeIdentifier(sole.name);
-    }
-    const parts = params.map((p) => {
-        const mod = p.modifier ? `${p.modifier} ` : "";
-        return p.type
-            ? `${mod}${printType(p.type)} ${escapeIdentifier(p.name)}`
-            : `${mod}${escapeIdentifier(p.name)}`;
-    });
-    return `(${parts.join(", ")})`;
-};
-const printInterpolatedString = (parts, indent) => {
-    const inner = parts
-        .map((part) => {
-        if (part.kind === "text")
-            return part.text;
-        const exprText = printExpression(part.expression, indent);
-        const safeText = expressionMayPrintColon(part.expression)
-            ? `(${exprText})`
-            : exprText;
-        return part.formatClause
-            ? `{${safeText}:${part.formatClause}}`
-            : `{${safeText}}`;
-    })
-        .join("");
-    return `$"${inner}"`;
-};
-const printSwitchExpression = (expr, indent) => {
-    const gov = printExpression(expr.governingExpression, indent);
-    const arms = expr.arms
-        .map((arm) => printSwitchExpressionArm(arm, indent))
-        .join(", ");
-    return `${gov} switch { ${arms} }`;
-};
-const printSwitchExpressionArm = (arm, indent) => {
-    const pattern = printPattern(arm.pattern);
-    const whenClause = arm.whenClause
-        ? ` when ${printExpression(arm.whenClause, indent)}`
-        : "";
-    const result = printExpression(arm.expression, indent);
-    return `${pattern}${whenClause} => ${result}`;
-};
-// ============================================================
-// Pattern Printer
-// ============================================================
-export const printPattern = (pattern) => {
-    switch (pattern.kind) {
-        case "typePattern":
-            return printType(pattern.type);
-        case "declarationPattern":
-            return `${printType(pattern.type)} ${escapeIdentifier(pattern.designation)}`;
-        case "varPattern":
-            return `var ${escapeIdentifier(pattern.designation)}`;
-        case "constantPattern":
-            return printExpression(pattern.expression);
-        case "discardPattern":
-            return "_";
-        case "negatedPattern":
-            return `not ${printPattern(pattern.pattern)}`;
-        default: {
-            const exhaustiveCheck = pattern;
-            throw new Error(`ICE: Unhandled pattern AST kind: ${exhaustiveCheck.kind}`);
-        }
-    }
-};
-// ============================================================
-// Statement Printer
-// ============================================================
-export const printStatement = (stmt, indent) => {
-    switch (stmt.kind) {
-        case "blockStatement":
-            return printBlockStatement(stmt, indent);
-        case "localDeclarationStatement": {
-            const mods = stmt.modifiers.length > 0 ? `${stmt.modifiers.join(" ")} ` : "";
-            const typeStr = printType(stmt.type);
-            const decls = stmt.declarators
-                .map((d) => d.initializer
-                ? `${escapeIdentifier(d.name)} = ${printExpression(d.initializer, indent)}`
-                : escapeIdentifier(d.name))
-                .join(", ");
-            return `${indent}${mods}${typeStr} ${decls};`;
-        }
-        case "localFunctionStatement": {
-            const mods = stmt.modifiers.length > 0 ? `${stmt.modifiers.join(" ")} ` : "";
-            const ret = printType(stmt.returnType);
-            const typeParams = stmt.typeParameters && stmt.typeParameters.length > 0
-                ? `<${stmt.typeParameters.join(", ")}>`
-                : "";
-            const params = stmt.parameters.map(printParameter).join(", ");
-            const body = printBlockStatement(stmt.body, indent);
-            return `${indent}${mods}${ret} ${escapeIdentifier(stmt.name)}${typeParams}(${params})\n${body}`;
-        }
-        case "expressionStatement":
-            return `${indent}${printExpression(stmt.expression, indent)};`;
-        case "ifStatement":
-            return printIfStatement(stmt, indent);
-        case "whileStatement": {
-            const cond = printExpression(stmt.condition, indent);
-            const body = printStatement(stmt.body, indent);
-            return `${indent}while (${cond})\n${body}`;
-        }
-        case "forStatement":
-            return printForStatement(stmt, indent);
-        case "foreachStatement": {
-            const awaitStr = stmt.isAwait ? "await " : "";
-            const typeStr = printType(stmt.type);
-            const ident = escapeIdentifier(stmt.identifier);
-            const collection = printExpression(stmt.expression, indent);
-            const body = printStatement(stmt.body, indent);
-            return `${indent}${awaitStr}foreach (${typeStr} ${ident} in ${collection})\n${body}`;
-        }
-        case "switchStatement":
-            return printSwitchStatement(stmt, indent);
-        case "tryStatement":
-            return printTryStatement(stmt, indent);
-        case "throwStatement":
-            return stmt.expression
-                ? `${indent}throw ${printExpression(stmt.expression, indent)};`
-                : `${indent}throw;`;
-        case "returnStatement":
-            return stmt.expression
-                ? `${indent}return ${printExpression(stmt.expression, indent)};`
-                : `${indent}return;`;
-        case "breakStatement":
-            return `${indent}break;`;
-        case "continueStatement":
-            return `${indent}continue;`;
-        case "emptyStatement":
-            return `${indent};`;
-        case "yieldStatement":
-            if (stmt.isBreak) {
-                return `${indent}yield break;`;
-            }
-            return stmt.expression
-                ? `${indent}yield return ${printExpression(stmt.expression, indent)};`
-                : `${indent}yield return;`;
-        default: {
-            const exhaustiveCheck = stmt;
-            throw new Error(`ICE: Unhandled statement AST kind: ${exhaustiveCheck.kind}`);
-        }
-    }
-};
-const printBlockStatement = (block, indent) => {
-    const innerIndent = indent + "    ";
-    const stmts = block.statements
-        .map((s) => printStatement(s, innerIndent))
-        .join("\n");
-    return `${indent}{\n${stmts}\n${indent}}`;
-};
-const printIfStatement = (stmt, indent) => {
-    const cond = printExpression(stmt.condition, indent);
-    const thenBody = printStatement(stmt.thenStatement, indent);
-    if (!stmt.elseStatement) {
-        return `${indent}if (${cond})\n${thenBody}`;
-    }
-    // Else-if chain: don't add extra indentation
-    if (stmt.elseStatement.kind === "ifStatement") {
-        const elseIfText = printIfStatement(stmt.elseStatement, indent);
-        // Strip the indent from the else-if since we're adding "else " prefix
-        const elseIfBody = elseIfText.slice(indent.length);
-        return `${indent}if (${cond})\n${thenBody}\n${indent}else ${elseIfBody}`;
-    }
-    const elseBody = printStatement(stmt.elseStatement, indent);
-    return `${indent}if (${cond})\n${thenBody}\n${indent}else\n${elseBody}`;
-};
-const printForStatement = (stmt, indent) => {
-    const parts = [];
-    // Initializer
-    if (stmt.declaration) {
-        const typeStr = printType(stmt.declaration.type);
-        const decls = stmt.declaration.declarators
-            .map((d) => d.initializer
-            ? `${escapeIdentifier(d.name)} = ${printExpression(d.initializer, indent)}`
-            : escapeIdentifier(d.name))
-            .join(", ");
-        parts.push(`${typeStr} ${decls}`);
-    }
-    else if (stmt.initializers && stmt.initializers.length > 0) {
-        parts.push(stmt.initializers.map((expr) => printExpression(expr, indent)).join(", "));
-    }
-    else {
-        parts.push("");
-    }
-    // Condition
-    parts.push(stmt.condition ? printExpression(stmt.condition, indent) : "");
-    // Incrementors
-    parts.push(stmt.incrementors.map((expr) => printExpression(expr, indent)).join(", "));
-    const header = parts.join("; ");
-    const body = printStatement(stmt.body, indent);
-    return `${indent}for (${header})\n${body}`;
-};
-const printSwitchStatement = (stmt, indent) => {
-    const expr = printExpression(stmt.expression, indent);
-    const innerIndent = indent + "    ";
-    const sections = stmt.sections
-        .map((s) => printSwitchSection(s, innerIndent))
-        .join("\n");
-    return `${indent}switch (${expr})\n${indent}{\n${sections}\n${indent}}`;
-};
-const printSwitchSection = (section, indent) => {
-    const labels = section.labels
-        .map((l) => printSwitchLabel(l, indent))
-        .join("\n");
-    const stmtIndent = indent + "    ";
-    const stmts = section.statements
-        .map((s) => printStatement(s, stmtIndent))
-        .join("\n");
-    return `${labels}\n${stmts}`;
-};
-const printSwitchLabel = (label, indent) => {
-    switch (label.kind) {
-        case "caseSwitchLabel":
-            return `${indent}case ${printExpression(label.value, indent)}:`;
-        case "casePatternSwitchLabel": {
-            const pattern = printPattern(label.pattern);
-            const when = label.whenClause
-                ? ` when ${printExpression(label.whenClause, indent)}`
-                : "";
-            return `${indent}case ${pattern}${when}:`;
-        }
-        case "defaultSwitchLabel":
-            return `${indent}default:`;
-    }
-};
-const printTryStatement = (stmt, indent) => {
-    const tryBody = printBlockStatement(stmt.body, indent);
-    const catches = stmt.catches
-        .map((c) => printCatchClause(c, indent))
-        .join("\n");
-    const finallyStr = stmt.finallyBody
-        ? `\n${indent}finally\n${printBlockStatement(stmt.finallyBody, indent)}`
-        : "";
-    return `${indent}try\n${tryBody}\n${catches}${finallyStr}`;
-};
-const printCatchClause = (clause, indent) => {
-    const body = printBlockStatement(clause.body, indent);
-    if (!clause.type) {
-        return `${indent}catch\n${body}`;
-    }
-    const typeName = printType(clause.type);
-    const ident = clause.identifier
-        ? ` ${escapeIdentifier(clause.identifier)}`
-        : "";
-    const filter = clause.filter
-        ? ` when (${printExpression(clause.filter, indent)})`
-        : "";
-    return `${indent}catch (${typeName}${ident})${filter}\n${body}`;
-};
-export const printParameter = (param) => {
-    const attrPrefix = param.attributes && param.attributes.length > 0
-        ? param.attributes
-            .map((a) => {
-            const targetPrefix = a.target ? `${a.target}: ` : "";
-            const args = a.arguments && a.arguments.length > 0
-                ? `(${a.arguments.map((arg) => printExpression(arg)).join(", ")})`
-                : "";
-            return `[${targetPrefix}${printType(a.type)}${args}]`;
-        })
-            .join("") + " "
-        : "";
-    const mods = param.modifiers && param.modifiers.length > 0
-        ? `${param.modifiers.join(" ")} `
-        : "";
-    const typeName = printType(param.type);
-    const name = escapeIdentifier(param.name);
-    const defaultVal = param.defaultValue
-        ? ` = ${printExpression(param.defaultValue)}`
-        : "";
-    return `${attrPrefix}${mods}${typeName} ${name}${defaultVal}`;
-};
-// ============================================================
-// Declaration Printer
-// ============================================================
-export const printMember = (member, indent) => {
-    switch (member.kind) {
-        case "fieldDeclaration": {
-            const attrs = printAttributes(member.attributes, indent);
-            const mods = member.modifiers.length > 0 ? `${member.modifiers.join(" ")} ` : "";
-            const typeName = printType(member.type);
-            const name = escapeIdentifier(member.name);
-            const init = member.initializer
-                ? ` = ${printExpression(member.initializer, indent)}`
-                : "";
-            return `${attrs}${indent}${mods}${typeName} ${name}${init};`;
-        }
-        case "propertyDeclaration": {
-            const attrs = printAttributes(member.attributes, indent);
-            const mods = member.modifiers.length > 0 ? `${member.modifiers.join(" ")} ` : "";
-            const typeName = printType(member.type);
-            const name = escapeIdentifier(member.name);
-            if (member.isAutoProperty) {
-                const getStr = member.hasGetter ? "get; " : "";
-                const setStr = member.hasInit
-                    ? "init; "
-                    : member.hasSetter
-                        ? `${member.setterAccessibility ? `${member.setterAccessibility} ` : ""}set; `
-                        : "";
-                const accessors = ` { ${getStr}${setStr}}`;
-                const init = member.initializer
-                    ? ` = ${printExpression(member.initializer, indent)};`
-                    : "";
-                return `${attrs}${indent}${mods}${typeName} ${name}${accessors}${init}`;
-            }
-            // Explicit property accessors
-            const bodyIndent = indent + "    ";
-            const accessorIndent = bodyIndent + "    ";
-            const lines = [];
-            lines.push(`${attrs}${indent}${mods}${typeName} ${name}`);
-            lines.push(`${bodyIndent}{`);
-            if (member.getterBody) {
-                lines.push(`${bodyIndent}get`);
-                lines.push(printBlockStatement(member.getterBody, accessorIndent));
-            }
-            if (member.setterBody) {
-                lines.push(`${bodyIndent}set`);
-                lines.push(printBlockStatement(member.setterBody, accessorIndent));
-            }
-            lines.push(`${bodyIndent}}`);
-            return lines.join("\n");
-        }
-        case "methodDeclaration": {
-            const attrs = printAttributes(member.attributes, indent);
-            const mods = member.modifiers.length > 0 ? `${member.modifiers.join(" ")} ` : "";
-            const ret = printType(member.returnType);
-            const typeParams = printTypeParameters(member.typeParameters);
-            const params = member.parameters.map(printParameter).join(", ");
-            const constraints = printConstraints(member.constraints, indent);
-            if (member.expressionBody) {
-                return `${attrs}${indent}${mods}${ret} ${escapeIdentifier(member.name)}${typeParams}(${params})${constraints} => ${printExpression(member.expressionBody, indent)};`;
-            }
-            if (member.body) {
-                return `${attrs}${indent}${mods}${ret} ${escapeIdentifier(member.name)}${typeParams}(${params})${constraints}\n${printBlockStatement(member.body, indent)}`;
-            }
-            // Abstract/interface method (no body)
-            return `${attrs}${indent}${mods}${ret} ${escapeIdentifier(member.name)}${typeParams}(${params})${constraints};`;
-        }
-        case "constructorDeclaration": {
-            const attrs = printAttributes(member.attributes, indent);
-            const mods = member.modifiers.length > 0 ? `${member.modifiers.join(" ")} ` : "";
-            const params = member.parameters.map(printParameter).join(", ");
-            const baseCall = member.baseArguments !== undefined
-                ? ` : base(${member.baseArguments.map((arg) => printExpression(arg, indent)).join(", ")})`
-                : "";
-            return `${attrs}${indent}${mods}${escapeIdentifier(member.name)}(${params})${baseCall}\n${printBlockStatement(member.body, indent)}`;
-        }
-        case "delegateDeclaration": {
-            const mods = member.modifiers.length > 0 ? `${member.modifiers.join(" ")} ` : "";
-            const ret = printType(member.returnType);
-            const params = member.parameters.map(printParameter).join(", ");
-            return `${indent}${mods}delegate ${ret} ${escapeIdentifier(member.name)}(${params});`;
-        }
-        default: {
-            const exhaustiveCheck = member;
-            throw new Error(`ICE: Unhandled member AST kind: ${exhaustiveCheck.kind}`);
-        }
-    }
-};
-export const printTypeDeclaration = (decl, indent) => {
-    switch (decl.kind) {
-        case "classDeclaration":
-        case "structDeclaration":
-        case "interfaceDeclaration": {
-            const keyword = decl.kind === "classDeclaration"
-                ? "class"
-                : decl.kind === "structDeclaration"
-                    ? "struct"
-                    : "interface";
-            const attrs = printAttributes(decl.attributes, indent);
-            const mods = decl.modifiers.length > 0 ? `${decl.modifiers.join(" ")} ` : "";
-            const typeParams = printTypeParameters(decl.typeParameters);
-            const baseTypes = [];
-            if (decl.kind === "classDeclaration" && decl.baseType) {
-                baseTypes.push(printType(decl.baseType));
-            }
-            baseTypes.push(...decl.interfaces.map(printType));
-            const baseClause = baseTypes.length > 0 ? ` : ${baseTypes.join(", ")}` : "";
-            const constraints = printConstraints(decl.constraints, indent);
-            const innerIndent = indent + "    ";
-            const members = decl.members
-                .map((m) => printMember(m, innerIndent))
-                .join("\n\n");
-            return `${attrs}${indent}${mods}${keyword} ${escapeIdentifier(decl.name)}${typeParams}${baseClause}${constraints}\n${indent}{\n${members}\n${indent}}`;
-        }
-        case "enumDeclaration": {
-            const attrs = printAttributes(decl.attributes, indent);
-            const mods = decl.modifiers.length > 0 ? `${decl.modifiers.join(" ")} ` : "";
-            const innerIndent = indent + "    ";
-            const members = decl.members
-                .map((m) => printEnumMember(m, innerIndent))
-                .join(",\n");
-            return `${attrs}${indent}${mods}enum ${escapeIdentifier(decl.name)}\n${indent}{\n${members}\n${indent}}`;
-        }
-        default: {
-            const exhaustiveCheck = decl;
-            throw new Error(`ICE: Unhandled type declaration AST kind: ${exhaustiveCheck.kind}`);
-        }
-    }
-};
-const printEnumMember = (member, indent) => member.value
-    ? `${indent}${escapeIdentifier(member.name)} = ${printExpression(member.value, indent)}`
-    : `${indent}${escapeIdentifier(member.name)}`;
-const printTypeParameters = (typeParams) => {
-    if (!typeParams || typeParams.length === 0)
-        return "";
-    return `<${typeParams.map((tp) => tp.name).join(", ")}>`;
-};
-const printConstraints = (constraints, indent) => {
-    if (!constraints || constraints.length === 0)
-        return "";
-    const printConstraint = (constraint) => {
-        switch (constraint.kind) {
-            case "typeConstraint":
-                return printType(constraint.type);
-            case "classConstraint":
-                return "class";
-            case "structConstraint":
-                return "struct";
-            case "constructorConstraint":
-                return "new()";
-            default: {
-                const exhaustiveCheck = constraint;
-                throw new Error(`ICE: Unhandled type parameter constraint kind: ${exhaustiveCheck.kind}`);
-            }
-        }
-    };
-    return constraints
-        .map((c) => `\n${indent}    where ${escapeIdentifier(c.typeParameter)} : ${c.constraints
-        .map(printConstraint)
-        .join(", ")}`)
-        .join("");
-};
-export const printAttributes = (attrs, indent) => {
-    if (attrs.length === 0)
-        return "";
-    return attrs
-        .map((a) => {
-        const targetPrefix = a.target ? `${a.target}: ` : "";
-        const args = a.arguments && a.arguments.length > 0
-            ? `(${a.arguments.map((arg) => printExpression(arg, indent)).join(", ")})`
-            : "";
-        return `${indent}[${targetPrefix}${printType(a.type)}${args}]\n`;
-    })
-        .join("");
-};
-// ============================================================
-// Compilation Unit Printer
-// ============================================================
-export const printCompilationUnit = (unit) => {
-    const parts = [];
-    if (unit.leadingTrivia && unit.leadingTrivia.length > 0) {
-        parts.push(unit.leadingTrivia.map(printTrivia).join("\n"));
-    }
-    const usings = unit.usings
-        .map((u) => `using ${escapeQualifiedName(u.namespace, false)};`)
-        .join("\n");
-    if (usings) {
-        parts.push(usings);
-        parts.push("");
-    }
-    const members = unit.members
-        .map((m) => {
-        if (m.kind === "namespaceDeclaration") {
-            return printNamespaceDeclaration(m);
-        }
-        return printTypeDeclaration(m, "");
-    })
-        .join("\n\n");
-    if (members) {
-        parts.push(members);
-    }
-    return parts.join("\n");
-};
-const printNamespaceDeclaration = (ns) => {
-    const name = escapeQualifiedName(ns.name, false);
-    const members = ns.members
-        .map((m) => printTypeDeclaration(m, "    "))
-        .join("\n\n");
-    return `namespace ${name}\n{\n${members}\n}`;
-};
-// ============================================================
-// Flat Block Printer
-// ============================================================
-/**
- * Print a statement with "flat block" convention:
- * block braces and inner statements share the same indent level.
- *
- * Used by the static container's __TopLevel method and other contexts
- * where block bodies need Tsonic's flat-block formatting (braces at same
- * indent as inner statements, not C#-standard nested convention).
  *
- * For compound statements (if/while/for/foreach/switch/try), body blocks
- * are printed at indent+4 with flat block convention (braces and inner
- * statements at the same level).
- */
-export const printStatementFlatBlock = (stmt, indent) => {
-    const bodyIndent = indent + "    ";
-    switch (stmt.kind) {
-        case "blockStatement": {
-            const inner = stmt.statements
-                .map((s) => printStatementFlatBlock(s, indent))
-                .join("\n");
-            return `${indent}{\n${inner}\n${indent}}`;
-        }
-        case "ifStatement": {
-            const cond = printExpression(stmt.condition, indent);
-            const thenBody = printStatementFlatBlock(stmt.thenStatement, bodyIndent);
-            if (!stmt.elseStatement) {
-                return `${indent}if (${cond})\n${thenBody}`;
-            }
-            // Else-if chain
-            if (stmt.elseStatement.kind === "ifStatement") {
-                const elseIfText = printStatementFlatBlock(stmt.elseStatement, indent);
-                const elseIfBody = elseIfText.slice(indent.length);
-                return `${indent}if (${cond})\n${thenBody}\n${indent}else ${elseIfBody}`;
-            }
-            const elseBody = printStatementFlatBlock(stmt.elseStatement, bodyIndent);
-            return `${indent}if (${cond})\n${thenBody}\n${indent}else\n${elseBody}`;
-        }
-        case "whileStatement": {
-            const cond = printExpression(stmt.condition, indent);
-            const body = printStatementFlatBlock(stmt.body, bodyIndent);
-            return `${indent}while (${cond})\n${body}`;
-        }
-        case "forStatement": {
-            const parts = [];
-            if (stmt.declaration) {
-                const typeStr = printType(stmt.declaration.type);
-                const decls = stmt.declaration.declarators
-                    .map((d) => d.initializer
-                    ? `${escapeIdentifier(d.name)} = ${printExpression(d.initializer, indent)}`
-                    : escapeIdentifier(d.name))
-                    .join(", ");
-                parts.push(`${typeStr} ${decls}`);
-            }
-            else if (stmt.initializers && stmt.initializers.length > 0) {
-                parts.push(stmt.initializers
-                    .map((expr) => printExpression(expr, indent))
-                    .join(", "));
-            }
-            else {
-                parts.push("");
-            }
-            parts.push(stmt.condition ? printExpression(stmt.condition, indent) : "");
-            parts.push(stmt.incrementors
-                .map((expr) => printExpression(expr, indent))
-                .join(", "));
-            const header = parts.join("; ");
-            const body = printStatementFlatBlock(stmt.body, bodyIndent);
-            return `${indent}for (${header})\n${body}`;
-        }
-        case "foreachStatement": {
-            const awaitStr = stmt.isAwait ? "await " : "";
-            const typeStr = printType(stmt.type);
-            const ident = escapeIdentifier(stmt.identifier);
-            const collection = printExpression(stmt.expression, indent);
-            const body = printStatementFlatBlock(stmt.body, bodyIndent);
-            return `${indent}${awaitStr}foreach (${typeStr} ${ident} in ${collection})\n${body}`;
-        }
-        case "switchStatement": {
-            const expr = printExpression(stmt.expression, indent);
-            const sections = stmt.sections
-                .map((s) => {
-                const labels = s.labels
-                    .map((l) => printSwitchLabel(l, bodyIndent))
-                    .join("\n");
-                const stmtInd = bodyIndent + "    ";
-                const sectionStmts = s.statements
-                    .map((st) => printStatementFlatBlock(st, stmtInd))
-                    .join("\n");
-                return `${labels}\n${sectionStmts}`;
-            })
-                .join("\n");
-            return `${indent}switch (${expr})\n${indent}{\n${sections}\n${indent}}`;
-        }
-        case "tryStatement": {
-            // Try/catch/finally bodies are at the SAME indent as the keyword
-            // (the old text emitter did NOT call indent() for try/catch bodies)
-            const tryBody = printStatementFlatBlock(stmt.body, indent);
-            const catches = stmt.catches
-                .map((c) => {
-                const catchBody = printStatementFlatBlock(c.body, indent);
-                if (!c.type) {
-                    return `${indent}catch\n${catchBody}`;
-                }
-                const typeName = printType(c.type);
-                const ident = c.identifier
-                    ? ` ${escapeIdentifier(c.identifier)}`
-                    : "";
-                const filter = c.filter
-                    ? ` when (${printExpression(c.filter, indent)})`
-                    : "";
-                return `${indent}catch (${typeName}${ident})${filter}\n${catchBody}`;
-            })
-                .join("\n");
-            const finallyStr = stmt.finallyBody
-                ? `\n${indent}finally\n${printStatementFlatBlock(stmt.finallyBody, indent)}`
-                : "";
-            return `${indent}try\n${tryBody}\n${catches}${finallyStr}`;
-        }
-        case "localFunctionStatement": {
-            const mods = stmt.modifiers.length > 0 ? `${stmt.modifiers.join(" ")} ` : "";
-            const ret = printType(stmt.returnType);
-            const typeParams = stmt.typeParameters && stmt.typeParameters.length > 0
-                ? `<${stmt.typeParameters.join(", ")}>`
-                : "";
-            const params = stmt.parameters.map(printParameter).join(", ");
-            const body = printBlockStatement(stmt.body, indent);
-            return `${indent}${mods}${ret} ${escapeIdentifier(stmt.name)}${typeParams}(${params})\n${body}`;
-        }
-        default:
-            return printStatement(stmt, indent);
-    }
-};
+ * Implementation is split across focused sub-modules:
+ *   printer-shared.ts       – escape helpers, keywords, precedence, printType
+ *   printer-expressions.ts  – printExpression, printPattern, printAttributes, printParameter
+ *   printer-statements.ts   – printStatement, printStatementFlatBlock
+ *   printer-declarations.ts – printMember, printTypeDeclaration, printCompilationUnit
+ */
+export { printType } from "./printer-shared.js";
+export { printExpression, printPattern, printAttributes, printParameter, } from "./printer-expressions.js";
+export { printStatement, printStatementFlatBlock, } from "./printer-statements.js";
+export { printMember, printTypeDeclaration, printCompilationUnit, } from "./printer-declarations.js";
 //# sourceMappingURL=printer.js.map