@ttsc/lint 0.12.4 → 0.13.0

package/linthost/print_nodes_function.go

@@ -0,0 +1,353 @@
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// Function-shaped and statement-body node printers: arrow functions,
+// function expressions, parenthesized expressions, block statements,
+// and the two leaf statements a callback body is almost always made of
+// — expression statements and return statements.
+//
+// These printers exist for one job: make callback-bearing code
+// (`new Singleton(() => { … })`, `foo(x, function () { … })`) reflow
+// with *consistent* indentation. The headline bug they fix is the
+// verbatim-column hazard — an un-handled multi-line node keeps the
+// source columns its lines were written at, so when the enclosing call
+// re-indents, the callback header and its body drift apart.
+//
+// Coverage discipline. The signature (parameters, `=>` / `function`
+// keyword, return type) is emitted verbatim because it almost never
+// contains a newline and is not a reflow target. The *body* is where
+// the newlines live, so the body is dispatched through PrintNode and
+// re-indented by the Doc engine. Each printer ANDs the body's `covered`
+// flag into its own result: a body the dispatcher cannot fully control
+// taints the whole subtree and the format/print-width rule abstains.
+//
+// The expression- and return-statement printers carry the same
+// discipline one level deeper: a callback body whose statements are
+// themselves calls (`outer(() => { inner(() => { … }); })`) only
+// reflows when those statements dispatch to a real printer. Without
+// them every multi-line statement would be verbatim and a nested
+// callback would always abstain.
+
+// printArrowFunction renders an arrow function. The portion before the
+// body — parameters, optional return type, `=>` token — is emitted
+// verbatim; only the body participates in reflow.
+//
+//  verbatim prefix      reflowed body
+//  ┌──────────────┐     ┌──────────┐
+//  (a, b): number =>    { return a; }
+//
+// A concise (expression) body is dispatched directly. A block body
+// flows through printBlock, which re-indents its statements relative
+// to the printer's current indent.
+//
+// The second return value is the `covered` flag: see PrintNode. The
+// verbatim prefix is single-line in every realistic arrow, but a
+// pathological multi-line parameter list would still taint coverage.
+func printArrowFunction(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  arrow := node.AsArrowFunction()
+  if arrow == nil || arrow.Body == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  return printFunctionLike(ctx, node, arrow.Body)
+}
+
+// printFunctionExpression renders a `function` expression. Like the
+// arrow printer, the signature is verbatim and only the body reflows.
+// Function expressions always carry a block body, so the body always
+// flows through printBlock.
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printFunctionExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  fn := node.AsFunctionExpression()
+  if fn == nil || fn.Body == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  return printFunctionLike(ctx, node, fn.Body)
+}
+
+// printFunctionLike is the shared body of the arrow / function-expression
+// printers. It slices the verbatim signature from the node's first byte
+// up to the body's first byte, dispatches the body, and concatenates
+// the two.
+//
+// The signature slice intentionally includes the whitespace between the
+// signature and the body (`=> ` keeps its trailing space, `) ` before a
+// `function` body keeps its space) so the flat form reads naturally and
+// the body's open brace lands where the user put it.
+func printFunctionLike(ctx *PrintContext, node, body *shimast.Node) (Doc, bool) {
+  nodeStart := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  bodyStart := shimscanner.SkipTrivia(ctx.Source, body.Pos())
+  if nodeStart < 0 || bodyStart < nodeStart || bodyStart > len(ctx.Source) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  prefix := verbatimRange(ctx.Source, nodeStart, bodyStart)
+  // A signature that itself spans multiple lines is a verbatim slice
+  // with frozen interior columns — taint coverage so the rule abstains.
+  prefixCovered := !strings.Contains(ctx.Source[nodeStart:bodyStart], "\n")
+  bodyDoc, bodyCovered := PrintNode(ctx, body)
+  return Concat(prefix, bodyDoc), prefixCovered && bodyCovered
+}
+
+// printParenthesizedExpression renders `( expr )`. The parentheses are
+// fixed punctuation; the inner expression is dispatched so a call or
+// object literal wrapped in parens still reflows.
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printParenthesizedExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  paren := node.AsParenthesizedExpression()
+  if paren == nil || paren.Expression == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  inner, covered := PrintNode(ctx, paren.Expression)
+  return Concat(Text("("), inner, Text(")")), covered
+}
+
+// printBlock renders a `{ … }` block statement. A statement-free block
+// collapses to `{}`. A non-empty block always renders multi-line —
+// matching every JavaScript formatter — with each statement on its own
+// line, indented one unit from the block's base indent and the closing
+// brace back at the base indent.
+//
+//  {
+//    stmt;
+//    stmt;
+//  }
+//
+// Each statement is dispatched through PrintNode, so a statement that
+// is itself reflowable (a long call) gets reflowed and a plain
+// statement falls back to verbatim. Because the engine re-applies the
+// indent at every Hardline, even a verbatim statement lands at the
+// correct column — the verbatim-column hazard only bites *multi-line*
+// verbatim nodes, and those taint `covered` so the rule abstains.
+//
+// The second return value is the `covered` flag: see PrintNode. A block
+// is uncovered when any statement is uncovered, or when the block
+// carries a comment that lives outside every statement's byte range —
+// the freshly minted Hardline separators have no carrier slot for such
+// trivia, so reflowing would silently drop the comment. The
+// comment check guards the statement-free path too: `{ /* note */ }`
+// has no statements but is *not* an empty block — collapsing it to `{}`
+// would delete the comment, so the printer emits it verbatim instead.
+func printBlock(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  block := node.AsBlock()
+  if block == nil || block.Statements == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  hasComment := blockHasNonStatementComment(ctx, node, block.Statements.Nodes)
+  if len(block.Statements.Nodes) == 0 {
+    if hasComment {
+      // `{ /* … */ }` — not collapsible without dropping the comment.
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    return Text("{}"), true
+  }
+  stmts := block.Statements.Nodes
+  items := make([]Doc, 0, len(stmts))
+  covered := !hasComment
+  for _, stmt := range stmts {
+    if stmt == nil {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    doc, childCovered := PrintNode(ctx, stmt)
+    covered = covered && childCovered
+    items = append(items, doc)
+  }
+  // Join statements with a Hardline, preserving a single user-authored
+  // blank line between consecutive statements. The block printer mints
+  // fresh separators, so a bare `Join(Hardline, …)` would silently
+  // delete every blank line in the body on the first reflow. The blank
+  // line is a Literalline — a bare newline with no indent — so the
+  // empty line carries no trailing whitespace. Two or more blank lines
+  // collapse to one, matching Prettier.
+  bodyParts := make([]Doc, 0, len(items)*2)
+  for i, item := range items {
+    if i > 0 {
+      if blankLineBetweenStatements(ctx.Source, stmts[i-1].End(), stmts[i].Pos()) {
+        bodyParts = append(bodyParts, Literalline())
+      }
+      bodyParts = append(bodyParts, Hardline())
+    }
+    bodyParts = append(bodyParts, item)
+  }
+  doc := Concat(
+    Text("{"),
+    Indent(ctx.indentUnit(), Hardline(), Concat(bodyParts...)),
+    Hardline(),
+    Text("}"),
+  )
+  return doc, covered
+}
+
+// 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
+// user-authored blank line between statements. blockHasNonStatementComment
+// has already guaranteed the gap holds no comment when the block is
+// covered, so the gap is pure whitespace and counting newlines suffices.
+func blankLineBetweenStatements(src string, prevEnd, nextPos int) bool {
+  nextStart := shimscanner.SkipTrivia(src, nextPos)
+  if prevEnd < 0 || nextStart > len(src) || nextStart <= prevEnd {
+    return false
+  }
+  newlines := 0
+  for i := prevEnd; i < nextStart; i++ {
+    if src[i] == '\n' {
+      newlines++
+      if newlines >= 2 {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+// blockHasNonStatementComment reports whether the block's byte range
+// holds a `//` or `/*` outside every statement's token range. The block
+// printer joins statements with bare Hardlines that have no slot for
+// inter-statement trivia, so a stray comment would be dropped by a
+// reflow. Detecting it lets printBlock report the block uncovered and
+// the format/print-width rule abstain.
+//
+// The scan mirrors rules_format_print_width.go::hasNonChildComments:
+// comment-shaped bytes inside a complete statement token range (string
+// literals, nested comments) are masked, so only genuine
+// inter-statement comments surface.
+func blockHasNonStatementComment(ctx *PrintContext, node *shimast.Node, stmts []*shimast.Node) bool {
+  start := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  end := node.End()
+  if start < 0 || end < start || end > len(ctx.Source) {
+    return false
+  }
+  type span struct{ pos, end int }
+  ranges := make([]span, 0, len(stmts))
+  for _, stmt := range stmts {
+    if stmt == nil {
+      continue
+    }
+    ranges = append(ranges, span{shimscanner.SkipTrivia(ctx.Source, stmt.Pos()), stmt.End()})
+  }
+  inStatement := func(i int) bool {
+    for _, r := range ranges {
+      if i >= r.pos && i < r.end {
+        return true
+      }
+    }
+    return false
+  }
+  src := ctx.Source
+  for i := start; i < end-1 && i < len(src)-1; i++ {
+    if inStatement(i) {
+      continue
+    }
+    if src[i] == '/' && (src[i+1] == '/' || src[i+1] == '*') {
+      return true
+    }
+  }
+  return false
+}
+
+// printExpressionStatement renders an `expr;` statement. The expression
+// is dispatched so a callback-body statement that is itself a call or
+// object literal reflows; the trailing `;` is preserved when the source
+// carries one.
+//
+// The dispatcher reaches this printer through the block printer, so
+// nested callbacks (`outer(() => { inner(() => { … }); })`) reflow at
+// every depth instead of stalling on the verbatim fallback.
+//
+// The second return value is the `covered` flag: see PrintNode. The
+// printer falls back to verbatim when the gap between the expression
+// and the statement end holds anything other than the optional `;` and
+// whitespace — a comment in that gap has no carrier slot and would be
+// dropped.
+func printExpressionStatement(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  stmt := node.AsExpressionStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  if !tailIsCleanTerminator(ctx.Source, stmt.Expression.End(), node.End()) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  exprDoc, covered := PrintNode(ctx, stmt.Expression)
+  parts := []Doc{exprDoc}
+  if sourceHasStatementTerminator(ctx.Source, node.End()) {
+    parts = append(parts, Text(";"))
+  }
+  return Concat(parts...), covered
+}
+
+// printReturnStatement renders a `return expr;` statement. Like the
+// expression-statement printer, the returned expression is dispatched
+// so a returned callback or object literal reflows.
+//
+// A bare `return;` carries no expression and is emitted verbatim — it
+// is a single token with nothing to reflow.
+//
+// The second return value is the `covered` flag: see PrintNode. The
+// printer falls back to verbatim when the gap between the expression
+// and the statement end holds anything but the optional `;` and
+// whitespace.
+func printReturnStatement(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  stmt := node.AsReturnStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  if !tailIsCleanTerminator(ctx.Source, stmt.Expression.End(), node.End()) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  exprDoc, covered := PrintNode(ctx, stmt.Expression)
+  parts := []Doc{Text("return "), exprDoc}
+  if sourceHasStatementTerminator(ctx.Source, node.End()) {
+    parts = append(parts, Text(";"))
+  }
+  return Concat(parts...), covered
+}
+
+// tailIsCleanTerminator reports whether src[exprEnd:stmtEnd] holds only
+// whitespace and at most one `;`. The expression- and return-statement
+// printers consult it before re-minting the trailing `;`: a comment or
+// any other token in that gap would be dropped by the reflow, so the
+// printer must fall back to verbatim instead.
+func tailIsCleanTerminator(src string, exprEnd, stmtEnd int) bool {
+  if exprEnd < 0 || stmtEnd < exprEnd || stmtEnd > len(src) {
+    return false
+  }
+  semis := 0
+  for i := exprEnd; i < stmtEnd; i++ {
+    switch src[i] {
+    case ' ', '\t', '\r', '\n':
+    case ';':
+      semis++
+      if semis > 1 {
+        return false
+      }
+    default:
+      return false
+    }
+  }
+  return true
+}

package/linthost/print_nodes_imports.go

@@ -20,56 +20,70 @@ import (
 // mode, matching Prettier's `bracketSpacing: true` default for import
 // declarations (which is hard-coded; Prettier ignores `bracketSpacing`
 // for imports). Empty named imports `{}` collapse cleanly.
-func printNamedImports(ctx *PrintContext, node *shimast.Node) Doc {
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printNamedImports(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if node == nil {
-    return Doc{}
+    return Doc{}, true
   }
   ni := node.AsNamedImports()
   if ni == nil || ni.Elements == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   items := make([]Doc, 0, len(ni.Elements.Nodes))
+  covered := true
   for _, spec := range ni.Elements.Nodes {
     if spec == nil {
-      return verbatim(ctx, node)
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
     }
-    doc, _ := PrintNode(ctx, spec)
+    doc, childCovered := PrintNode(ctx, spec)
+    covered = covered && childCovered
     items = append(items, doc)
   }
+  // AddComma honors `format.trailingComma`: named imports are an
+  // ES5-permitted comma position, so "all" and "es5" both keep the
+  // trailing comma; only "none" drops it.
   return printList(ctx, listShape{
     OpenTok:  "{",
     CloseTok: "}",
     Items:    items,
     Space:    true,
-    AddComma: true,
-  })
+    AddComma: ctx.allowsEs5TrailingComma(),
+  }), covered
 }
 
 // printNamedExports renders `export { a, b }`. The shape is identical
 // to NamedImports; only the surrounding declaration differs.
-func printNamedExports(ctx *PrintContext, node *shimast.Node) Doc {
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printNamedExports(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if node == nil {
-    return Doc{}
+    return Doc{}, true
   }
   ne := node.AsNamedExports()
   if ne == nil || ne.Elements == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   items := make([]Doc, 0, len(ne.Elements.Nodes))
+  covered := true
   for _, spec := range ne.Elements.Nodes {
     if spec == nil {
-      return verbatim(ctx, node)
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
     }
-    doc, _ := PrintNode(ctx, spec)
+    doc, childCovered := PrintNode(ctx, spec)
+    covered = covered && childCovered
     items = append(items, doc)
   }
+  // AddComma honors `format.trailingComma`: named exports are an
+  // ES5-permitted comma position, so "all" and "es5" both keep the
+  // trailing comma; only "none" drops it.
   return printList(ctx, listShape{
     OpenTok:  "{",
     CloseTok: "}",
     Items:    items,
     Space:    true,
-    AddComma: true,
-  })
+    AddComma: ctx.allowsEs5TrailingComma(),
+  }), covered
 }
 
 // printImportDeclaration renders the surrounding `import … from "x";`.
@@ -79,13 +93,15 @@ func printNamedExports(ctx *PrintContext, node *shimast.Node) Doc {
 //
 // The dispatcher hands off to the per-clause printers; the top-level
 // frame stitches them together with the keywords and `from` token.
-func printImportDeclaration(ctx *PrintContext, node *shimast.Node) Doc {
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printImportDeclaration(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if node == nil {
-    return Doc{}
+    return Doc{}, true
   }
   imp := node.AsImportDeclaration()
   if imp == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   // If the declaration uses anything other than a vanilla
   // `import { ... } from "x"` shape (default specifier, namespace
@@ -93,20 +109,26 @@ func printImportDeclaration(ctx *PrintContext, node *shimast.Node) Doc {
   // canonical reflow target is the named-import body.
   clause := imp.ImportClause
   if clause == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   clauseData := clause.AsImportClause()
   if clauseData == nil || clauseData.NamedBindings == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   if clauseData.NamedBindings.Kind != shimast.KindNamedImports {
     // Namespace imports (`import * as ns from "x"`) have no
     // reflow surface; leave them alone.
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   if clause.Name() != nil {
     // `import Default, { … } from "x"` — keep verbatim for v1.
-    return verbatim(ctx, node)
+    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)
   }
 
   // Bracketed clause prefix: `import ` (and optional `type `).
@@ -114,8 +136,9 @@ func printImportDeclaration(ctx *PrintContext, node *shimast.Node) Doc {
   if clause.IsTypeOnly() {
     prefix = "import type "
   }
-  named, _ := PrintNode(ctx, clauseData.NamedBindings)
+  named, covered := PrintNode(ctx, clauseData.NamedBindings)
   moduleSpec := verbatim(ctx, imp.ModuleSpecifier)
+  covered = covered && !nodeSpansMultipleLines(ctx, imp.ModuleSpecifier)
   parts := []Doc{Text(prefix), named, Text(" from "), moduleSpec}
   if sourceHasStatementTerminator(ctx.Source, node.End()) {
     // Preserve the user's terminator decision. Emitting `;`
@@ -124,13 +147,7 @@ func printImportDeclaration(ctx *PrintContext, node *shimast.Node) Doc {
     // `;;` — `format/semi` owns terminator placement.
     parts = append(parts, Text(";"))
   }
-  // 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)
-  }
-  return Concat(parts...)
+  return Concat(parts...), covered
 }
 
 // sourceHasStatementTerminator reports whether the last non-trivia

package/linthost/print_nodes_list.go

@@ -27,15 +27,53 @@ type listShape struct {
   Items    []Doc
   Space    bool // emit a space after OPEN / before CLOSE in flat mode
   AddComma bool // emit a trailing comma in broken mode
+  // HugLast keeps the final item attached to the parens instead of
+  // exploding the whole list. It is set by the call/new argument
+  // printer when the last argument is a callback or object literal —
+  // see printArgList. When true, the last item is emitted directly
+  // against OPEN…CLOSE with no leading/trailing soft break, so a
+  // multi-line callback body does not force every preceding argument
+  // onto its own line.
+  HugLast 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
 }
 
 // printList renders the list shape as a Doc tree. Empty lists collapse
-// to `OPENCLOSE`. Single-element lists still wrap so trailing-comma
-// logic stays uniform.
+// to `OPENCLOSE`. A HugLast list becomes a ConditionalGroup of up to
+// three shapes; every other list is the plain fit-or-break Group.
 func printList(ctx *PrintContext, shape listShape) Doc {
   if len(shape.Items) == 0 {
     return Text(shape.OpenTok + shape.CloseTok)
   }
+  plain := printListPlain(ctx, shape)
+  if !shape.HugLast {
+    return plain
+  }
+  // A HugLast 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;
+  //   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 allFlat, ok := flatten(plain); ok {
+    return ConditionalGroup(allFlat, hugged, plain)
+  }
+  return ConditionalGroup(hugged, plain)
+}
+
+// printListPlain renders the open-comma-close list as a single
+// fit-or-break Group: flat (`OPEN a, b CLOSE`) when it fits the width
+// budget, one item per indented line — with an optional trailing
+// comma — when it does not.
+func printListPlain(ctx *PrintContext, shape listShape) Doc {
   sep := Concat(Text(","), Line())
   body := Join(sep, shape.Items)
 
@@ -53,12 +91,55 @@ func printList(ctx *PrintContext, shape listShape) Doc {
   closeTok := Text(shape.CloseTok)
 
   // In flat mode: OPEN [pad] body [pad] CLOSE
-  // In broken mode: OPEN \n body, \n CLOSE — using Softline so the
-  // flat form collapses cleanly.
+  // In broken mode: OPEN \n body, \n CLOSE.
   leadingSep := IfBreak(Hardline(), flatPad)
   trailingSep := IfBreak(Hardline(), flatPad)
 
   bodyBlock := Indent(ctx.indentUnit(), leadingSep, body, trailing)
   doc := Concat(openTok, bodyBlock, trailingSep, closeTok)
-  return Group(doc)
+  group := Group(doc)
+  // ForceBreak (object-literal newline preservation) commits the group
+  // to its broken shape regardless of fit.
+  group.Break = shape.ForceBreak
+  return group
+}
+
+// printListHuggingLast renders the "last-argument hugging" shape that
+// Prettier uses for `foo(a, b, () => { … })`: the leading items flow
+// comma-separated and the final item stays attached to the closing
+// paren instead of being pushed onto its own indented line.
+//
+//  hugged: OPEN a, b, OPEN-of-last … CLOSE-of-last CLOSE
+//
+// The result is a plain Concat, not a Group: the hugged last argument
+// is a callback or object literal whose own printer carries the
+// fit-or-break decision for its body, so wrapping here would let a
+// multi-line body force the `a, b,` prefix to break. printList offers
+// this Concat as a ConditionalGroup option; when its opening line would
+// overflow printWidth the engine falls back to the plain exploded list.
+//
+// The hugged final item is forced broken — via forceBreakFirstGroup —
+// so the hugged option is genuinely multi-line and distinct from the
+// all-flat option. A flat hugged object would otherwise be
+// byte-identical to all-flat yet escape its width check. The break
+// reaches the first Group in the item's subtree, so an object or array
+// nested inside an arrow body (`(x) => ({ … })`) breaks too.
+func printListHuggingLast(ctx *PrintContext, shape listShape) Doc {
+  last := shape.Items[len(shape.Items)-1]
+  lead := shape.Items[:len(shape.Items)-1]
+  // Force the hugged item's first Group broken only when the item has
+  // no hard line breaks of its own. A block-bodied callback already
+  // renders multi-line through its block's hard breaks; descending into
+  // it with forceBreakFirstGroup would instead force some unrelated
+  // nested Group — a plain statement's call-argument list — broken.
+  if _, flat := flatten(last); flat {
+    last, _ = forceBreakFirstGroup(last)
+  }
+
+  parts := []Doc{Text(shape.OpenTok)}
+  for _, item := range lead {
+    parts = append(parts, item, Text(", "))
+  }
+  parts = append(parts, last, Text(shape.CloseTok))
+  return Concat(parts...)
 }