@ttsc/factory 0.19.3 → 0.20.0

package/lib/TsPrinter.mjs

@@ -1,5 +1,5 @@
 import { getSyntheticLeadingComments, getSyntheticTrailingComments } from './comments.mjs';
-import { join, hardline, printDocToString, line, softline, group, concat, indent, ifBreak } from './internal/doc.mjs';
+import { join, hardline, printDocToString, line, softline, group, concat, indent, ifBreak, raw } from './internal/doc.mjs';
 import { SyntaxKind } from './syntax/SyntaxKind.mjs';
 import { NodeFlags } from './syntax/NodeFlags.mjs';
 
@@ -73,7 +73,11 @@ class TsPrinter {
         return group(concat([
             open,
             indent(concat([ln, join(concat([",", line]), items)])),
-            opts.trailingComma ? ifBreak(",") : "",
+            opts.trailingComma === "always"
+                ? ","
+                : opts.trailingComma === "onBreak"
+                    ? ifBreak(",")
+                    : "",
             ln,
             close,
         ]), opts.forceBreak === true);
@@ -129,28 +133,75 @@ class TsPrinter {
         // type-argument / type-parameter lists disallow a trailing comma (TS1009)
         return args && args.length
             ? this.delim("<", args.map((a) => this.emit(a)), ">", {
-                trailingComma: false,
+                trailingComma: "never",
             })
             : "";
     }
     /**
-     * Whether a broken parameter list / binding pattern may append a synthetic
-     * trailing comma after its last element.
+     * Trailing-comma policy for a parameter list or binding pattern.
      *
-     * A trailing comma after a rest element (`...rest`) is a syntax error (TS1013
-     * / V8 `SyntaxError`), and one after a trailing elision (`OmittedExpression`)
-     * is not cosmetic: `[a, ,]` parses to one more hole than `[a, ]`, so the flat
-     * and broken layouts of the same node would disagree. Call arguments and
-     * array / object literals are unaffected — a trailing comma after a spread is
-     * legal there.
+     * A comma the printer adds only because a group broke must never change
+     * whether the text parses, nor what it parses to. After a rest element
+     * (`...rest`) it changes the first: a trailing comma there is a syntax error
+     * (TS1013 / V8 `SyntaxError`). After a trailing elision it changes the
+     * second: `[a, ,]` has one more hole than `[a, ]`, so the flat and broken
+     * layouts of the same node would disagree. A binding pattern is the one place
+     * where dropping that hole is lossless, since a trailing hole binds nothing;
+     * {@link literalTrailingComma} materializes it instead, because in an array
+     * literal the hole is a value.
      */
     listTrailingComma(nodes) {
         const last = nodes[nodes.length - 1];
         if (last === undefined)
-            return true;
+            return "onBreak";
         if (last.kind === "OmittedExpression")
-            return false;
-        return !("dotDotDotToken" in last && last.dotDotDotToken !== undefined);
+            return "never";
+        return "dotDotDotToken" in last && last.dotDotDotToken !== undefined
+            ? "never"
+            : "onBreak";
+    }
+    /**
+     * Trailing-comma policy for a call or `new` argument list.
+     *
+     * A trailing `OmittedExpression` prints as nothing, so the list already ends
+     * in the separator comma of its last real argument: `f(a, )`, which is what
+     * the legacy printer emits too and parses as one argument. Adding the break
+     * comma on top produces `f(a, ,)`, which is a syntax error. A trailing spread
+     * is unaffected — a comma after it is legal in an argument list.
+     */
+    argsTrailingComma(args) {
+        const last = args[args.length - 1];
+        return last !== undefined && last.kind === "OmittedExpression"
+            ? "never"
+            : "onBreak";
+    }
+    /**
+     * Trailing-comma policy for an array or object literal.
+     *
+     * Two positions make the comma load-bearing rather than cosmetic.
+     *
+     * A trailing elision is a **value**: the comma is the token that materializes
+     * the hole, so `["a", ]` has one element and `["a", ,]` has two. The legacy
+     * printer emits it in every layout, so this printer emits it in every layout
+     * too; leaving it to the break would make the same node mean different things
+     * at different widths.
+     *
+     * A destructuring **assignment target** is the same node kind as an rvalue
+     * literal, but ECMAScript forbids a comma after its `AssignmentRestElement` /
+     * `AssignmentRestProperty`: `[a, ...rest,] = source` is a syntax error, while
+     * the identical rvalue `[a, ...rest,]` is legal. Only the target position
+     * suppresses it, so the rvalue twin keeps its break comma.
+     */
+    literalTrailingComma(elements, assignmentTarget) {
+        const last = elements[elements.length - 1];
+        if (last === undefined)
+            return "onBreak";
+        if (last.kind === "OmittedExpression")
+            return "always";
+        return assignmentTarget &&
+            (last.kind === "SpreadElement" || last.kind === "SpreadAssignment")
+            ? "never"
+            : "onBreak";
     }
     params(params) {
         return this.delim("(", params.map((p) => this.emit(p)), ")", {
@@ -159,7 +210,7 @@ class TsPrinter {
     }
     args(args) {
         return this.delim("(", args.map((a) => this.expressionForDisallowedComma(a)), ")", {
-            trailingComma: true,
+            trailingComma: this.argsTrailingComma(args),
         });
     }
     modifiers(mods, decoratorsOnNewLine) {
@@ -183,14 +234,56 @@ class TsPrinter {
             ])
             : "";
     }
+    /**
+     * Lay out a JSX element's or fragment's children.
+     *
+     * A line break between JSX children is not cosmetic. JSX deletes a
+     * whitespace-only text child that contains a newline and trims
+     * whitespace-carrying-a-newline off both edges of every other text child, so
+     * a break introduced only because the group did not fit changes what the
+     * component renders: `<div>Hello there, {name}!</div>` becomes `Hello
+     * there,NAME!`, and the separator in `<div>{a} {b}</div>` disappears
+     * outright.
+     *
+     * Children are therefore laid out across lines only when the break survives
+     * that transformation unchanged: every text child must carry non-whitespace
+     * content, must not begin or end with whitespace, and must not sit next to
+     * another text child, since inserting a newline between two of them would
+     * merge into one text with a space in the middle. Otherwise the children are
+     * emitted verbatim on one line, whatever `printWidth` says — width may choose
+     * a layout, never a meaning.
+     */
+    jsxChildren(open, children, close) {
+        if (!this.jsxChildrenMayBreak(children))
+            return concat([open, concat(children.map((c) => this.emit(c))), close]);
+        return group(concat([
+            open,
+            indent(concat(children.map((c) => concat([softline, this.emit(c)])))),
+            softline,
+            close,
+        ]));
+    }
+    jsxChildrenMayBreak(children) {
+        return children.every((child, index) => child.kind !== "JsxText" ||
+            (isBreakSafeJsxText(child.text) &&
+                children[index + 1]?.kind !== "JsxText"));
+    }
     optType(type) {
         return type ? concat([": ", this.emit(type)]) : "";
     }
     optBody(body) {
         return body ? concat([" ", this.emit(body)]) : ";";
     }
-    emit(node) {
-        const body = this.emitNode(node);
+    /**
+     * @param assignmentTarget Whether `node` occupies destructuring
+     *   assignment-target position, where an array or object literal is a pattern
+     *   rather than a value. The flag is set by the assignment and `for…in` /
+     *   `for…of` cases, forwarded by every node that is transparent to it (a
+     *   spread, a property's initializer, a parenthesis, an `=` default), and
+     *   dropped by every other node.
+     */
+    emit(node, assignmentTarget = false) {
+        const body = this.emitNode(node, assignmentTarget);
         const leading = getSyntheticLeadingComments(node);
         const trailing = getSyntheticTrailingComments(node);
         if ((leading === undefined || leading.length === 0) &&
@@ -234,7 +327,7 @@ class TsPrinter {
             "*/",
         ]);
     }
-    emitNode(node) {
+    emitNode(node, assignmentTarget) {
         switch (node.kind) {
             /* names & tokens */
             case "Identifier":
@@ -246,7 +339,7 @@ class TsPrinter {
             case "Token":
                 return node.token;
             case "Decorator":
-                return concat(["@", this.leftSideExpression(node.expression)]);
+                return concat(["@", this.leftSideExpression(node.expression, false)]);
             /* literals */
             case "StringLiteral":
                 return escapeString(node.text, node.singleQuote);
@@ -256,18 +349,21 @@ class TsPrinter {
                 return node.text;
             /* expressions */
             case "ArrayLiteralExpression":
-                return this.delim("[", node.elements.map((e) => this.expressionForDisallowedComma(e)), "]", { trailingComma: true, forceBreak: node.multiLine === true });
+                return this.delim("[", node.elements.map((e) => this.expressionForDisallowedComma(e, assignmentTarget)), "]", {
+                    trailingComma: this.literalTrailingComma(node.elements, assignmentTarget),
+                    forceBreak: node.multiLine === true,
+                });
             case "ObjectLiteralExpression":
-                return this.delim("{", node.properties.map((p) => this.emit(p)), "}", {
+                return this.delim("{", node.properties.map((p) => this.emit(p, assignmentTarget)), "}", {
                     space: true,
-                    trailingComma: true,
+                    trailingComma: this.literalTrailingComma(node.properties, assignmentTarget),
                     forceBreak: node.multiLine === true,
                 });
             case "PropertyAssignment":
                 return concat([
                     this.emit(node.name),
                     ": ",
-                    this.expressionForDisallowedComma(node.initializer),
+                    this.expressionForDisallowedComma(node.initializer, assignmentTarget),
                 ]);
             case "ShorthandPropertyAssignment":
                 return concat([
@@ -282,24 +378,24 @@ class TsPrinter {
             case "SpreadAssignment":
                 return concat([
                     "...",
-                    this.expressionForDisallowedComma(node.expression),
+                    this.expressionForDisallowedComma(node.expression, assignmentTarget),
                 ]);
             case "PropertyAccessExpression":
                 return concat([
-                    this.leftSideExpression(node.expression),
+                    this.leftSideExpression(node.expression, false),
                     ".",
                     this.emit(node.name),
                 ]);
             case "ElementAccessExpression":
                 return concat([
-                    this.leftSideExpression(node.expression),
+                    this.leftSideExpression(node.expression, false),
                     "[",
                     this.expressionForDisallowedComma(node.argumentExpression),
                     "]",
                 ]);
             case "CallExpression":
                 return concat([
-                    this.leftSideExpression(node.expression),
+                    this.leftSideExpression(node.expression, false),
                     this.typeArguments(node.typeArguments),
                     this.args(node.arguments),
                 ]);
@@ -311,11 +407,19 @@ class TsPrinter {
                     this.args(node.arguments ?? []),
                 ]);
             case "ParenthesizedExpression":
-                return concat(["(", this.emit(node.expression), ")"]);
+                return concat(["(", this.emit(node.expression, assignmentTarget), ")"]);
             case "BinaryExpression":
+                // the left side of `=` is a destructuring assignment target, both for a
+                // top-level assignment and for a `[a = init]` default inside one
                 return group(concat([
-                    this.binaryOperand(node.operator, node.left, true),
-                    " ",
+                    this.binaryOperand(node.operator, node.left, true, undefined, node.operator === SyntaxKind.EqualsToken),
+                    // Every operator but the comma is written with a space on each
+                    // side. The comma is punctuation that attaches to what precedes it:
+                    // `CommaListExpression` joins with ", ", the legacy printer and the
+                    // repository's pinned Prettier both emit `a, b`, and this factory's
+                    // own JSDoc for `createComma` shows `(a, b)`. Only the printer
+                    // disagreed, with `a , b`.
+                    node.operator === SyntaxKind.CommaToken ? "" : " ",
                     node.operator,
                     indent(concat([
                         line,
@@ -375,11 +479,11 @@ class TsPrinter {
                     this.emit(node.type),
                 ]);
             case "NonNullExpression":
-                return concat([this.leftSideExpression(node.expression), "!"]);
+                return concat([this.leftSideExpression(node.expression, false), "!"]);
             case "SpreadElement":
                 return concat([
                     "...",
-                    this.expressionForDisallowedComma(node.expression),
+                    this.expressionForDisallowedComma(node.expression, assignmentTarget),
                 ]);
             case "AwaitExpression":
                 return concat(["await ", this.prefixUnaryOperand(node.expression)]);
@@ -412,7 +516,7 @@ class TsPrinter {
                 ]);
             case "TupleTypeNode":
                 return this.delim("[", node.elements.map((e) => this.emit(e)), "]", {
-                    trailingComma: true,
+                    trailingComma: "onBreak",
                 });
             case "ParenthesizedTypeNode":
                 return concat(["(", this.emit(node.type), ")"]);
@@ -432,8 +536,11 @@ class TsPrinter {
             case "TypeQueryNode":
                 return concat(["typeof ", this.emit(node.exprName)]);
             case "ExpressionWithTypeArguments":
+                // heritage clauses take a LeftHandSideExpression: `class A extends
+                // (X || Y) {}` does not parse without the parentheses, and a bare comma
+                // sequence silently becomes two base classes
                 return concat([
-                    this.emit(node.expression),
+                    this.leftSideExpression(node.expression, false),
                     this.typeArguments(node.typeArguments),
                 ]);
             case "PropertySignature":
@@ -684,10 +791,16 @@ class TsPrinter {
                     named.push(this.emit(node.name));
                 if (node.namedBindings)
                     named.push(this.emit(node.namedBindings));
-                return concat([node.isTypeOnly ? "type " : "", join(", ", named)]);
+                // The phase modifier is the keyword itself, so it prints as written —
+                // `type` and `defer` both reach here, where a boolean could only ever
+                // have produced the first.
+                return concat([
+                    node.phaseModifier ? `${node.phaseModifier} ` : "",
+                    join(", ", named),
+                ]);
             }
             case "NamedImports":
-                return this.delim("{", node.elements.map((e) => this.emit(e)), "}", { space: true, trailingComma: true });
+                return this.delim("{", node.elements.map((e) => this.emit(e)), "}", { space: true, trailingComma: "onBreak" });
             case "ImportSpecifier":
                 return concat([
                     node.isTypeOnly ? "type " : "",
@@ -710,7 +823,7 @@ class TsPrinter {
                     ";",
                 ]);
             case "NamedExports":
-                return this.delim("{", node.elements.map((e) => this.emit(e)), "}", { space: true, trailingComma: true });
+                return this.delim("{", node.elements.map((e) => this.emit(e)), "}", { space: true, trailingComma: "onBreak" });
             case "ExportSpecifier":
                 return concat([
                     node.isTypeOnly ? "type " : "",
@@ -747,7 +860,7 @@ class TsPrinter {
             case "ForInStatement":
                 return concat([
                     "for (",
-                    this.emit(node.initializer),
+                    this.emit(node.initializer, true),
                     " in ",
                     this.emit(node.expression),
                     ") ",
@@ -758,7 +871,7 @@ class TsPrinter {
                     "for ",
                     node.awaitModifier ? "await " : "",
                     "(",
-                    this.emit(node.initializer),
+                    this.emit(node.initializer, true),
                     " of ",
                     this.emit(node.expression),
                     ") ",
@@ -863,7 +976,17 @@ class TsPrinter {
             case "ModuleDeclaration":
                 return concat([
                     this.modifiers(node.modifiers, true),
-                    node.name.kind === "StringLiteral" ? "module " : "namespace ",
+                    // A string-literal name is always `module "…"`; the flag says nothing
+                    // there. For an identifier the flag is what chooses, which is the
+                    // upstream rule and the one `createModuleDeclaration` documents:
+                    // `namespace A` with `NodeFlags.Namespace`, `module A` without it.
+                    // The printer used to read the name kind alone, so an identifier
+                    // always printed `namespace` and the flag it published was inert.
+                    node.name.kind === "StringLiteral"
+                        ? "module "
+                        : node.flags === NodeFlags.Namespace
+                            ? "namespace "
+                            : "module ",
                     this.emit(node.name),
                     node.body ? concat([" ", this.emit(node.body)]) : ";",
                 ]);
@@ -970,6 +1093,19 @@ class TsPrinter {
                     node.isTypeOf ? "typeof " : "",
                     "import(",
                     this.emit(node.argument),
+                    // An import type spells its attributes as a second call argument —
+                    // `import("m", { with: { … } }).T` — not as the trailing `with { … }`
+                    // an import declaration uses, so the elements are wrapped here rather
+                    // than emitted through the attributes node's own form.
+                    node.attributes && node.attributes.elements.length > 0
+                        ? concat([
+                            ", { ",
+                            node.attributes.token,
+                            ": { ",
+                            join(", ", node.attributes.elements.map((e) => this.emit(e))),
+                            " } }",
+                        ])
+                        : "",
                     ")",
                     node.qualifier ? concat([".", this.emit(node.qualifier)]) : "",
                     this.typeArguments(node.typeArguments),
@@ -1009,7 +1145,7 @@ class TsPrinter {
                 ]);
             case "TaggedTemplateExpression":
                 return concat([
-                    this.leftSideExpression(node.tag),
+                    this.leftSideExpression(node.tag, false),
                     this.typeArguments(node.typeArguments),
                     this.emit(node.template),
                 ]);
@@ -1077,13 +1213,13 @@ class TsPrinter {
                 ]);
             case "PropertyAccessChain":
                 return concat([
-                    this.leftSideExpression(node.expression),
+                    this.leftSideExpression(node.expression, true),
                     node.questionDotToken ? "?." : ".",
                     this.emit(node.name),
                 ]);
             case "ElementAccessChain":
                 return concat([
-                    this.leftSideExpression(node.expression),
+                    this.leftSideExpression(node.expression, true),
                     node.questionDotToken ? "?." : "",
                     "[",
                     this.expressionForDisallowedComma(node.argumentExpression),
@@ -1091,21 +1227,16 @@ class TsPrinter {
                 ]);
             case "CallChain":
                 return concat([
-                    this.leftSideExpression(node.expression),
+                    this.leftSideExpression(node.expression, true),
                     node.questionDotToken ? "?." : "",
                     this.typeArguments(node.typeArguments),
                     this.args(node.arguments),
                 ]);
             case "NonNullChain":
-                return concat([this.leftSideExpression(node.expression), "!"]);
+                return concat([this.leftSideExpression(node.expression, true), "!"]);
             /* jsx */
             case "JsxElement":
-                return group(concat([
-                    this.emit(node.openingElement),
-                    indent(concat(node.children.map((c) => concat([softline, this.emit(c)])))),
-                    softline,
-                    this.emit(node.closingElement),
-                ]));
+                return this.jsxChildren(this.emit(node.openingElement), node.children, this.emit(node.closingElement));
             case "JsxSelfClosingElement":
                 return concat([
                     "<",
@@ -1125,18 +1256,15 @@ class TsPrinter {
             case "JsxClosingElement":
                 return concat(["</", this.emit(node.tagName), ">"]);
             case "JsxFragment":
-                return group(concat([
-                    this.emit(node.openingFragment),
-                    indent(concat(node.children.map((c) => concat([softline, this.emit(c)])))),
-                    softline,
-                    this.emit(node.closingFragment),
-                ]));
+                return this.jsxChildren(this.emit(node.openingFragment), node.children, this.emit(node.closingFragment));
             case "JsxOpeningFragment":
                 return "<>";
             case "JsxClosingFragment":
                 return "</>";
             case "JsxText":
-                return node.text;
+                // the one node emitted as unquoted source text: its trailing spaces are
+                // rendered content, so they must survive the layout engine's line trim
+                return raw(node.text);
             case "JsxAttribute":
                 return node.initializer === undefined
                     ? this.emit(node.name)
@@ -1353,6 +1481,10 @@ class TsPrinter {
                         ? concat([this.emit(node.importClause), " from "])
                         : "",
                     this.emit(node.moduleSpecifier),
+                    // `@import { a } from "m" with { type: "json" }` — the same trailing
+                    // form an import declaration uses, which is why the attributes node
+                    // emits itself here rather than being unwrapped.
+                    node.attributes ? concat([" ", this.emit(node.attributes)]) : "",
                     this.jsDocComment(node.comment),
                 ]);
             case "JSDocTemplateTag":
@@ -1384,19 +1516,67 @@ class TsPrinter {
      * re-associate — matching the legacy printer's parenthesizer rules.
      */
     parenthesizedExpression(expression) {
-        return expression.kind === "ParenthesizedExpression"
+        return this.skipPartiallyEmittedExpressions(expression).kind ===
+            "ParenthesizedExpression"
             ? this.emit(expression)
             : concat(["(", this.emit(expression), ")"]);
     }
-    expressionForDisallowedComma(expression) {
+    /**
+     * The partial-emission wrapper carries transform provenance but emits no
+     * syntax of its own, so every grammar predicate must inspect its inner node.
+     */
+    skipPartiallyEmittedExpressions(expression) {
+        while (expression.kind === "PartiallyEmittedExpression")
+            expression = expression.expression;
+        return expression;
+    }
+    expressionForDisallowedComma(expression, assignmentTarget = false) {
         return this.expressionPrecedence(expression) > ExpressionPrecedence.Comma
-            ? this.emit(expression)
+            ? this.emit(expression, assignmentTarget)
             : this.parenthesizedExpression(expression);
     }
-    leftSideExpression(expression) {
-        return this.isLeftHandSideExpression(expression)
-            ? this.emit(expression)
-            : this.parenthesizedExpression(expression);
+    /**
+     * Emit an operand the grammar requires to be a `LeftHandSideExpression`,
+     * mirroring the legacy parenthesizer's
+     * `parenthesizeLeftSideOfAccess(expression, optionalChain)`.
+     *
+     * `optionalChain` is the **consuming** node's own chain-ness, not the
+     * operand's. An optional chain may be emitted bare only when the node
+     * consuming it continues the same chain: `a?.b?.()` is one chain, while
+     * `(a?.b)()` is a plain call on the chain's value. Emitting the second as
+     * `a?.b()` re-parses as the first, which stops throwing on a nullish head,
+     * and in `new`, tagged-template and decorator position it does not compile at
+     * all.
+     */
+    leftSideExpression(expression, optionalChain) {
+        return this.leftSideNeedsParentheses(expression, optionalChain)
+            ? this.parenthesizedExpression(expression)
+            : this.emit(expression);
+    }
+    /**
+     * Whether {@link leftSideExpression} wraps this operand.
+     *
+     * The legacy rule also parenthesizes an argument-less `new` here, because it
+     * prints `new X` bare and `new X.y` would re-parse with `y` on the target.
+     * This printer always emits the argument list, so `new X().y` already says
+     * what the tree says and needs no wrapper.
+     */
+    leftSideNeedsParentheses(expression, optionalChain) {
+        if (!this.isLeftHandSideExpression(expression))
+            return true;
+        return !optionalChain && this.isOptionalChain(expression);
+    }
+    isOptionalChain(expression) {
+        expression = this.skipPartiallyEmittedExpressions(expression);
+        switch (expression.kind) {
+            case "CallChain":
+            case "ElementAccessChain":
+            case "NonNullChain":
+            case "PropertyAccessChain":
+                return true;
+            default:
+                return false;
+        }
     }
     newExpressionTarget(expression) {
         return this.newExpressionTargetNeedsParentheses(expression)
@@ -1407,20 +1587,69 @@ class TsPrinter {
      * Whether a `new` target must be parenthesized to keep its call arguments
      * from re-binding to the `new` — mirroring the legacy printer's
      * `parenthesizeExpressionOfNew`. A `new` target is grammatically a
-     * `MemberExpression`, so a call anywhere on the target's left spine (not just
-     * a direct one: `new (f().bar)()`, `new (a.b().c)()`) would otherwise
-     * re-parse with the call's arguments consumed by the `new` — a different
-     * program. Argument-less `new` on the spine is kept parenthesized for
-     * continuity with the direct case, though this printer always prints an
-     * argument list, which already disambiguates it.
+     * `MemberExpression`, so a call anywhere on the target's printed left spine
+     * (not just a direct one: `new (f().bar)()`, `new (a.b().c)()`) would
+     * otherwise re-parse with the call's arguments consumed by the `new` — a
+     * different program. Argument-less `new` on the spine is kept parenthesized
+     * for continuity with the direct case, though this printer always prints an
+     * argument list, which already disambiguates it. Anything else falls back to
+     * the shared left-side rule, which is what parenthesizes an optional-chain
+     * target (`new (a?.b)()`, TS1209 without it).
      */
     newExpressionTargetNeedsParentheses(expression) {
-        if (!this.isLeftHandSideExpression(expression))
-            return true;
-        const leftmost = this.leftmostExpression(expression, true);
-        return (leftmost.kind === "CallExpression" ||
-            leftmost.kind === "CallChain" ||
-            (leftmost.kind === "NewExpression" && leftmost.arguments === undefined));
+        const leftmost = this.leftmostPrintedExpression(expression);
+        if (leftmost !== undefined) {
+            if (leftmost.kind === "CallExpression" || leftmost.kind === "CallChain")
+                return true;
+            if (leftmost.kind === "NewExpression")
+                return leftmost.arguments === undefined;
+        }
+        return this.leftSideNeedsParentheses(expression, false);
+    }
+    /**
+     * The node whose own text opens `expression`'s printed form, or `undefined`
+     * when that text opens with a printer-inserted `(`.
+     *
+     * The legacy factory parenthesizes each operand as it builds the node, so its
+     * `getLeftmostExpression` walk halts on the resulting
+     * `ParenthesizedExpression`. This printer decides the same parentheses at
+     * emit time instead, so the walk has to ask {@link leftSideNeedsParentheses}
+     * the same question directly; otherwise `new` re-wraps a target whose call is
+     * already behind parentheses, and `new (f?.()).bar()` comes out as `new
+     * ((f?.()).bar)()`. Calls halt the walk, matching the legacy
+     * `stopAtCallExpressions` mode this predicate is the only user of.
+     */
+    leftmostPrintedExpression(expression) {
+        expression = this.skipPartiallyEmittedExpressions(expression);
+        switch (expression.kind) {
+            case "CallExpression":
+            case "CallChain":
+                return expression;
+            case "ElementAccessExpression":
+            case "NonNullExpression":
+            case "PropertyAccessExpression":
+                return this.leftmostPrintedLeftSide(expression.expression, false);
+            case "ElementAccessChain":
+            case "NonNullChain":
+            case "PropertyAccessChain":
+                return this.leftmostPrintedLeftSide(expression.expression, true);
+            case "TaggedTemplateExpression":
+                return this.leftmostPrintedLeftSide(expression.tag, false);
+            case "AsExpression":
+            case "SatisfiesExpression":
+                return this.leftmostPrintedExpression(expression.expression);
+            case "BinaryExpression":
+                return this.leftmostPrintedExpression(expression.left);
+            case "ConditionalExpression":
+                return this.leftmostPrintedExpression(expression.condition);
+            default:
+                return expression;
+        }
+    }
+    leftmostPrintedLeftSide(operand, optionalChain) {
+        return this.leftSideNeedsParentheses(operand, optionalChain)
+            ? undefined
+            : this.leftmostPrintedExpression(operand);
     }
     prefixUnaryOperand(operand, operator) {
         const body = this.isUnaryExpression(operand)
@@ -1469,42 +1698,45 @@ class TsPrinter {
             ? this.expressionForDisallowedComma(expression)
             : this.parenthesizedExpression(expression);
     }
-    binaryOperand(operator, operand, isLeftSide, leftOperand) {
+    binaryOperand(operator, operand, isLeftSide, leftOperand, assignmentTarget = false) {
         return this.binaryOperandNeedsParentheses(operator, operand, isLeftSide, leftOperand)
             ? this.parenthesizedExpression(operand)
-            : this.emit(operand);
+            : this.emit(operand, assignmentTarget);
     }
     binaryOperandNeedsParentheses(operator, operand, isLeftSide, leftOperand) {
-        if (operand.kind === "ParenthesizedExpression")
+        const emittedOperand = this.skipPartiallyEmittedExpressions(operand);
+        if (emittedOperand.kind === "ParenthesizedExpression")
             return false;
         if (operator === SyntaxKind.AsteriskAsteriskToken &&
             isLeftSide &&
-            this.expressionPrecedence(operand) === ExpressionPrecedence.Unary)
+            this.expressionPrecedence(emittedOperand) === ExpressionPrecedence.Unary)
             return true;
-        if (operand.kind === "BinaryExpression" &&
-            this.mixingBinaryOperatorsRequiresParentheses(operator, operand.operator))
+        if (emittedOperand.kind === "BinaryExpression" &&
+            this.mixingBinaryOperatorsRequiresParentheses(operator, emittedOperand.operator))
             return true;
         const operatorPrecedence = this.binaryOperatorPrecedence(operator);
-        const operandPrecedence = this.expressionPrecedence(operand);
+        const operandPrecedence = this.expressionPrecedence(emittedOperand);
         if (operandPrecedence < operatorPrecedence)
             return true;
         if (operandPrecedence > operatorPrecedence)
             return false;
         if (isLeftSide)
             return this.binaryOperatorAssociativity(operator) === Associativity.Right;
-        if (operand.kind === "BinaryExpression" && operand.operator === operator) {
+        if (emittedOperand.kind === "BinaryExpression" &&
+            emittedOperand.operator === operator) {
             if (this.operatorHasAssociativeProperty(operator))
                 return false;
             if (operator === SyntaxKind.PlusToken &&
                 leftOperand !== undefined &&
                 this.literalKindOfBinaryPlusOperand(leftOperand) !== undefined &&
                 this.literalKindOfBinaryPlusOperand(leftOperand) ===
-                    this.literalKindOfBinaryPlusOperand(operand))
+                    this.literalKindOfBinaryPlusOperand(emittedOperand))
                 return false;
         }
-        return this.expressionAssociativity(operand) === Associativity.Left;
+        return this.expressionAssociativity(emittedOperand) === Associativity.Left;
     }
     expressionPrecedence(expression) {
+        expression = this.skipPartiallyEmittedExpressions(expression);
         switch (expression.kind) {
             case "CommaListExpression":
                 return ExpressionPrecedence.Comma;
@@ -1546,6 +1778,7 @@ class TsPrinter {
         }
     }
     expressionAssociativity(expression) {
+        expression = this.skipPartiallyEmittedExpressions(expression);
         switch (expression.kind) {
             case "NewExpression":
                 return expression.arguments === undefined
@@ -1649,6 +1882,7 @@ class TsPrinter {
             operator === SyntaxKind.CommaToken);
     }
     literalKindOfBinaryPlusOperand(expression) {
+        expression = this.skipPartiallyEmittedExpressions(expression);
         switch (expression.kind) {
             case "StringLiteral":
             case "NumericLiteral":
@@ -1671,6 +1905,7 @@ class TsPrinter {
         return this.expressionPrecedence(expression) >= ExpressionPrecedence.Unary;
     }
     isLeftHandSideExpression(expression) {
+        expression = this.skipPartiallyEmittedExpressions(expression);
         switch (expression.kind) {
             case "ArrowFunction":
             case "ClassExpression":
@@ -1701,18 +1936,19 @@ class TsPrinter {
     }
     /**
      * Walk to the expression's leftmost node — the one that starts its printed
-     * text. With `stopAtCall`, calls terminate the walk instead of being walked
-     * through, matching the legacy `getLeftmostExpression`'s
-     * `stopAtCallExpressions` mode used by the `new`-target parenthesizer.
+     * text — matching the legacy `getLeftmostExpression`.
+     *
+     * Used by the statement, concise-body and export-default predicates, which
+     * ask only whether the text opens with a `function`, `class` or `{` token.
+     * The `new`-target predicate needs the printed left edge instead and uses
+     * {@link leftmostPrintedExpression}.
      */
-    leftmostExpression(expression, stopAtCall = false) {
+    leftmostExpression(expression) {
+        expression = this.skipPartiallyEmittedExpressions(expression);
         switch (expression.kind) {
+            case "AsExpression":
             case "CallExpression":
             case "CallChain":
-                if (stopAtCall)
-                    return expression;
-                return this.leftmostExpression(expression.expression, stopAtCall);
-            case "AsExpression":
             case "ElementAccessExpression":
             case "ElementAccessChain":
             case "NonNullExpression":
@@ -1720,18 +1956,19 @@ class TsPrinter {
             case "PropertyAccessExpression":
             case "PropertyAccessChain":
             case "SatisfiesExpression":
-                return this.leftmostExpression(expression.expression, stopAtCall);
+                return this.leftmostExpression(expression.expression);
             case "BinaryExpression":
-                return this.leftmostExpression(expression.left, stopAtCall);
+                return this.leftmostExpression(expression.left);
             case "ConditionalExpression":
-                return this.leftmostExpression(expression.condition, stopAtCall);
+                return this.leftmostExpression(expression.condition);
             case "TaggedTemplateExpression":
-                return this.leftmostExpression(expression.tag, stopAtCall);
+                return this.leftmostExpression(expression.tag);
             default:
                 return expression;
         }
     }
     needsPrefixUnaryGap(operator, operand) {
+        operand = this.skipPartiallyEmittedExpressions(operand);
         if (operator === undefined || operand.kind !== "PrefixUnaryExpression")
             return false;
         return ((operator === SyntaxKind.PlusToken &&
@@ -1851,15 +2088,84 @@ const escapeTemplateText = (text) => text
     .replace(/\$\{/g, "\\${")
     .replace(/\r\n/g, "\\r\\n")
     .replace(/\r/g, "\\r");
+/**
+ * Whether a JSX text child means the same thing with a line break and
+ * indentation around it.
+ *
+ * JSX drops a whitespace-only child that contains a newline and trims an edge
+ * whose whitespace contains one, so only a child with non-whitespace content
+ * and no edge whitespace survives being moved onto its own line. Newlines
+ * _inside_ the text are unaffected, because JSX collapses each interior line
+ * break to a single space in either layout.
+ */
+const isBreakSafeJsxText = (text) => text.length !== 0 && !/^\s/.test(text) && !/\s$/.test(text);
+/**
+ * Escape a string literal's text so the printed program holds the value the AST
+ * carries.
+ *
+ * The old set was the backslash, LF, CR, TAB and the active quote. Everything
+ * else was emitted raw, which is three separate hazards rather than a cosmetic
+ * gap: a C0 control or DEL lands in the generated file as itself; U+2028 and
+ * U+2029 terminate a string literal in any JavaScript engine predating ES2019,
+ * so the emitted program does not parse; and a lone surrogate becomes U+FFFD
+ * the moment the text is written as UTF-8, so the generated program holds a
+ * different string than the caller built.
+ *
+ * Iterated by code point rather than matched by a pattern. That is what makes
+ * the surrogate case fall out instead of needing a rule: a well-formed pair
+ * arrives as one two-unit string and passes through, and a lone surrogate
+ * arrives as a single unit whose code point is in the surrogate range.
+ */
 const escapeString = (text, singleQuote) => {
-    const escaped = text
-        .replace(/\\/g, "\\\\")
-        .replace(/\n/g, "\\n")
-        .replace(/\r/g, "\\r")
-        .replace(/\t/g, "\\t");
-    return singleQuote === true
-        ? `'${escaped.replace(/'/g, "\\'")}'`
-        : `"${escaped.replace(/"/g, '\\"')}"`;
+    const quote = singleQuote === true ? "'" : '"';
+    let escaped = "";
+    for (const ch of text) {
+        if (ch === "\\") {
+            escaped += "\\\\";
+            continue;
+        }
+        if (ch === quote) {
+            escaped += "\\" + ch;
+            continue;
+        }
+        // The inactive quote is ordinary text and stays as written.
+        const code = ch.codePointAt(0) ?? 0;
+        const lone = code >= 0xd800 && code <= 0xdfff;
+        if (ch.length === 2 ||
+            (code >= 0x20 &&
+                code !== 0x7f &&
+                code !== 0x2028 &&
+                code !== 0x2029 &&
+                !lone)) {
+            escaped += ch;
+            continue;
+        }
+        switch (code) {
+            case 0x08:
+                escaped += "\\b";
+                continue;
+            case 0x09:
+                escaped += "\\t";
+                continue;
+            case 0x0a:
+                escaped += "\\n";
+                continue;
+            case 0x0b:
+                escaped += "\\v";
+                continue;
+            case 0x0c:
+                escaped += "\\f";
+                continue;
+            case 0x0d:
+                escaped += "\\r";
+                continue;
+        }
+        escaped +=
+            code > 0xff
+                ? "\\u" + code.toString(16).padStart(4, "0")
+                : "\\x" + code.toString(16).padStart(2, "0");
+    }
+    return `${quote}${escaped}${quote}`;
 };
 const ExpressionPrecedence = {
     Comma: 0,