@tsonic/emitter 0.0.73 → 0.0.74

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

@@ -7,6 +7,203 @@
  * 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
 // ============================================================
@@ -115,21 +312,16 @@ const PREDEFINED_TYPE_KEYWORDS = new Set([
  */
 const escapeIdentifier = (name) => CSHARP_KEYWORDS.has(name) ? `@${name}` : name;
 /**
- * Escape segments in a qualified name (e.g. "global::Foo.stackalloc.Bar").
- * The "global::" prefix and predefined type keywords are preserved.
+ * Escape segments in a qualified name AST.
  */
 const escapeQualifiedName = (name, preservePredefinedTypeKeywords = false) => {
-    const globalPrefix = "global::";
-    const hasGlobal = name.startsWith(globalPrefix);
-    const body = hasGlobal ? name.slice(globalPrefix.length) : name;
-    const escaped = body
-        .split(".")
+    const escaped = [...name.segments]
         .map((segment) => CSHARP_KEYWORDS.has(segment) &&
         !(preservePredefinedTypeKeywords && PREDEFINED_TYPE_KEYWORDS.has(segment))
         ? `@${segment}`
         : segment)
         .join(".");
-    return hasGlobal ? `${globalPrefix}${escaped}` : escaped;
+    return name.aliasQualifier ? `${name.aliasQualifier}::${escaped}` : escaped;
 };
 // ============================================================
 // Operator precedence for parenthesization
@@ -224,13 +416,20 @@ const getExpressionPrecedence = (expr) => {
         case "awaitExpression":
             return 14; // Await is at unary level
         // Primary expressions (highest precedence)
-        case "literalExpression":
+        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":
@@ -289,8 +488,8 @@ const needsParensInBinary = (child, parentPrecedence, isRightOperand) => {
 /**
  * Wrap expression text in parens if needed for the given context.
  */
-const parenthesizeIfNeeded = (expr, parentPrecedence, isRightOperand) => {
-    const text = printExpression(expr);
+const parenthesizeIfNeeded = (expr, parentPrecedence, isRightOperand, indent) => {
+    const text = printExpression(expr, indent);
     return needsParensInBinary(expr, parentPrecedence, isRightOperand)
         ? `(${text})`
         : text;
@@ -303,6 +502,17 @@ export const printType = (type) => {
         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;
@@ -339,39 +549,68 @@ export const printType = (type) => {
 // ============================================================
 // Expression Printer
 // ============================================================
-export const printExpression = (expr) => {
+export const printExpression = (expr, indent = "") => {
     switch (expr.kind) {
-        case "literalExpression":
-            return expr.text;
+        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)})`;
+            return `(${printExpression(expr.expression, indent)})`;
         case "memberAccessExpression":
-            return `${printPrimaryExpression(expr.expression)}.${escapeIdentifier(expr.memberName)}`;
+            return `${printPrimaryExpression(expr.expression, indent)}.${escapeIdentifier(expr.memberName)}`;
         case "conditionalMemberAccessExpression":
-            return `${printPrimaryExpression(expr.expression)}?.${escapeIdentifier(expr.memberName)}`;
+            return `${printPrimaryExpression(expr.expression, indent)}?.${escapeIdentifier(expr.memberName)}`;
         case "elementAccessExpression": {
-            const args = expr.arguments.map(printExpression).join(", ");
-            return `${printPrimaryExpression(expr.expression)}[${args}]`;
+            const args = expr.arguments
+                .map((arg) => printExpression(arg, indent))
+                .join(", ");
+            return `${printPrimaryExpression(expr.expression, indent)}[${args}]`;
         }
         case "conditionalElementAccessExpression": {
-            const args = expr.arguments.map(printExpression).join(", ");
-            return `${printPrimaryExpression(expr.expression)}?[${args}]`;
+            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);
+            const callee = printPrimaryExpression(expr.expression, indent);
             const typeArgs = expr.typeArguments && expr.typeArguments.length > 0
                 ? `<${expr.typeArguments.map(printType).join(", ")}>`
                 : "";
-            const args = expr.arguments.map(printExpression).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(printExpression).join(", ");
+            const args = expr.arguments
+                .map((arg) => printExpression(arg, indent))
+                .join(", ");
             const init = expr.initializer && expr.initializer.length > 0
-                ? ` { ${expr.initializer.map(printExpression).join(", ")} }`
+                ? ` { ${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)
@@ -385,58 +624,58 @@ export const printExpression = (expr) => {
             const isImplicit = expr.elementType.kind === "varType";
             const elemType = isImplicit ? "" : ` ${printType(expr.elementType)}`;
             if (expr.initializer && expr.initializer.length > 0) {
-                const elems = expr.initializer.map(printExpression).join(", ");
+                const elems = expr.initializer
+                    .map((item) => printExpression(item, indent))
+                    .join(", ");
                 if (expr.sizeExpression) {
-                    return `new${elemType}[${printExpression(expr.sizeExpression)}] { ${elems} }`;
+                    return `new${elemType}[${printExpression(expr.sizeExpression, indent)}] { ${elems} }`;
                 }
                 return `new${elemType}[] { ${elems} }`;
             }
             if (expr.sizeExpression) {
-                return `new${elemType}[${printExpression(expr.sizeExpression)}]`;
+                return `new${elemType}[${printExpression(expr.sizeExpression, indent)}]`;
             }
             return `new${elemType}[0]`;
         }
         case "stackAllocArrayCreationExpression":
-            return `stackalloc ${printType(expr.elementType)}[${printExpression(expr.sizeExpression)}]`;
+            return `stackalloc ${printType(expr.elementType)}[${printExpression(expr.sizeExpression, indent)}]`;
         case "assignmentExpression": {
-            const left = printExpression(expr.left);
-            const right = printExpression(expr.right);
+            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);
-            const right = parenthesizeIfNeeded(expr.right, prec, true);
+            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);
-            // Operators like ++ and -- need no space, but ! and - do if operand starts with same char
-            if ((expr.operatorToken === "-" && operand.startsWith("-")) ||
-                (expr.operatorToken === "+" && operand.startsWith("+"))) {
+            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)}${expr.operatorToken}`;
+            return `${printUnaryOperand(expr.operand, false, indent)}${expr.operatorToken}`;
         case "conditionalExpression": {
-            const cond = printExpression(expr.condition);
-            const whenTrue = printExpression(expr.whenTrue);
-            const whenFalse = printExpression(expr.whenFalse);
+            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);
+            const operand = printCastOperand(expr.expression, indent);
             return `(${typeName})${operand}`;
         }
         case "asExpression": {
-            const inner = printExpression(expr.expression);
+            const inner = printExpression(expr.expression, indent);
             return `${inner} as ${printType(expr.type)}`;
         }
         case "isExpression": {
-            const inner = printExpression(expr.expression);
+            const inner = printExpression(expr.expression, indent);
             const pattern = printPattern(expr.pattern);
             return `${inner} is ${pattern}`;
         }
@@ -445,23 +684,25 @@ export const printExpression = (expr) => {
         case "sizeOfExpression":
             return `sizeof(${printType(expr.type)})`;
         case "awaitExpression":
-            return `await ${printUnaryOperand(expr.expression, true)}`;
+            return `await ${printUnaryOperand(expr.expression, true, indent)}`;
         case "lambdaExpression":
-            return printLambdaExpression(expr);
+            return printLambdaExpression(expr, indent);
         case "interpolatedStringExpression":
-            return printInterpolatedString(expr.parts);
+            return printInterpolatedString(expr.parts, indent);
         case "throwExpression":
-            return `throw ${printExpression(expr.expression)}`;
+            return `throw ${printExpression(expr.expression, indent)}`;
         case "suppressNullableWarningExpression":
-            return `${printPrimaryExpression(expr.expression)}!`;
+            return `${printPrimaryExpression(expr.expression, indent)}!`;
         case "typeofExpression":
             return `typeof(${printType(expr.type)})`;
         case "switchExpression":
-            return printSwitchExpression(expr);
+            return printSwitchExpression(expr, indent);
         case "argumentModifierExpression":
-            return `${expr.modifier} ${printExpression(expr.expression)}`;
+            return `${expr.modifier} ${printExpression(expr.expression, indent)}`;
         case "tupleExpression": {
-            const elems = expr.elements.map(printExpression).join(", ");
+            const elems = expr.elements
+                .map((element) => printExpression(element, indent))
+                .join(", ");
             return `(${elems})`;
         }
         default: {
@@ -475,16 +716,21 @@ export const printExpression = (expr) => {
  * (before `.member`, `[index]`, `(args)`, etc.).
  * Wraps in parens if needed.
  */
-const printPrimaryExpression = (expr) => {
-    const text = printExpression(expr);
+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 === "literalExpression" ||
+        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" ||
@@ -498,8 +744,8 @@ const printPrimaryExpression = (expr) => {
 /**
  * Print an expression that appears as a unary operand.
  */
-const printUnaryOperand = (expr, isPrefix) => {
-    const text = printExpression(expr);
+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
@@ -512,8 +758,8 @@ const printUnaryOperand = (expr, isPrefix) => {
  * Print an expression that appears as a cast operand.
  * Special rules: unary minus after cast needs parens to avoid ambiguity.
  */
-const printCastOperand = (expr) => {
-    const text = printExpression(expr);
+const printCastOperand = (expr, indent) => {
+    const text = printExpression(expr, indent);
     // Cast operand needs at least unary precedence
     if (getExpressionPrecedence(expr) < 14) {
         return `(${text})`;
@@ -523,26 +769,16 @@ const printCastOperand = (expr) => {
     if (expr.kind === "prefixUnaryExpression" && expr.operatorToken === "-") {
         return `(${text})`;
     }
-    if (expr.kind === "literalExpression" && text.startsWith("-")) {
-        return `(${text})`;
-    }
     return text;
 };
-const printLambdaExpression = (expr) => {
+const printLambdaExpression = (expr, indent) => {
     const asyncPrefix = expr.isAsync ? "async " : "";
     const params = printLambdaParameters(expr.parameters);
     if (expr.body.kind === "blockStatement") {
-        if (expr.bodyIndent != null) {
-            // Multi-line block body with flat-block convention (braces + body at same indent)
-            return `${asyncPrefix}${params} =>\n${printStatementFlatBlock(expr.body, expr.bodyIndent)}`;
-        }
-        // Inline single-line block body: () => { stmt1; stmt2; }
-        const stmts = expr.body.statements
-            .map((s) => printStatement(s, ""))
-            .join(" ");
-        return `${asyncPrefix}${params} => { ${stmts} }`;
+        const bodyIndent = `${indent}    `;
+        return `${asyncPrefix}${params} =>\n${printStatementFlatBlock(expr.body, bodyIndent)}`;
     }
-    return `${asyncPrefix}${params} => ${printExpression(expr.body)}`;
+    return `${asyncPrefix}${params} => ${printExpression(expr.body, indent)}`;
 };
 const printLambdaParameters = (params) => {
     const sole = params.length === 1 ? params[0] : undefined;
@@ -557,16 +793,15 @@ const printLambdaParameters = (params) => {
     });
     return `(${parts.join(", ")})`;
 };
-const printInterpolatedString = (parts) => {
+const printInterpolatedString = (parts, indent) => {
     const inner = parts
         .map((part) => {
         if (part.kind === "text")
             return part.text;
-        const exprText = printExpression(part.expression);
-        // Wrap in parens if the expression text contains ':' to prevent
-        // C# from interpreting it as a format specifier delimiter.
-        // Common case: global::Namespace.Type, ternary a ? b : c
-        const safeText = exprText.includes(":") ? `(${exprText})` : exprText;
+        const exprText = printExpression(part.expression, indent);
+        const safeText = expressionMayPrintColon(part.expression)
+            ? `(${exprText})`
+            : exprText;
         return part.formatClause
             ? `{${safeText}:${part.formatClause}}`
             : `{${safeText}}`;
@@ -574,17 +809,19 @@ const printInterpolatedString = (parts) => {
         .join("");
     return `$"${inner}"`;
 };
-const printSwitchExpression = (expr) => {
-    const gov = printExpression(expr.governingExpression);
-    const arms = expr.arms.map(printSwitchExpressionArm).join(", ");
+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) => {
+const printSwitchExpressionArm = (arm, indent) => {
     const pattern = printPattern(arm.pattern);
     const whenClause = arm.whenClause
-        ? ` when ${printExpression(arm.whenClause)}`
+        ? ` when ${printExpression(arm.whenClause, indent)}`
         : "";
-    const result = printExpression(arm.expression);
+    const result = printExpression(arm.expression, indent);
     return `${pattern}${whenClause} => ${result}`;
 };
 // ============================================================
@@ -622,7 +859,7 @@ export const printStatement = (stmt, indent) => {
             const typeStr = printType(stmt.type);
             const decls = stmt.declarators
                 .map((d) => d.initializer
-                ? `${escapeIdentifier(d.name)} = ${printExpression(d.initializer)}`
+                ? `${escapeIdentifier(d.name)} = ${printExpression(d.initializer, indent)}`
                 : escapeIdentifier(d.name))
                 .join(", ");
             return `${indent}${mods}${typeStr} ${decls};`;
@@ -638,11 +875,11 @@ export const printStatement = (stmt, indent) => {
             return `${indent}${mods}${ret} ${escapeIdentifier(stmt.name)}${typeParams}(${params})\n${body}`;
         }
         case "expressionStatement":
-            return `${indent}${printExpression(stmt.expression)};`;
+            return `${indent}${printExpression(stmt.expression, indent)};`;
         case "ifStatement":
             return printIfStatement(stmt, indent);
         case "whileStatement": {
-            const cond = printExpression(stmt.condition);
+            const cond = printExpression(stmt.condition, indent);
             const body = printStatement(stmt.body, indent);
             return `${indent}while (${cond})\n${body}`;
         }
@@ -652,7 +889,7 @@ export const printStatement = (stmt, indent) => {
             const awaitStr = stmt.isAwait ? "await " : "";
             const typeStr = printType(stmt.type);
             const ident = escapeIdentifier(stmt.identifier);
-            const collection = printExpression(stmt.expression);
+            const collection = printExpression(stmt.expression, indent);
             const body = printStatement(stmt.body, indent);
             return `${indent}${awaitStr}foreach (${typeStr} ${ident} in ${collection})\n${body}`;
         }
@@ -662,11 +899,11 @@ export const printStatement = (stmt, indent) => {
             return printTryStatement(stmt, indent);
         case "throwStatement":
             return stmt.expression
-                ? `${indent}throw ${printExpression(stmt.expression)};`
+                ? `${indent}throw ${printExpression(stmt.expression, indent)};`
                 : `${indent}throw;`;
         case "returnStatement":
             return stmt.expression
-                ? `${indent}return ${printExpression(stmt.expression)};`
+                ? `${indent}return ${printExpression(stmt.expression, indent)};`
                 : `${indent}return;`;
         case "breakStatement":
             return `${indent}break;`;
@@ -679,7 +916,7 @@ export const printStatement = (stmt, indent) => {
                 return `${indent}yield break;`;
             }
             return stmt.expression
-                ? `${indent}yield return ${printExpression(stmt.expression)};`
+                ? `${indent}yield return ${printExpression(stmt.expression, indent)};`
                 : `${indent}yield return;`;
         default: {
             const exhaustiveCheck = stmt;
@@ -695,7 +932,7 @@ const printBlockStatement = (block, indent) => {
     return `${indent}{\n${stmts}\n${indent}}`;
 };
 const printIfStatement = (stmt, indent) => {
-    const cond = printExpression(stmt.condition);
+    const cond = printExpression(stmt.condition, indent);
     const thenBody = printStatement(stmt.thenStatement, indent);
     if (!stmt.elseStatement) {
         return `${indent}if (${cond})\n${thenBody}`;
@@ -717,27 +954,27 @@ const printForStatement = (stmt, indent) => {
         const typeStr = printType(stmt.declaration.type);
         const decls = stmt.declaration.declarators
             .map((d) => d.initializer
-            ? `${escapeIdentifier(d.name)} = ${printExpression(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(printExpression).join(", "));
+        parts.push(stmt.initializers.map((expr) => printExpression(expr, indent)).join(", "));
     }
     else {
         parts.push("");
     }
     // Condition
-    parts.push(stmt.condition ? printExpression(stmt.condition) : "");
+    parts.push(stmt.condition ? printExpression(stmt.condition, indent) : "");
     // Incrementors
-    parts.push(stmt.incrementors.map(printExpression).join(", "));
+    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);
+    const expr = printExpression(stmt.expression, indent);
     const innerIndent = indent + "    ";
     const sections = stmt.sections
         .map((s) => printSwitchSection(s, innerIndent))
@@ -757,11 +994,11 @@ const printSwitchSection = (section, indent) => {
 const printSwitchLabel = (label, indent) => {
     switch (label.kind) {
         case "caseSwitchLabel":
-            return `${indent}case ${printExpression(label.value)}:`;
+            return `${indent}case ${printExpression(label.value, indent)}:`;
         case "casePatternSwitchLabel": {
             const pattern = printPattern(label.pattern);
             const when = label.whenClause
-                ? ` when ${printExpression(label.whenClause)}`
+                ? ` when ${printExpression(label.whenClause, indent)}`
                 : "";
             return `${indent}case ${pattern}${when}:`;
         }
@@ -789,7 +1026,7 @@ const printCatchClause = (clause, indent) => {
         ? ` ${escapeIdentifier(clause.identifier)}`
         : "";
     const filter = clause.filter
-        ? ` when (${printExpression(clause.filter)})`
+        ? ` when (${printExpression(clause.filter, indent)})`
         : "";
     return `${indent}catch (${typeName}${ident})${filter}\n${body}`;
 };
@@ -799,7 +1036,7 @@ export const printParameter = (param) => {
             .map((a) => {
             const targetPrefix = a.target ? `${a.target}: ` : "";
             const args = a.arguments && a.arguments.length > 0
-                ? `(${a.arguments.map(printExpression).join(", ")})`
+                ? `(${a.arguments.map((arg) => printExpression(arg)).join(", ")})`
                 : "";
             return `[${targetPrefix}${printType(a.type)}${args}]`;
         })
@@ -826,7 +1063,7 @@ export const printMember = (member, indent) => {
             const typeName = printType(member.type);
             const name = escapeIdentifier(member.name);
             const init = member.initializer
-                ? ` = ${printExpression(member.initializer)}`
+                ? ` = ${printExpression(member.initializer, indent)}`
                 : "";
             return `${attrs}${indent}${mods}${typeName} ${name}${init};`;
         }
@@ -844,7 +1081,7 @@ export const printMember = (member, indent) => {
                         : "";
                 const accessors = ` { ${getStr}${setStr}}`;
                 const init = member.initializer
-                    ? ` = ${printExpression(member.initializer)};`
+                    ? ` = ${printExpression(member.initializer, indent)};`
                     : "";
                 return `${attrs}${indent}${mods}${typeName} ${name}${accessors}${init}`;
             }
@@ -873,7 +1110,7 @@ export const printMember = (member, indent) => {
             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)};`;
+                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)}`;
@@ -886,7 +1123,7 @@ export const printMember = (member, 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(printExpression).join(", ")})`
+                ? ` : base(${member.baseArguments.map((arg) => printExpression(arg, indent)).join(", ")})`
                 : "";
             return `${attrs}${indent}${mods}${escapeIdentifier(member.name)}(${params})${baseCall}\n${printBlockStatement(member.body, indent)}`;
         }
@@ -944,7 +1181,7 @@ export const printTypeDeclaration = (decl, indent) => {
     }
 };
 const printEnumMember = (member, indent) => member.value
-    ? `${indent}${escapeIdentifier(member.name)} = ${printExpression(member.value)}`
+    ? `${indent}${escapeIdentifier(member.name)} = ${printExpression(member.value, indent)}`
     : `${indent}${escapeIdentifier(member.name)}`;
 const printTypeParameters = (typeParams) => {
     if (!typeParams || typeParams.length === 0)
@@ -983,7 +1220,7 @@ export const printAttributes = (attrs, indent) => {
         .map((a) => {
         const targetPrefix = a.target ? `${a.target}: ` : "";
         const args = a.arguments && a.arguments.length > 0
-            ? `(${a.arguments.map(printExpression).join(", ")})`
+            ? `(${a.arguments.map((arg) => printExpression(arg, indent)).join(", ")})`
             : "";
         return `${indent}[${targetPrefix}${printType(a.type)}${args}]\n`;
     })
@@ -994,8 +1231,8 @@ export const printAttributes = (attrs, indent) => {
 // ============================================================
 export const printCompilationUnit = (unit) => {
     const parts = [];
-    if (unit.header) {
-        parts.push(unit.header);
+    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)};`)
@@ -1049,7 +1286,7 @@ export const printStatementFlatBlock = (stmt, indent) => {
             return `${indent}{\n${inner}\n${indent}}`;
         }
         case "ifStatement": {
-            const cond = printExpression(stmt.condition);
+            const cond = printExpression(stmt.condition, indent);
             const thenBody = printStatementFlatBlock(stmt.thenStatement, bodyIndent);
             if (!stmt.elseStatement) {
                 return `${indent}if (${cond})\n${thenBody}`;
@@ -1064,7 +1301,7 @@ export const printStatementFlatBlock = (stmt, indent) => {
             return `${indent}if (${cond})\n${thenBody}\n${indent}else\n${elseBody}`;
         }
         case "whileStatement": {
-            const cond = printExpression(stmt.condition);
+            const cond = printExpression(stmt.condition, indent);
             const body = printStatementFlatBlock(stmt.body, bodyIndent);
             return `${indent}while (${cond})\n${body}`;
         }
@@ -1074,19 +1311,23 @@ export const printStatementFlatBlock = (stmt, indent) => {
                 const typeStr = printType(stmt.declaration.type);
                 const decls = stmt.declaration.declarators
                     .map((d) => d.initializer
-                    ? `${escapeIdentifier(d.name)} = ${printExpression(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(printExpression).join(", "));
+                parts.push(stmt.initializers
+                    .map((expr) => printExpression(expr, indent))
+                    .join(", "));
             }
             else {
                 parts.push("");
             }
-            parts.push(stmt.condition ? printExpression(stmt.condition) : "");
-            parts.push(stmt.incrementors.map(printExpression).join(", "));
+            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}`;
@@ -1095,12 +1336,12 @@ export const printStatementFlatBlock = (stmt, indent) => {
             const awaitStr = stmt.isAwait ? "await " : "";
             const typeStr = printType(stmt.type);
             const ident = escapeIdentifier(stmt.identifier);
-            const collection = printExpression(stmt.expression);
+            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);
+            const expr = printExpression(stmt.expression, indent);
             const sections = stmt.sections
                 .map((s) => {
                 const labels = s.labels
@@ -1129,7 +1370,9 @@ export const printStatementFlatBlock = (stmt, indent) => {
                 const ident = c.identifier
                     ? ` ${escapeIdentifier(c.identifier)}`
                     : "";
-                const filter = c.filter ? ` when (${printExpression(c.filter)})` : "";
+                const filter = c.filter
+                    ? ` when (${printExpression(c.filter, indent)})`
+                    : "";
                 return `${indent}catch (${typeName}${ident})${filter}\n${catchBody}`;
             })
                 .join("\n");