@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/print_nodes_call.go

@@ -46,12 +46,34 @@ func printCallExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   }
   if call.TypeArguments != nil {
     // Verbatim range covering `<A, B>` punctuation and members.
-    parts = append(parts, verbatimRange(ctx.Source, callTypeArgsStart(ctx, call), callTypeArgsEnd(ctx, call)))
+    parts = append(parts, verbatimRange(ctx.Source, typeArgsStart(ctx.Source, call.TypeArguments), typeArgsEnd(ctx.Source, call.TypeArguments)))
   }
   if hasNilEntry(call.Arguments) {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
-  argDoc, argCovered := printArgList(ctx, call.Arguments)
+  // A comment in an argument gap (`foo(a, /* c */ b)`) would be dropped by the
+  // freshly minted `, ` separators in printArgList. The top-level print-width
+  // scan only masks a *direct* child's comments, so a comment inside a NESTED
+  // call's argument list slips through and is lost on reflow. Self-guard the
+  // way the object/array printers do: bail to verbatim and report UNCOVERED so
+  // an enclosing reflow abstains too. Uncovered must be hard `false`, not
+  // `!nodeSpansMultipleLines`: a single-line comment-bearing call would
+  // otherwise report covered and let the outer reflow break around it, moving
+  // the verbatim node off its line (the assertFormatUnchanged contract).
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
+  // Prettier never appends a trailing comma inside a dynamic
+  // `import(...)`, so the printer's reflow must agree with
+  // format/trailing-comma's same exception (see isDynamicImportCall).
+  addComma := ctx.allowsCallArgumentTrailingComma() && !isDynamicImportCall(call)
+  // A decorator's call hugs its last argument even past leading callbacks
+  // (`@OneToMany(() => P, (p) => p.c, { … })`); a plain call explodes there.
+  decoratorCall := node.Parent != nil && node.Parent.Kind == shimast.KindDecorator
+  // A test-framework call (`test("desc", () => { … })`) hugs its callback even
+  // when the description string pushes the opening line past printWidth, so the
+  // exploded fallback is dropped for it. See isTestCall.
+  argDoc, argCovered := printArgList(ctx, call.Arguments, addComma, decoratorCall, isTestCall(node))
   parts = append(parts, argDoc)
   return Concat(parts...), covered && argCovered
 }
@@ -77,13 +99,23 @@ func printNewExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
     covered = covered && !nodeSpansMultipleLines(ctx, ne.Expression)
   }
   if ne.TypeArguments != nil {
-    parts = append(parts, verbatimRange(ctx.Source, newTypeArgsStart(ctx, ne), newTypeArgsEnd(ctx, ne)))
+    parts = append(parts, verbatimRange(ctx.Source, typeArgsStart(ctx.Source, ne.TypeArguments), typeArgsEnd(ctx.Source, ne.TypeArguments)))
+  }
+  // A comment in the `new`->constructee gap (`new /* c */ Foo`) or an argument
+  // gap would be dropped by the minted `Text("new ")` / fresh separators — those
+  // gaps are not AST children, so a nested new-expression's comment slips past
+  // the top-level scan. Guard unconditionally (the no-args `new Foo` path mints
+  // `new ` too), mirroring printCallExpression's unconditional guard. Report
+  // UNCOVERED (hard `false`, not `!nodeSpansMultipleLines`) so an enclosing
+  // reflow abstains rather than breaking around this single-line verbatim node.
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
   }
   if ne.Arguments != nil {
     if hasNilEntry(ne.Arguments) {
       return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
     }
-    argDoc, argCovered := printArgList(ctx, ne.Arguments)
+    argDoc, argCovered := printArgList(ctx, ne.Arguments, ctx.allowsCallArgumentTrailingComma(), false, false)
     parts = append(parts, argDoc)
     covered = covered && argCovered
   }
@@ -116,7 +148,14 @@ func hasNilEntry(list *shimast.NodeList) bool {
 // layout, so the parens stay attached and the preceding arguments are
 // not exploded onto their own lines. This is the Prettier behavior for
 // `foo(x, () => { … })`.
-func printArgList(ctx *PrintContext, list *shimast.NodeList) (Doc, bool) {
+// `addComma` is supplied by the caller (which honors `format.trailingComma`
+// and the dynamic-import exception) rather than read here, so call and new
+// expressions can diverge on the comma without printArgList knowing the
+// callee. Call / new argument lists accepted trailing commas only in
+// ES2017+, so Prettier's "es5" and "none" modes pass false; otherwise the
+// printer would oscillate against format/trailing-comma on every cascade
+// pass (rxjs hit this on ajax.ts and several operators / testing helpers).
+func printArgList(ctx *PrintContext, list *shimast.NodeList, addComma bool, decoratorCall bool, forceHugLast bool) (Doc, bool) {
   if list == nil {
     return Text("()"), true
   }
@@ -127,24 +166,340 @@ func printArgList(ctx *PrintContext, list *shimast.NodeList) (Doc, bool) {
     covered = covered && childCovered
     items = append(items, doc)
   }
-  // AddComma honors `format.trailingComma`: call / new argument lists
-  // accepted trailing commas only in ES2017+, so Prettier's "es5" and
-  // "none" modes skip them here. Hardcoding `true` would oscillate
-  // against Prettier on every cascade pass on any project configured
-  // with "es5" (rxjs hit this on ajax.ts and several operators / testing
-  // helpers — the rule said "no comma needed" while the printer added
-  // one back on its own reflow).
+  // Last-argument hugging wins when both predicates match; first-arg
+  // hugging only applies to the two-argument `callback, simpleArg` shape.
+  // Decline last-arg hugging when a leading argument forces the call
+  // multi-line on its own, so Prettier explodes the whole call rather than
+  // hugging the last argument. Two leading shapes trigger that: a function
+  // or arrow expression (`useMemo(() => x, [deps])`, even with an inline
+  // expression body Prettier never hugs after it), and any argument whose
+  // doc carries hard breaks (a block-bodied callback). A leading object or
+  // array that merely fits flat does NOT decline — Prettier still hugs the
+  // last argument there (`doConfigure({ … }, () => { … })`).
+  // The useMemo/useEffect deps shape (`f(() => x, [deps])`) explodes its 2-arg
+  // arrow+array one-per-line even under a decorator: Prettier's shouldExpandLastArg
+  // declines `args.length === 2 && penultimate is ArrowFunction && last is Array`
+  // unconditionally (it is NOT decorator-gated). The genuine decorator hug
+  // (`@OneToMany(() => P, (p) => p.c, { … })`) is 3-arg, so isUseMemoArrowArrayShape
+  // already returns false for it; a 2-or-more-callback composition is handled by
+  // argListForcesFunctionBreak, and a block-bodied leading callback by
+  // anyLeadingItemBreaks.
+  hugLast := shouldHugLastArgument(list.Nodes) &&
+    !anyLeadingItemBreaks(items) &&
+    !isUseMemoArrowArrayShape(list.Nodes)
+  // Two or more function/arrow arguments force the list to explode, one per
+  // line, even when it would fit flat: Prettier always breaks a call carrying
+  // multiple callbacks (`promise.then(() => a, () => b)`), the
+  // function-composition rule. The sole exception is a decorator hugging a
+  // huggable trailing argument (`@OneToMany(() => P, (p) => p.c, { … })`),
+  // where the leading arrows stay inline and only the object breaks — so the
+  // gate defers to hugLast off a decorator. See argListForcesFunctionBreak.
+  forceFnBreak := argListForcesFunctionBreak(list.Nodes, decoratorCall)
+  if forceFnBreak {
+    hugLast = false
+  }
+  // A test-framework call always hugs its trailing callback (the description
+  // string may overflow the open line); force the hug and drop the exploded
+  // fallback via HugLastForce.
+  if forceHugLast {
+    hugLast = true
+    forceFnBreak = false
+  }
+  hugFirst := !hugLast && !forceFnBreak && shouldHugFirstArgument(ctx, list.Nodes)
   shape := listShape{
-    OpenTok:  "(",
-    CloseTok: ")",
-    Items:    items,
-    Space:    false,
-    AddComma: ctx.allowsCallArgumentTrailingComma(),
-    HugLast:  shouldHugLastArgument(list.Nodes),
+    OpenTok:      "(",
+    CloseTok:     ")",
+    Items:        items,
+    Space:        false,
+    AddComma:     addComma,
+    HugLast:      hugLast,
+    HugLastForce: forceHugLast,
+    HugFirst:     hugFirst,
+    // A non-empty array second argument reaches HugFirst only via the
+    // React-hook deps branch of shouldHugFirstArgument; let that deps array
+    // break one-per-line instead of being pinned flat on the close line.
+    HugFirstTrailingBreaks: hugFirst && len(list.Nodes) == 2 &&
+      list.Nodes[1] != nil &&
+      list.Nodes[1].Kind == shimast.KindArrayLiteralExpression,
+    HugFirstForce: hugFirst && isReactHookDepsCall(list.Nodes),
+    ForceBreak:    forceFnBreak,
+    BlankBefore:   blankBeforeItems(ctx.Source, list.Nodes),
   }
   return printList(ctx, shape), covered
 }
 
+// testCalleePatterns is Prettier's exact testCallCalleePatterns set (the dotted
+// callee chains its isTestCallCallee matches). Matching the precise set, rather
+// than "any base with a {only,skip,…} tail", avoids both over-matching
+// (`test.each`, `it.todo` are NOT test calls) and under-matching (`test.fixme`,
+// `test.describe.only` ARE).
+var testCalleePatterns = map[string]bool{
+  "it": true, "it.only": true, "it.skip": true,
+  "describe": true, "describe.only": true, "describe.skip": true,
+  "test": true, "test.only": true, "test.skip": true,
+  "test.fixme": true, "test.step": true,
+  "test.describe": true, "test.describe.only": true,
+  "test.describe.skip": true, "test.describe.fixme": true,
+  "test.describe.parallel": true, "test.describe.parallel.only": true,
+  "test.describe.serial": true, "test.describe.serial.only": true,
+  "skip": true, "xit": true, "xdescribe": true, "xtest": true,
+  "fit": true, "fdescribe": true, "ftest": true,
+}
+
+// calleeChain builds the dotted member-access chain of a callee rooted at a
+// plain identifier (`test.describe.only` becomes "test.describe.only"), or ""
+// when the callee is not a pure identifier / property-access chain (a computed
+// access, a call, `this`, etc.).
+func calleeChain(node *shimast.Node) string {
+  switch node.Kind {
+  case shimast.KindIdentifier:
+    return identifierText(node)
+  case shimast.KindPropertyAccessExpression:
+    pa := node.AsPropertyAccessExpression()
+    if pa == nil || pa.Name() == nil || pa.Name().Kind != shimast.KindIdentifier {
+      return ""
+    }
+    base := calleeChain(pa.Expression)
+    if base == "" {
+      return ""
+    }
+    return base + "." + identifierText(pa.Name())
+  }
+  return ""
+}
+
+// testCalleeName reports whether `callee` is one of Prettier's recognized
+// test-framework callees (see testCalleePatterns).
+func testCalleeName(callee *shimast.Node) bool {
+  return callee != nil && testCalleePatterns[calleeChain(callee)]
+}
+
+// isTestCall reports whether `node` is a test-framework call Prettier prints
+// with its callback hugged regardless of width: `it(...)` / `test(...)` /
+// `describe(...)` (and focus/skip variants) called with a string or template
+// description and a trailing function/arrow. Prettier never explodes such a
+// call's arguments, so the printer keeps the callback on the open-paren line
+// even when the description string overflows printWidth (the callback's
+// parameter count does not matter, verified against Prettier). Scoped to the
+// two-argument form (the overwhelming shape); a three-argument timeout variant
+// falls through to ordinary hugging.
+func isTestCall(node *shimast.Node) bool {
+  if node == nil || node.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.QuestionDotToken != nil || call.Arguments == nil {
+    return false
+  }
+  args := call.Arguments.Nodes
+  // Prettier accepts a two- or three-argument test call (the third is a numeric
+  // timeout): `it("name", () => { … })` and `it("name", () => { … }, 2500)`.
+  if len(args) != 2 && len(args) != 3 {
+    return false
+  }
+  if args[0] == nil || args[1] == nil {
+    return false
+  }
+  switch args[0].Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindTemplateExpression:
+  default:
+    return false
+  }
+  if !testCalleeName(call.Expression) {
+    return false
+  }
+  if len(args) == 3 {
+    // The timeout argument must be numeric, and the callback a block-bodied
+    // function/arrow taking at most one parameter (Prettier's
+    // isFunctionOrArrowExpressionWithBody + parameter-count gate).
+    if args[2] == nil || args[2].Kind != shimast.KindNumericLiteral {
+      return false
+    }
+    return isBlockBodiedCallback(args[1]) && len(args[1].Parameters()) <= 1
+  }
+  return isFunctionLikeArg(args[1])
+}
+
+// isBlockBodiedCallback reports whether a node is a function expression or an
+// arrow with a block body (Prettier's isFunctionOrArrowExpressionWithBody).
+func isBlockBodiedCallback(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindFunctionExpression:
+    return true
+  case shimast.KindArrowFunction:
+    a := node.AsArrowFunction()
+    return a != nil && a.Body != nil && a.Body.Kind == shimast.KindBlock
+  }
+  return false
+}
+
+// isFunctionLikeArg reports whether an argument is a function or arrow
+// expression, the two shapes Prettier counts as "function" arguments.
+func isFunctionLikeArg(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindArrowFunction, shimast.KindFunctionExpression:
+    return true
+  }
+  return false
+}
+
+// callArgsContainFunctionLike reports whether a CALL expression's own argument
+// list carries a function/arrow argument. Prettier's function-composition test
+// treats `foo.map((x) => x)` as a composed call, so a call carrying it
+// alongside any second argument explodes. Only a call counts: Prettier's
+// isCallExpression matches CallExpression / OptionalCallExpression but NOT a
+// NewExpression, so `foo(new Bar(() => x), other)` is left inline.
+func callArgsContainFunctionLike(node *shimast.Node) bool {
+  if node == nil || node.Kind != shimast.KindCallExpression {
+    return false
+  }
+  c := node.AsCallExpression()
+  if c == nil || c.Arguments == nil {
+    return false
+  }
+  for _, a := range c.Arguments.Nodes {
+    if isFunctionLikeArg(a) {
+      return true
+    }
+  }
+  return false
+}
+
+// isFunctionCompositionArgs mirrors Prettier's predicate of the same name: a
+// call with two or more arguments is "function composition" when either two of
+// them are themselves functions/arrows, or one is a call/new whose own
+// arguments include a function/arrow (`stream.pipe(map((x) => x), other)`).
+// Prettier breaks such a list onto one-argument-per-line unconditionally.
+func isFunctionCompositionArgs(args []*shimast.Node) bool {
+  if len(args) <= 1 {
+    return false
+  }
+  fnCount := 0
+  for _, a := range args {
+    if isFunctionLikeArg(a) {
+      fnCount++
+      if fnCount > 1 {
+        return true
+      }
+    } else if callArgsContainFunctionLike(a) {
+      return true
+    }
+  }
+  return false
+}
+
+// argListForcesFunctionBreak reports whether a call's argument list must
+// explode under Prettier's function-composition rule (see
+// isFunctionCompositionArgs), which fires even when the call would fit on one
+// line. A DECORATOR is exempt entirely: Prettier guards the rule with
+// `path.parent.type !== "Decorator"` (printCallArguments in call-arguments.js),
+// so `@ManyToOne(() => User, (u) => u.addresses)` stays flat when it fits and
+// breaks only on width. Shared by printArgList (which sets ForceBreak) and the
+// print-width rule (whose fit fast-path must not skip such a call when it is
+// written flat in source).
+func argListForcesFunctionBreak(args []*shimast.Node, decoratorCall bool) bool {
+  if decoratorCall {
+    return false
+  }
+  return isFunctionCompositionArgs(args)
+}
+
+// callForcesFunctionBreak reports whether a node is a call OR new expression
+// that the multiple-callback rule forces to explode. Prettier's printCallArguments
+// is shared by NewExpression (its function-composition break is gated only by
+// `path.parent.type !== "Decorator"`, not by call-vs-new), so `new Foo(() => a,
+// () => b)` explodes the same as a call. The print-width rule consults this so
+// its flat-fit fast path does not leave such a call/new inline when the source
+// wrote it on one line.
+func callForcesFunctionBreak(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  var args *shimast.NodeList
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    if c := node.AsCallExpression(); c != nil {
+      args = c.Arguments
+    }
+  case shimast.KindNewExpression:
+    if n := node.AsNewExpression(); n != nil {
+      args = n.Arguments
+    }
+  default:
+    return false
+  }
+  if args == nil {
+    return false
+  }
+  // A new expression is never a decorator's call.
+  decoratorCall := node.Kind == shimast.KindCallExpression &&
+    node.Parent != nil && node.Parent.Kind == shimast.KindDecorator
+  return argListForcesFunctionBreak(args.Nodes, decoratorCall)
+}
+
+// isUseMemoArrowArrayShape reports the ONE leading-argument shape Prettier
+// declines last-argument hugging for: exactly two arguments where the first is
+// an arrow function and the last is an array literal — the
+// `useMemo(() => x, [deps])` / `useEffect(() => { … }, [deps])` shape.
+// Prettier's shouldExpandLastArg (call-arguments.js:260-262) has NO general
+// "a leading function declines hugging" rule; its only leading-argument clause
+// is `args.length === 2 && penultimate is ArrowFunctionExpression && last is
+// ArrayExpression`. A block-bodied leading callback is handled independently by
+// anyLeadingItemBreaks (it `willBreak`), and two-or-more callbacks by
+// argListForcesFunctionBreak, so a leading expression-bodied arrow before a
+// non-array huggable last argument (`f((x) => g(x), { a: 1 })`) must still hug.
+func isUseMemoArrowArrayShape(args []*shimast.Node) bool {
+  if len(args) != 2 || args[0] == nil || args[1] == nil {
+    return false
+  }
+  return args[0].Kind == shimast.KindArrowFunction &&
+    args[1].Kind == shimast.KindArrayLiteralExpression
+}
+
+// isReactHookDepsCall reports the React-hook deps shape Prettier hugs WITHOUT an
+// exploded fallback: exactly two arguments, the first a ZERO-parameter
+// block-bodied arrow, the second an array literal (`useEffect(() => { … },
+// [deps])`). Prettier's isReactHookCallWithDepsArray / isValidHookCallbackAndDepsFormat
+// keys on this and never explodes the args — it keeps the callback hugged and
+// lets the open line overflow. A parameterized callback (`subscribe((e) => { … },
+// [])`) is NOT this shape and keeps the fallback, so the zero-parameter +
+// block-body gate is load-bearing (distinct from isUseMemoArrowArrayShape and
+// from the HugFirstTrailingBreaks array check).
+func isReactHookDepsCall(args []*shimast.Node) bool {
+  if len(args) != 2 || args[0] == nil || args[1] == nil {
+    return false
+  }
+  if args[1].Kind != shimast.KindArrayLiteralExpression {
+    return false
+  }
+  arrow := args[0].AsArrowFunction()
+  return arrow != nil && arrow.Body != nil &&
+    arrow.Body.Kind == shimast.KindBlock &&
+    len(args[0].Parameters()) == 0
+}
+
+// anyLeadingItemBreaks reports whether any item before the last carries a
+// hard line break — it cannot render flat. Such an item (a block-bodied
+// callback) forces the call multi-line on its own, so last-argument
+// hugging must decline and let the whole list explode, matching Prettier's
+// willBreak gate on the non-last arguments.
+func anyLeadingItemBreaks(items []Doc) bool {
+  for i := 0; i+1 < len(items); i++ {
+    if _, ok := flatten(items[i]); !ok {
+      return true
+    }
+  }
+  return false
+}
+
 // shouldHugLastArgument reports whether the final entry of `args` is a
 // shape Prettier keeps hugging the closing paren: an object or array
 // literal, a function expression, or an arrow function whose body is a
@@ -164,14 +519,55 @@ func shouldHugLastArgument(args []*shimast.Node) bool {
     return false
   }
   last := args[len(args)-1]
-  if last == nil {
+  if last == nil || !lastArgHuggableShape(last) {
     return false
   }
+  // Prettier's shouldGroupLastArg declines only when the penultimate argument
+  // is the SAME node kind as the last: two objects or two arrays compete for
+  // the break, so `new Sash(x, { … }, { … })` and `bar({ … }, { … })` explode.
+  // A different-kind penultimate (an arrow before an object, `@OneToMany(() =>
+  // P, (p) => p.c, { … })`, or a plain `foo(a, b, { … })`) still hugs.
+  if len(args) >= 2 {
+    if pen := args[len(args)-2]; pen != nil && pen.Kind == last.Kind {
+      return false
+    }
+    // Prettier's shouldExpandLastArg also declines a CONCISELY-PRINTED numeric
+    // array as the last of two-plus arguments: it fills on its own line, so
+    // `drawPolygon(ctx, [1, 2, 3, …])` explodes rather than hugging.
+    if last.Kind == shimast.KindArrayLiteralExpression {
+      if arr := last.AsArrayLiteralExpression(); arr != nil && arr.Elements != nil &&
+        isConciselyPrintedArray(arr.Elements.Nodes) {
+        return false
+      }
+    }
+  }
+  return true
+}
+
+// lastArgHuggableShape reports whether `node` is the shape Prettier keeps
+// hugging the closing paren: an object/array literal, a function expression,
+// or an arrow whose body is a block, object, or array. An expression-bodied
+// arrow (`(x) => x.id`) is excluded: it has no internal break point, so the
+// flat hugging Concat would pin an overflowing call to one line.
+func lastArgHuggableShape(last *shimast.Node) bool {
   switch last.Kind {
-  case shimast.KindFunctionExpression,
-    shimast.KindObjectLiteralExpression,
-    shimast.KindArrayLiteralExpression:
+  case shimast.KindFunctionExpression:
     return true
+  case shimast.KindObjectLiteralExpression:
+    // Prettier's couldExpandArg requires a NON-EMPTY object (`properties.length
+    // > 0`); an empty `{}` is not expandable, so `foo(a, b, {})` explodes the
+    // list rather than hugging. (Inter-item comments route to verbatim, so the
+    // hasComment branch is moot here.)
+    if obj := last.AsObjectLiteralExpression(); obj != nil {
+      return obj.Properties != nil && len(obj.Properties.Nodes) > 0
+    }
+    return false
+  case shimast.KindArrayLiteralExpression:
+    // Likewise a non-empty array; an empty `[]` is not expandable.
+    if arr := last.AsArrayLiteralExpression(); arr != nil {
+      return arr.Elements != nil && len(arr.Elements.Nodes) > 0
+    }
+    return false
   case shimast.KindArrowFunction:
     arrow := last.AsArrowFunction()
     if arrow == nil || arrow.Body == nil {
@@ -186,15 +582,366 @@ func shouldHugLastArgument(args []*shimast.Node) bool {
       }
     }
     switch body.Kind {
-    case shimast.KindBlock,
-      shimast.KindObjectLiteralExpression,
+    case shimast.KindBlock:
+      // A block-bodied arrow hugs regardless of any return-type annotation.
+      return true
+    case shimast.KindObjectLiteralExpression,
       shimast.KindArrayLiteralExpression:
+      // An object/array-bodied arrow hugs unless its return type is a type
+      // REFERENCE. Prettier's couldExpandArg gates only on
+      // `returnType.typeAnnotation.type === "TSTypeReference"`, so a keyword,
+      // union, array, or literal return type (`map((r): void => ({ … }))`)
+      // still hugs while a named-reference return (`map((r): Foo => ({ … })))`)
+      // explodes the whole list. A block body hugs regardless (handled above).
+      return arrow.Type == nil || arrow.Type.Kind != shimast.KindTypeReference
+    }
+  }
+  // DEFERRED (architectural, not a one-line predicate fix; do not re-add to the
+  // switch above without the supporting layout work):
+  //   - A call/conditional/JSX-expression arrow body. Prettier's couldExpandArg
+  //     hugs it, but ttsc emits the arrow signature (`=> `) verbatim with no
+  //     break point after `=>`, so hugging here would force the FIRST group
+  //     inside the call instead of breaking after `=>` — a different shape, not
+  //     parity. Needs a break-after-`=>` arrow-body layout variant first.
+  //   - A trailing `as`/`satisfies` cast wrapping a huggable last argument.
+  //     Prettier's couldExpandArg recurses into the cast, but ttsc does not
+  //     dispatch KindAsExpression (it prints verbatim), so forceBreakFirstGroup
+  //     finds no group and the hug is inert. Needs a cast printer first.
+  return false
+}
+
+// shouldHugFirstArgument reports whether a call's argument list takes
+// Prettier's "first-argument hugging" shape: exactly two arguments where
+// the first is a block-bodied callback and the second is a short, simple
+// value. `foo(() => { … }, target)` keeps the callback attached to the
+// open paren and flows `, target)` after its closing brace, instead of
+// exploding both arguments onto their own lines.
+//
+// Mirrors Prettier's shouldGroupFirstArg: it declines when the second
+// argument is itself a function, arrow, conditional, or any expandable
+// shape, so `both(() => {}, () => {})` falls through to the exploded
+// list rather than hugging.
+func shouldHugFirstArgument(ctx *PrintContext, args []*shimast.Node) bool {
+  if len(args) != 2 {
+    return false
+  }
+  first, second := args[0], args[1]
+  if first == nil || second == nil {
+    return false
+  }
+  if !isFirstArgHuggableCallback(first) {
+    return false
+  }
+  // A NON-EMPTY array trailing arg hugs only in Prettier's React-hook deps
+  // shape (isReactHookCallWithDepsArray): a ZERO-parameter arrow callback plus
+  // an array, e.g. `useEffect(() => { … }, [a, b])`. With a parameter the call
+  // explodes (`subscribe((event) => { … }, [a, b])`), and a function expression
+  // (not an arrow) never qualifies. An EMPTY array falls through to
+  // isSimpleTrailingArg.
+  if second.Kind == shimast.KindArrayLiteralExpression {
+    if arr := second.AsArrayLiteralExpression(); arr != nil &&
+      arr.Elements != nil && len(arr.Elements.Nodes) > 0 {
+      return first.Kind == shimast.KindArrowFunction && len(first.Parameters()) == 0
+    }
+  }
+  return isSimpleTrailingArg(ctx, second)
+}
+
+// isFirstArgHuggableCallback reports whether `node` is the callback shape
+// Prettier hugs in the first-argument position: a function expression or
+// an arrow with a block body. An expression-bodied arrow is excluded
+// because it carries no internal break point.
+func isFirstArgHuggableCallback(node *shimast.Node) bool {
+  switch node.Kind {
+  case shimast.KindFunctionExpression:
+    return true
+  case shimast.KindArrowFunction:
+    arrow := node.AsArrowFunction()
+    return arrow != nil && arrow.Body != nil && arrow.Body.Kind == shimast.KindBlock
+  }
+  return false
+}
+
+// isSimpleTrailingArg reports whether `node` is a value that may trail a
+// hugged first-argument callback. Prettier hugs the leading callback when
+// the trailing argument is an identifier, member access, literal, `this`,
+// or an EMPTY array/object literal. It also accepts a short call/new (at
+// most one value argument) and a short arithmetic/logical expression
+// (`setTimeout(fn, 1000 - x)`). A function, arrow, conditional, a non-empty
+// array, or a non-empty object literal is excluded, so first-argument hugging
+// declines and the whole list explodes. (A non-empty array after a
+// zero-parameter arrow is the React-hook deps shape, hugged earlier in
+// shouldHugFirstArgument and never routed here.)
+//
+// The call/new case rides the close line: the conditional-group fit check
+// only measures an option's first line, so a hugged-first option whose
+// trailing call overflows the closing line is still selected. Prettier
+// accepts the same trade for a short trailing call.
+func isSimpleTrailingArg(ctx *PrintContext, node *shimast.Node) bool {
+  switch node.Kind {
+  case shimast.KindIdentifier,
+    shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindThisKeyword,
+    shimast.KindPropertyAccessExpression,
+    shimast.KindElementAccessExpression:
+    return true
+  case shimast.KindArrayLiteralExpression:
+    // Only an EMPTY array is simple-trailing (the `[] as T[]` cast idiom).
+    // Prettier's couldExpandArg treats an array with elements as expandable,
+    // so a non-empty array cast (`[x] as number[]`) explodes the list rather
+    // than hugging. The non-empty bare-array deps shape (zero-param arrow) is
+    // handled in shouldHugFirstArgument before reaching here.
+    if arr := node.AsArrayLiteralExpression(); arr != nil {
+      return arr.Elements == nil || len(arr.Elements.Nodes) == 0
+    }
+    return false
+  case shimast.KindAsExpression:
+    // `[] as string[]`: the `reduce(fn, [] as T[])` idiom. Hug when the cast
+    // target is a simple type AND its inner expression is simple at depth 1 —
+    // Prettier's isHopefullyShortCallArgument cast branch is exactly
+    // `isSimpleType(typeAnnotation) && isSimpleCallArgument(node.expression, 1)`.
+    // Depth 1 (not the general isSimpleTrailingArg) is deliberate: it has no
+    // binaryish branch and bottoms a nested call's argument out at depth 0, so
+    // `(a - b) as T` and `makeInit(x) as T[]` are NOT simple and explode.
+    if as := node.AsAsExpression(); as != nil && as.Expression != nil {
+      return isSimpleCallArg(as.Expression, 1) && isSimpleCastType(as.Type)
+    }
+  case shimast.KindSatisfiesExpression:
+    // `[] satisfies T[]`: Prettier's isBinaryCastExpression covers
+    // TSSatisfiesExpression identically to TSAsExpression, so a satisfies cast
+    // takes the same simple-type + depth-1 simple-expression path as `as`.
+    if s := node.AsSatisfiesExpression(); s != nil && s.Expression != nil {
+      return isSimpleCallArg(s.Expression, 1) && isSimpleCastType(s.Type)
+    }
+  case shimast.KindCallExpression, shimast.KindNewExpression:
+    // `reduce(fn, Object.create(null))` / `reduce(fn, new Map<…>())`: Prettier
+    // hugs the first arg over a trailing call/new only when it has at most one
+    // value argument AND that argument is itself structurally simple. Its
+    // isHopefullyShortCallArgument early-rejects >1 args, then falls through to
+    // isSimpleCallArgument (depth 2), so a 1-arg call whose sole argument is a
+    // non-trivial nested call/object/array (`reduce(fn, makeInit(deep(arg)))`)
+    // is NOT simple and the whole list explodes. Type arguments and long names
+    // still do not matter; the close line is allowed to overflow.
+    return callValueArgCount(node) <= 1 && isSimpleCallArg(node, 2)
+  case shimast.KindObjectLiteralExpression:
+    // `reduce(fn, {})`: an EMPTY object literal hugs (Prettier's couldGroupArg
+    // excludes a property-less object); an object with properties expands and
+    // explodes the list instead (`f(fn, { a: 1 })`).
+    if obj := node.AsObjectLiteralExpression(); obj != nil {
+      return obj.Properties == nil || len(obj.Properties.Nodes) == 0
+    }
+  case shimast.KindBinaryExpression:
+    // `setTimeout(fn, 1000 - ellapsed)`: a SINGLE arithmetic/logical operation
+    // whose two operands are simple leaves rides the close line and hugs. A
+    // chained binary (`60 * 60 * 1000`, an operand itself a binary) is not
+    // simple and explodes the list, matching Prettier's isHopefullyShortCallArgument
+    // (which only treats a binaryish short when both sides are themselves short).
+    if bin := node.AsBinaryExpression(); bin != nil {
+      return isSimpleBinaryOperand(bin.Left) && isSimpleBinaryOperand(bin.Right)
+    }
+  case shimast.KindPrefixUnaryExpression:
+    // `reduce(fn, -1)`: a unary applied to a simple leaf rides the close line.
+    if u := node.AsPrefixUnaryExpression(); u != nil {
+      return isSimpleBinaryOperand(u.Operand)
+    }
+  }
+  return false
+}
+
+// isSimpleCallArg ports Prettier's isSimpleCallArgument (utilities/index.js): a
+// depth-bounded structural simplicity check. A node is simple when it is a leaf
+// (identifier, literal, this, member access) or a shallow composite whose parts
+// are simple at a reduced depth — a call/new is simple only when its callee is
+// simple, it has at most `depth` arguments, and every argument is simple at
+// `depth-1`. The recursion floor (`depth <= 0`) is what makes a nested call
+// like `makeInit(deep(arg))` non-simple, so first-argument hugging declines and
+// the list explodes, matching Prettier. A non-empty object is treated as
+// non-simple (its values bottom out below the depth floor anyway — the safe
+// under-match direction). Element access is treated as a simple leaf, matching
+// ttsc's existing member-access handling, rather than recursing into its
+// computed key (a pre-existing, rare residual over-match left out of scope).
+func isSimpleCallArg(node *shimast.Node, depth int) bool {
+  if node == nil || depth <= 0 {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindIdentifier,
+    shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindThisKeyword,
+    shimast.KindElementAccessExpression:
+    return true
+  case shimast.KindParenthesizedExpression:
+    if p := node.AsParenthesizedExpression(); p != nil {
+      return isSimpleCallArg(p.Expression, depth)
+    }
+  case shimast.KindNonNullExpression:
+    // Prettier's isSimpleCallArgument unwraps TSNonNullExpression at the same
+    // depth, so `foo!()` / `target!` recurse into the asserted expression.
+    if n := node.AsNonNullExpression(); n != nil {
+      return isSimpleCallArg(n.Expression, depth)
+    }
+  case shimast.KindPrefixUnaryExpression:
+    if u := node.AsPrefixUnaryExpression(); u != nil {
+      return isSimpleCallArg(u.Operand, depth)
+    }
+  case shimast.KindPropertyAccessExpression:
+    // The `.name` half is an identifier (trivially simple); recurse the object
+    // so `a.b(x, y).c` (a member of a multi-argument call) is correctly not
+    // simple, matching Prettier's member recursion.
+    if m := node.AsPropertyAccessExpression(); m != nil {
+      return isSimpleCallArg(m.Expression, depth)
+    }
+  case shimast.KindArrayLiteralExpression:
+    if arr := node.AsArrayLiteralExpression(); arr != nil {
+      if arr.Elements == nil {
+        return true
+      }
+      for _, el := range arr.Elements.Nodes {
+        if !isSimpleCallArg(el, depth-1) {
+          return false
+        }
+      }
       return true
     }
+  case shimast.KindObjectLiteralExpression:
+    // Only an empty object is treated as simple. A non-empty object's values
+    // are checked at depth-1, which bottoms out to false at every depth that
+    // occurs as a trailing-call argument, so declining one never over-matches.
+    if obj := node.AsObjectLiteralExpression(); obj != nil {
+      return obj.Properties == nil || len(obj.Properties.Nodes) == 0
+    }
+  case shimast.KindCallExpression:
+    if c := node.AsCallExpression(); c != nil {
+      var args []*shimast.Node
+      if c.Arguments != nil {
+        args = c.Arguments.Nodes
+      }
+      if !isSimpleCallArg(c.Expression, depth) || len(args) > depth {
+        return false
+      }
+      for _, a := range args {
+        if !isSimpleCallArg(a, depth-1) {
+          return false
+        }
+      }
+      return true
+    }
+  case shimast.KindNewExpression:
+    if n := node.AsNewExpression(); n != nil {
+      var args []*shimast.Node
+      if n.Arguments != nil {
+        args = n.Arguments.Nodes
+      }
+      if !isSimpleCallArg(n.Expression, depth) || len(args) > depth {
+        return false
+      }
+      for _, a := range args {
+        if !isSimpleCallArg(a, depth-1) {
+          return false
+        }
+      }
+      return true
+    }
+  }
+  return false
+}
+
+// isSimpleBinaryOperand reports whether a node is a short, non-recursive
+// operand, an identifier, a literal, `this`, or a member access. A binary,
+// call, conditional, or other compound expression is not, so a binary built
+// from such operands is treated as too complex to ride a hugged close line.
+func isSimpleBinaryOperand(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindIdentifier,
+    shimast.KindNumericLiteral,
+    shimast.KindStringLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindThisKeyword,
+    shimast.KindPropertyAccessExpression,
+    shimast.KindElementAccessExpression:
+    return true
+  }
+  return false
+}
+
+// isSimpleCastType ports the type half of Prettier's isHopefullyShortCallArgument
+// cast branch: unwrap an array type up to two levels (`T[]`, `T[][]` -> `T`) and
+// a single-type-argument reference (`Ref<X>` -> `X`), then require a SIMPLE type
+// (isSimpleTypeNode). A reference still carrying type arguments after the unwrap
+// (`Foo<A, B>`, `Array<Array<string>>`), or a union / intersection / function /
+// tuple / object type, is not simple, so the cast declines the first-argument
+// hug and the list explodes, matching Prettier.
+func isSimpleCastType(typeNode *shimast.Node) bool {
+  node := typeNode
+  for i := 0; i < 2 && node != nil && node.Kind == shimast.KindArrayType; i++ {
+    at := node.AsArrayTypeNode()
+    if at == nil || at.ElementType == nil {
+      return false
+    }
+    node = at.ElementType
+  }
+  if node != nil && node.Kind == shimast.KindTypeReference {
+    if ref := node.AsTypeReferenceNode(); ref != nil && ref.TypeArguments != nil &&
+      len(ref.TypeArguments.Nodes) == 1 {
+      node = ref.TypeArguments.Nodes[0]
+    }
+  }
+  return isSimpleTypeNode(node)
+}
+
+// isSimpleTypeNode mirrors Prettier's isSimpleType: a keyword/primitive type, a
+// literal type, `this`, or a bare type reference with NO type arguments.
+func isSimpleTypeNode(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindStringKeyword, shimast.KindNumberKeyword, shimast.KindBooleanKeyword,
+    shimast.KindAnyKeyword, shimast.KindUnknownKeyword, shimast.KindVoidKeyword,
+    shimast.KindNeverKeyword, shimast.KindUndefinedKeyword, shimast.KindNullKeyword,
+    shimast.KindObjectKeyword, shimast.KindSymbolKeyword, shimast.KindBigIntKeyword,
+    shimast.KindThisType, shimast.KindLiteralType, shimast.KindTemplateLiteralType:
+    return true
+  case shimast.KindTypeReference:
+    ref := node.AsTypeReferenceNode()
+    return ref != nil && (ref.TypeArguments == nil || len(ref.TypeArguments.Nodes) == 0)
   }
   return false
 }
 
+// callValueArgCount returns the number of value arguments on a call or new
+// expression (type arguments are not counted). A new expression with no
+// argument list (`new Foo`) counts as zero.
+func callValueArgCount(node *shimast.Node) int {
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    if c := node.AsCallExpression(); c != nil && c.Arguments != nil {
+      return len(c.Arguments.Nodes)
+    }
+  case shimast.KindNewExpression:
+    if n := node.AsNewExpression(); n != nil && n.Arguments != nil {
+      return len(n.Arguments.Nodes)
+    }
+  }
+  return 0
+}
+
 // forceBreakFirstGroup returns `doc` with the first Group found in a
 // left-to-right walk of its subtree forced broken, and reports whether
 // one was found. printListHuggingLast uses it to commit a hugged
@@ -225,72 +972,34 @@ func forceBreakFirstGroup(doc Doc) (Doc, bool) {
 
 // Type-argument byte-range helpers. The shim's NodeList.End() points
 // past the last argument; the surrounding `<` and `>` are not part of
-// the list's range, so we have to scan around it.
+// the list's range, so we have to scan around it. Call and new
+// expressions share these — only the field holding the list differs.
 
-// callTypeArgsStart returns the byte offset of the `<` that opens the
-// type-argument list of a CallExpression. Returns -1 when absent.
-func callTypeArgsStart(ctx *PrintContext, call *shimast.CallExpression) int {
-  if call.TypeArguments == nil || len(call.TypeArguments.Nodes) == 0 {
-    return -1
-  }
-  first := call.TypeArguments.Nodes[0]
-  if first == nil {
+// typeArgsStart returns the byte offset of the `<` that opens a
+// type-argument list. Returns -1 when absent.
+func typeArgsStart(src string, list *shimast.NodeList) int {
+  if list == nil || len(list.Nodes) == 0 || list.Nodes[0] == nil {
     return -1
   }
   // `<` is the byte immediately before the first type argument
   // (modulo whitespace).
-  pos := first.Pos()
-  for i := pos - 1; i >= 0; i-- {
-    if ctx.Source[i] == '<' {
-      return i
-    }
-  }
-  return -1
-}
-
-// callTypeArgsEnd returns the byte offset one past the closing `>` of a
-// CallExpression's type-argument list. Returns -1 when absent.
-func callTypeArgsEnd(ctx *PrintContext, call *shimast.CallExpression) int {
-  if call.TypeArguments == nil {
-    return -1
-  }
-  end := call.TypeArguments.End()
-  for i := end; i < len(ctx.Source); i++ {
-    if ctx.Source[i] == '>' {
-      return i + 1
-    }
-  }
-  return end
-}
-
-// newTypeArgsStart returns the byte offset of the `<` that opens the
-// type-argument list of a NewExpression. Returns -1 when absent.
-func newTypeArgsStart(ctx *PrintContext, ne *shimast.NewExpression) int {
-  if ne.TypeArguments == nil || len(ne.TypeArguments.Nodes) == 0 {
-    return -1
-  }
-  first := ne.TypeArguments.Nodes[0]
-  if first == nil {
-    return -1
-  }
-  pos := first.Pos()
-  for i := pos - 1; i >= 0; i-- {
-    if ctx.Source[i] == '<' {
+  for i := list.Nodes[0].Pos() - 1; i >= 0; i-- {
+    if src[i] == '<' {
       return i
     }
   }
   return -1
 }
 
-// newTypeArgsEnd returns the byte offset one past the closing `>` of a
-// NewExpression's type-argument list. Returns -1 when absent.
-func newTypeArgsEnd(ctx *PrintContext, ne *shimast.NewExpression) int {
-  if ne.TypeArguments == nil {
+// typeArgsEnd returns the byte offset one past the closing `>` of a
+// type-argument list. Returns -1 when the list is absent.
+func typeArgsEnd(src string, list *shimast.NodeList) int {
+  if list == nil {
     return -1
   }
-  end := ne.TypeArguments.End()
-  for i := end; i < len(ctx.Source); i++ {
-    if ctx.Source[i] == '>' {
+  end := list.End()
+  for i := end; i < len(src); i++ {
+    if src[i] == '>' {
       return i + 1
     }
   }