@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/print_nodes_function.go

@@ -113,6 +113,16 @@ func printParenthesizedExpression(ctx *PrintContext, node *shimast.Node) (Doc, b
   if paren == nil || paren.Expression == nil {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
+  // A comment around the parens (`(/* c */ x)`, `(x /* c */)`) would be dropped
+  // by the minted `(`/`)` — the parens are not AST children, so a nested
+  // ParenthesizedExpression's gap comment slips past the top-level print-width
+  // scan and is lost on reflow. Bail to verbatim and report UNCOVERED (hard
+  // `false`, not `!nodeSpansMultipleLines`) so an enclosing reflow abstains
+  // instead of breaking around this single-line verbatim paren, like the
+  // object/array/call printers.
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
   inner, covered := PrintNode(ctx, paren.Expression)
   return Concat(Text("("), inner, Text(")")), covered
 }
@@ -180,6 +190,16 @@ func printBlock(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   bodyParts := make([]Doc, 0, len(items)*2)
   for i, item := range items {
     if i > 0 {
+      // A lone leading-semicolon ASI guard stays glued to the statement
+      // it protects (`;(expr)`): when the previous statement is an empty
+      // `;` sitting directly against this one in the source, emit no line
+      // break, so the reflow agrees with format/orphan-semi instead of
+      // ping-ponging it back onto two lines every cascade pass.
+      if stmts[i-1].Kind == shimast.KindEmptyStatement &&
+        !rangeHasNewline(ctx.Source, stmts[i-1].End(), shimscanner.SkipTrivia(ctx.Source, stmts[i].Pos())) {
+        bodyParts = append(bodyParts, item)
+        continue
+      }
       if blankLineBetweenStatements(ctx.Source, stmts[i-1].End(), stmts[i].Pos()) {
         bodyParts = append(bodyParts, Literalline())
       }
@@ -196,6 +216,21 @@ func printBlock(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   return doc, covered
 }
 
+// rangeHasNewline reports whether src[start:end) contains a newline. Used
+// to detect whether a leading-semicolon guard sits on the same line as
+// the statement it protects.
+func rangeHasNewline(src string, start, end int) bool {
+  if start < 0 || end > len(src) || end <= start {
+    return false
+  }
+  for i := start; i < end; i++ {
+    if src[i] == '\n' {
+      return true
+    }
+  }
+  return false
+}
+
 // blankLineBetweenStatements reports whether the source gap between the
 // end of one block statement and the start of the next contains a blank
 // line — two or more newlines. printBlock uses it to keep a single
@@ -319,6 +354,14 @@ func printReturnStatement(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if !tailIsCleanTerminator(ctx.Source, stmt.Expression.End(), node.End()) {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
+  // A comment between `return` and its argument (`return /* c */ x`) lives in
+  // the argument's leading trivia and would be dropped by the minted
+  // `Text("return ")` — the gap is not an AST child, and a return statement is
+  // only reached as a nested child of a block, so the outer print-width and
+  // block scans mask it. Bail to verbatim (uncovered) like the round-7 printers.
+  if gapHasComment(ctx.Source, stmt.Expression.Pos(), shimscanner.SkipTrivia(ctx.Source, stmt.Expression.Pos())) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
   exprDoc, covered := PrintNode(ctx, stmt.Expression)
   parts := []Doc{Text("return "), exprDoc}
   if sourceHasStatementTerminator(ctx.Source, node.End()) {

package/linthost/print_nodes_imports.go

@@ -2,6 +2,7 @@ package linthost
 
 import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // printNamedImports renders `{ a, b, c }` inside an import declaration.
@@ -115,39 +116,88 @@ func printImportDeclaration(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if clauseData == nil || clauseData.NamedBindings == nil {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
-  if clauseData.NamedBindings.Kind != shimast.KindNamedImports {
+  nb := clauseData.NamedBindings
+  if nb.Kind != shimast.KindNamedImports {
     // Namespace imports (`import * as ns from "x"`) have no
     // reflow surface; leave them alone.
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
-  if clause.Name() != nil {
-    // `import Default, { … } from "x"` — keep verbatim for v1.
-    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
-  }
   // AttributeClause (`with { ... }` / `assert { ... }`) lives after
   // the module specifier. Fall back to verbatim when present so we
   // don't drop attributes silently.
   if imp.Attributes != nil {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
+  // A comment between specifiers would be dropped by the fresh separators.
+  if listHasInterItemComments(ctx, nb) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  ni := nb.AsNamedImports()
+  if ni == nil || ni.Elements == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
 
-  // Bracketed clause prefix: `import ` (and optional `type `).
+  // Bracketed clause prefix: `import `, `import type `, or — when a default
+  // binding precedes the named clause — `import Default, `. A default never
+  // combines with `type` (TS forbids `import type D, { … }`), so the two
+  // prefix forms are exclusive.
   prefix := "import "
   if clause.IsTypeOnly() {
+    // A comment in the `type`->`{` gap (`import type /* c */ { … }`) would be
+    // dropped by the minted prefix. The `type` keyword is a clause modifier
+    // flag, not a child node, so the top-level scan masks it (it sits inside the
+    // ImportClause span) and the `nb`-scoped guard starts at `{`. Bail to
+    // verbatim, like the default-binding gap below.
+    if gapHasComment(ctx.Source, shimscanner.SkipTrivia(ctx.Source, clause.Pos()), shimscanner.SkipTrivia(ctx.Source, nb.Pos())) {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
     prefix = "import type "
   }
-  named, covered := PrintNode(ctx, clauseData.NamedBindings)
+  if name := clause.Name(); name != nil {
+    // A comment in the default-binding-to-brace gap (`import D /* c */, { … }`)
+    // would be dropped by the minted `, ` prefix. That gap is not a direct child
+    // of the import node, so the top-level scan masks it and the `nb`-scoped
+    // guard above starts at `{` — same class as printReturnStatement's leading
+    // gap. Bail to verbatim.
+    if gapHasComment(ctx.Source, name.End(), shimscanner.SkipTrivia(ctx.Source, nb.Pos())) {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    prefix = "import " + identifierText(name) + ", "
+  }
+
+  items := make([]Doc, 0, len(ni.Elements.Nodes))
+  covered := true
+  for _, spec := range ni.Elements.Nodes {
+    if spec == nil {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    doc, childCovered := PrintNode(ctx, spec)
+    covered = covered && childCovered
+    items = append(items, doc)
+  }
+
   moduleSpec := verbatim(ctx, imp.ModuleSpecifier)
   covered = covered && !nodeSpansMultipleLines(ctx, imp.ModuleSpecifier)
-  parts := []Doc{Text(prefix), named, Text(" from "), moduleSpec}
+  suffixParts := []Doc{Text(" from "), moduleSpec}
   if sourceHasStatementTerminator(ctx.Source, node.End()) {
-    // Preserve the user's terminator decision. Emitting `;`
-    // unconditionally would collide with `format/semi`'s
-    // zero-width insert on the same cascade pass and produce
-    // `;;` — `format/semi` owns terminator placement.
-    parts = append(parts, Text(";"))
+    // Preserve the user's terminator decision. Emitting `;` unconditionally
+    // would collide with `format/semi`'s zero-width insert and produce `;;`.
+    suffixParts = append(suffixParts, Text(";"))
   }
-  return Concat(parts...), covered
+
+  // The whole declaration renders as one Group via Prefix/Suffix, so the
+  // named-brace break decision counts the ` from "..."` tail: a brace that
+  // fits but whose declaration line overflows still breaks, and a
+  // default-combined import breaks its brace too.
+  return printList(ctx, listShape{
+    Prefix:   Text(prefix),
+    OpenTok:  "{",
+    CloseTok: "}",
+    Items:    items,
+    Space:    true,
+    AddComma: ctx.allowsEs5TrailingComma(),
+    Suffix:   Concat(suffixParts...),
+  }), covered
 }
 
 // sourceHasStatementTerminator reports whether the last non-trivia

package/linthost/print_nodes_list.go

@@ -1,5 +1,30 @@
 package linthost
 
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// listHasInterItemComments reports whether `node` (an object / array literal)
+// carries a comment in a gap between its items or brackets. The list printers
+// mint fresh comma/line separators that have no slot for such trivia, so a
+// reflow would silently delete the comment. When a node nested inside a
+// reflowing parent (an array argument of a call) carries one, the parent's
+// own top-level comment guard cannot see it (it lives inside a child range),
+// so each list printer must check itself and bail to verbatim — reporting the
+// span uncovered so the enclosing reflow abstains and the source round-trips.
+func listHasInterItemComments(ctx *PrintContext, node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  start := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  end := node.End()
+  if start < 0 || end < start || end > len(ctx.Source) {
+    return false
+  }
+  return hasNonChildComments(node, ctx.Source, start, end)
+}
+
 // Shared helpers for comma-separated list printers.
 //
 // Object literals, array literals, call arguments, parameter lists,
@@ -35,11 +60,87 @@ type listShape struct {
   // multi-line callback body does not force every preceding argument
   // onto its own line.
   HugLast bool
+  // HugFirst keeps the FIRST item attached to the open paren and flows
+  // the remaining simple items after it, the mirror of HugLast. The
+  // call-argument printer sets it for the two-argument
+  // `callback, simpleArg` shape Prettier hugs (`foo(() => { … }, x)`).
+  // HugLast and HugFirst are mutually exclusive.
+  HugFirst bool
+  // HugFirstTrailingBreaks tells printListHuggingFirst NOT to flatten the
+  // trailing item, letting it render through its own breakable group. The
+  // call-argument printer sets it for the React-hook deps shape
+  // (`useEffect(() => { … }, [deps])`), whose deps array Prettier breaks
+  // one-element-per-line when it overflows rather than pinning it flat on the
+  // close line. The short leaf/call trailing args of every other first-arg-hug
+  // case still flatten (they ride the close line flat, per Prettier).
+  HugFirstTrailingBreaks bool
+  // HugFirstForce drops the exploded fallback from a HugFirst list, the mirror
+  // of HugLastForce. The call-argument printer sets it for a genuine React-hook
+  // deps call (`useEffect(() => { … }, [deps])`: a zero-parameter block-bodied
+  // arrow plus an array literal), which Prettier's isReactHookCallWithDepsArray
+  // path never explodes — it keeps the callback hugged and lets the open line
+  // overflow. Distinct from HugFirstTrailingBreaks, which also fires for a
+  // parameterized callback whose empty-array second arg DOES keep the fallback.
+  HugFirstForce bool
+  // HugLastForce drops the exploded fallback from a HugLast list: the hugged
+  // shape is chosen even when its opening line overflows printWidth. The
+  // call-argument printer sets it for a test-framework call
+  // (`test("very long description", () => { … })`), which Prettier never
+  // explodes — the callback always rides the open paren. Requires HugLast.
+  HugLastForce bool
   // ForceBreak commits the list to its broken, one-item-per-line shape
   // even when it would fit flat. The object-literal printer sets it to
   // mirror Prettier's objectWrap:"preserve" — an object the source
   // wrote with a newline after `{` stays expanded.
   ForceBreak bool
+  // Fill packs the items with Prettier's fill layout — as many per line as
+  // fit — instead of one item per line when the list breaks. The array
+  // printer sets it for a concisely-printed numeric array. Mutually
+  // exclusive with HugLast / HugFirst.
+  Fill bool
+  // Prefix and Suffix are emitted inside the list's Group, before OpEN and
+  // after CLOSE respectively. They let a caller fold surrounding tokens into
+  // the same fit-or-break decision: an import declaration sets Prefix to
+  // `import ` (or `import D, `) and Suffix to ` from "..."` so the named-brace
+  // group's flat-fit check counts the whole declaration line — Prettier never
+  // breaks a brace that fits but whose `from` tail overflows is measured here,
+  // not in a separate group. Only used on the plain (non-hugging) path.
+  Prefix Doc
+  Suffix Doc
+  // BlankBefore[i] reports whether the source had a blank line before item i
+  // (i.e. between item i-1 and item i). When any entry is set the list is
+  // forced broken and a single blank line is preserved before that item,
+  // mirroring Prettier. Length, when non-nil, equals len(Items); index 0 is
+  // ignored (no item precedes the first).
+  BlankBefore []bool
+}
+
+// blankBeforeItems computes BlankBefore for a node list: entry i is true when
+// the source had a blank line (two or more newlines) between item i-1 and
+// item i. Returns nil for a list too short to carry one, so callers pass it
+// through unconditionally.
+func blankBeforeItems(src string, elems []*shimast.Node) []bool {
+  if len(elems) < 2 {
+    return nil
+  }
+  out := make([]bool, len(elems))
+  for i := 1; i < len(elems); i++ {
+    if elems[i-1] == nil || elems[i] == nil {
+      continue
+    }
+    out[i] = blankLineBetweenStatements(src, elems[i-1].End(), elems[i].Pos())
+  }
+  return out
+}
+
+// hasBlankBefore reports whether any item carries a preserved blank line.
+func (s listShape) hasBlankBefore() bool {
+  for _, b := range s.BlankBefore {
+    if b {
+      return true
+    }
+  }
+  return false
 }
 
 // printList renders the list shape as a Doc tree. Empty lists collapse
@@ -50,19 +151,35 @@ func printList(ctx *PrintContext, shape listShape) Doc {
     return Text(shape.OpenTok + shape.CloseTok)
   }
   plain := printListPlain(ctx, shape)
-  if !shape.HugLast {
+  // A source blank line forces the plain broken layout (Prettier never hugs or
+  // packs flat across a blank line), so skip the hugging ConditionalGroup.
+  if (!shape.HugLast && !shape.HugFirst) || shape.hasBlankBefore() {
     return plain
   }
-  // A HugLast list offers the engine up to three shapes, in preference
+  // A hugging list offers the engine up to three shapes, in preference
   // order:
   //   1. allFlat — every item on one line, chosen when it fits;
-  //   2. hugged  — leading items inline, the final callback or object
-  //      committed to its multi-line shape, chosen when its opening
-  //      line fits but the all-flat form does not;
+  //   2. hugged  — the callback (last for HugLast, first for HugFirst)
+  //      committed to its multi-line shape with the other items inline,
+  //      chosen when its opening line fits but the all-flat form does not;
   //   3. plain   — every item exploded onto its own indented line.
   // The all-flat option is dropped when the list cannot render flat
   // (a block-bodied callback argument carries hard line breaks).
   hugged := printListHuggingLast(ctx, shape)
+  if shape.HugFirst {
+    hugged = printListHuggingFirst(ctx, shape)
+  }
+  // A test-framework call (HugLastForce) and a genuine React-hook deps call
+  // (HugFirstForce, `useEffect(() => { … }, [deps])`) hug their callback
+  // unconditionally — Prettier never explodes their arguments, it lets the open
+  // line overflow — so drop the exploded fallback. The all-flat option still
+  // wins when the whole call fits (an empty-body callback).
+  if shape.HugLastForce || shape.HugFirstForce {
+    if allFlat, ok := flatten(plain); ok {
+      return ConditionalGroup(allFlat, hugged)
+    }
+    return hugged
+  }
   if allFlat, ok := flatten(plain); ok {
     return ConditionalGroup(allFlat, hugged, plain)
   }
@@ -75,7 +192,6 @@ func printList(ctx *PrintContext, shape listShape) Doc {
 // comma — when it does not.
 func printListPlain(ctx *PrintContext, shape listShape) Doc {
   sep := Concat(Text(","), Line())
-  body := Join(sep, shape.Items)
 
   flatPad := Doc{Kind: docNil}
   if shape.Space {
@@ -87,6 +203,50 @@ func printListPlain(ctx *PrintContext, shape listShape) Doc {
     trailing = IfBreak(Text(","), Doc{Kind: docNil})
   }
 
+  hasBlank := shape.hasBlankBefore()
+
+  var body Doc
+  if hasBlank {
+    // Per-item body that preserves a single source blank line before an item:
+    // `,` then a Literalline (the empty line, no indent, mirroring printBlock)
+    // then the normal Line. A blank line forces the group broken.
+    parts := make([]Doc, 0, len(shape.Items)*3)
+    for i, it := range shape.Items {
+      if i > 0 {
+        parts = append(parts, Text(","))
+        if i < len(shape.BlankBefore) && shape.BlankBefore[i] {
+          parts = append(parts, Literalline())
+        }
+        parts = append(parts, Line())
+      }
+      parts = append(parts, it)
+    }
+    body = Concat(parts...)
+  } else if shape.Fill {
+    // Each non-last fill content carries its own comma — `[el, ","]` — and the
+    // separator is just a Line. Prettier measures the pack/break decision on
+    // `[content_i, line, content_{i+1}]`, so the next element's comma must be
+    // part of its content or the line would pack one element too many. The
+    // last element carries no comma here; the trailing comma is the shared
+    // ifBreak appended after the body so it tracks the GROUP's break mode (a
+    // fill-mode ifBreak would drop the comma when the last item packs flat,
+    // making the format non-idempotent).
+    parts := make([]Doc, 0, len(shape.Items)*2-1)
+    for i, it := range shape.Items {
+      if i > 0 {
+        parts = append(parts, Line())
+      }
+      if i < len(shape.Items)-1 {
+        parts = append(parts, Concat(it, Text(",")))
+      } else {
+        parts = append(parts, it)
+      }
+    }
+    body = Fill(parts...)
+  } else {
+    body = Join(sep, shape.Items)
+  }
+
   openTok := Text(shape.OpenTok)
   closeTok := Text(shape.CloseTok)
 
@@ -96,11 +256,19 @@ func printListPlain(ctx *PrintContext, shape listShape) Doc {
   trailingSep := IfBreak(Hardline(), flatPad)
 
   bodyBlock := Indent(ctx.indentUnit(), leadingSep, body, trailing)
-  doc := Concat(openTok, bodyBlock, trailingSep, closeTok)
+  prefix := shape.Prefix
+  if prefix.Kind == 0 {
+    prefix = Doc{Kind: docNil}
+  }
+  suffix := shape.Suffix
+  if suffix.Kind == 0 {
+    suffix = Doc{Kind: docNil}
+  }
+  doc := Concat(prefix, openTok, bodyBlock, trailingSep, closeTok, suffix)
   group := Group(doc)
   // ForceBreak (object-literal newline preservation) commits the group
   // to its broken shape regardless of fit.
-  group.Break = shape.ForceBreak
+  group.Break = shape.ForceBreak || hasBlank
   return group
 }
 
@@ -143,3 +311,41 @@ func printListHuggingLast(ctx *PrintContext, shape listShape) Doc {
   parts = append(parts, last, Text(shape.CloseTok))
   return Concat(parts...)
 }
+
+// printListHuggingFirst renders the "first-argument hugging" shape
+// Prettier uses for `foo(() => { … }, target)`: the first item stays
+// attached to the open paren and the remaining simple items flow inline
+// after it, so a multi-line callback body does not explode the trailing
+// arguments onto their own lines.
+//
+//  hugged: OPEN OPEN-of-first … CLOSE-of-first, b, c CLOSE
+//
+// Like printListHuggingLast it returns a plain Concat (the callback's own
+// printer owns its body's break) and forces the hugged item's first Group
+// broken when the item has no hard line breaks of its own, so the hugged
+// option stays distinct from the all-flat option.
+func printListHuggingFirst(ctx *PrintContext, shape listShape) Doc {
+  first := shape.Items[0]
+  rest := shape.Items[1:]
+  if _, flat := flatten(first); flat {
+    first, _ = forceBreakFirstGroup(first)
+  }
+  parts := []Doc{Text(shape.OpenTok), first}
+  for _, item := range rest {
+    // The trailing simple arguments ride the close line flat — Prettier keeps
+    // them on one line even when that line overflows (a long zero/one-argument
+    // trailing call `}, makeAccumulator(single))` is not broken). Force each
+    // flat so its own Group does not break against the close-line width. The
+    // React-hook deps array is the exception (HugFirstTrailingBreaks): Prettier
+    // renders it through a breakable group, so leave it unflattened to break
+    // one-element-per-line when the close line overflows.
+    if !shape.HugFirstTrailingBreaks {
+      if flat, ok := flatten(item); ok {
+        item = flat
+      }
+    }
+    parts = append(parts, Text(", "), item)
+  }
+  parts = append(parts, Text(shape.CloseTok))
+  return Concat(parts...)
+}

package/linthost/print_nodes_object.go

@@ -35,6 +35,13 @@ func printObjectLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if obj == nil || obj.Properties == nil {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
+  // A comment between properties (or after `{`) would be dropped by the fresh
+  // separators; bail to verbatim and report UNCOVERED (hard `false`, not
+  // `!nodeSpansMultipleLines`) so an enclosing reflow abstains instead of
+  // breaking around this single-line verbatim object and moving it off its line.
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
   items := make([]Doc, 0, len(obj.Properties.Nodes))
   covered := true
   for _, prop := range obj.Properties.Nodes {
@@ -60,12 +67,13 @@ func printObjectLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   // "none" suppresses. Pairs with the call/array branches so the printer
   // never disagrees with the trailing-comma rule on the same setting.
   return printList(ctx, listShape{
-    OpenTok:    "{",
-    CloseTok:   "}",
-    Items:      items,
-    Space:      true,
-    AddComma:   ctx.allowsEs5TrailingComma(),
-    ForceBreak: forceBreak,
+    OpenTok:     "{",
+    CloseTok:    "}",
+    Items:       items,
+    Space:       true,
+    AddComma:    ctx.allowsEs5TrailingComma(),
+    ForceBreak:  forceBreak,
+    BlankBefore: blankBeforeItems(ctx.Source, obj.Properties.Nodes),
   }), covered
 }
 

package/linthost/print_nodes_ternary.go

@@ -0,0 +1,147 @@
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// printConditionalExpression renders a (possibly chained) ternary with
+// Prettier 3's "indent nested ternaries" staircase. A conditional whose
+// consequent or alternate is itself a conditional is printed inline
+// under the same break group, but its arms indent one extra level:
+//
+//  aaaaaaaaaa
+//    ? bbbbbbbbbb
+//    : cccccccccc
+//      ? dddddddddd
+//      : eeeeeeeeee
+//
+// The whole chain shares one fit-or-break decision (a single outer
+// Group), matching Prettier: either the entire chain fits flat
+// (`a ? b : c ? d : e`) or every rung breaks onto its own line. Nesting
+// is expressed by recursing the chain builder without wrapping the
+// nested conditional in its own Group. The outermost chain indents its arms
+// by `tabWidth`. A nested chain in the ALTERNATE (`: `) position indents by a
+// fixed 2 columns; a nested chain in the CONSEQUENT (`? `) position indents by
+// `max(2, tabWidth)` (Prettier's extra `align(tabWidth-2)` on the consequent).
+// So at tabWidth 4 the outer arms sit at column 4, an alternate-nested arm at
+// column 6, and a consequent-nested arm at column 8; they coincide at tabWidth 2.
+//
+// The second return value is the coverage flag (see PrintNode): the AND
+// of the test and both branches, so a multi-line verbatim node anywhere
+// in the chain makes formatPrintWidth abstain rather than emit a
+// half-reflowed shape.
+func printConditionalExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  body, covered := buildConditionalChain(ctx, node, ctx.indentUnit())
+  if body.IsNil() {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  return Group(body), covered
+}
+
+// buildConditionalChain returns the chain body for `node` WITHOUT a
+// surrounding Group, so a nested conditional recursed from here shares
+// the caller's group and its arms indent one level deeper. The top-level
+// printConditionalExpression wraps the outermost body in the single
+// Group that owns the break decision.
+func buildConditionalChain(ctx *PrintContext, node *shimast.Node, indentCols int) (Doc, bool) {
+  cond := node.AsConditionalExpression()
+  if cond == nil || cond.Condition == nil || cond.WhenTrue == nil || cond.WhenFalse == nil {
+    return Doc{}, true
+  }
+  // A comment around the `?`/`:` markers (`a ? /* c */ b : c`) would be dropped
+  // by the minted "? "/": " text — the markers are not AST children, so a
+  // nested conditional's gap comment slips past the top-level print-width scan
+  // and is lost on reflow. Bail to verbatim and report UNCOVERED (hard `false`,
+  // not `!nodeSpansMultipleLines`) so an enclosing reflow abstains instead of
+  // breaking around this single-line verbatim conditional and moving it off its
+  // line; the bytes survive.
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
+  testDoc, c1 := PrintNode(ctx, cond.Condition)
+  consDoc, c2 := ternaryArm(ctx, cond.WhenTrue, true)
+  altDoc, c3 := ternaryArm(ctx, cond.WhenFalse, false)
+  doc := Concat(
+    testDoc,
+    Indent(indentCols,
+      Line(), Text("? "), consDoc,
+      Line(), Text(": "), altDoc,
+    ),
+  )
+  return doc, c1 && c2 && c3
+}
+
+// ternaryArm prints a ternary consequent/alternate. A nested conditional
+// continues the chain inline (no new Group) so the staircase
+// accumulates; every other arm prints through the normal dispatcher (an
+// arm that is a `??` expression is already parenthesized in valid
+// source, so it round-trips its parens via the ParenthesizedExpression
+// printer).
+//
+// A non-conditional arm is wrapped in Align so that, when it breaks
+// internally, its continuation hangs under the arm expression's own
+// column (one level past the `? `/`: ` marker) rather than under the
+// chain's rung indent. Prettier hangs a broken call/object arm there:
+//
+//  cond
+//    ? foo(
+//        arg,        // arm-column + one level, not rung + one level
+//      )
+//    : bar
+//
+// Align is a no-op for an arm that stays flat, and a nested conditional
+// is deliberately NOT aligned — it keeps the Indent-based staircase.
+//
+// A nested conditional in the CONSEQUENT (`? `) position is wrapped in
+// parentheses, but only when the chain renders flat: Prettier's ternary-old
+// printer emits `consequent.type === node.type ? ifBreak("", "(") : ""` around
+// the consequent (`a ? (b ? c : d) : e` on one line), and drops the parens for
+// the broken staircase. A nested conditional in the ALTERNATE (`: `) position
+// is never wrapped — it chains. `isConsequent` selects between the two.
+func ternaryArm(ctx *PrintContext, node *shimast.Node, isConsequent bool) (Doc, bool) {
+  inner := node
+  // A nested ternary written with explicit source parentheses — `a ? (b ? c : d)
+  // : e` — is the same chain link as a bare nested ternary: Prettier's AST has no
+  // ParenthesizedExpression node, so its `printTernary` sees the consequent as a
+  // ConditionalExpression and joins the staircase (re-adding the parens only in
+  // flat mode via ifBreak). Unwrap a parenthesized conditional so it chains too,
+  // instead of printing flat inside kept parens. Only a ConditionalExpression
+  // inner is unwrapped; `(a ?? b)` and other parenthesized expressions keep their
+  // parens through the normal printer.
+  // Do NOT unwrap when a comment sits between the parens and the inner
+  // conditional (`(/* keep */ b ? c : d)`): dropping the ParenExpr wrapper would
+  // delete that comment. Leaving `inner` as the ParenExpr routes it through the
+  // normal printer, whose own self-guard bails to verbatim and preserves it.
+  if inner != nil && inner.Kind == shimast.KindParenthesizedExpression &&
+    !listHasInterItemComments(ctx, inner) {
+    if p := inner.AsParenthesizedExpression(); p != nil && p.Expression != nil &&
+      p.Expression.Kind == shimast.KindConditionalExpression {
+      inner = p.Expression
+    }
+  }
+  if inner != nil && inner.Kind == shimast.KindConditionalExpression {
+    // A nested chain's arms align at 2 past their parent rung. Prettier's
+    // ternary-old.js uses that as-is for an ALTERNATE-position nested chain
+    // (`align(2)`), but a CONSEQUENT-position one gets an extra
+    // `align(Math.max(0, tabWidth - 2))`, for a total of `max(2, tabWidth)`.
+    // The two coincide at the default tabWidth 2; they diverge at tabWidth > 2.
+    indentCols := 2
+    if isConsequent {
+      if u := ctx.indentUnit(); u > indentCols {
+        indentCols = u
+      }
+    }
+    chain, covered := buildConditionalChain(ctx, inner, indentCols)
+    if isConsequent {
+      // `ifBreak("", "(")` … `ifBreak("", ")")`: parens in flat mode only.
+      chain = Concat(
+        IfBreak(Doc{Kind: docNil}, Text("(")),
+        chain,
+        IfBreak(Doc{Kind: docNil}, Text(")")),
+      )
+    }
+    return chain, covered
+  }
+  doc, covered := PrintNode(ctx, node)
+  return Align(doc), covered
+}