@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/print_dispatch.go

@@ -28,7 +28,7 @@ import (
 // indented, corrupt output. To prevent that, every printer reports a
 // `covered` boolean alongside its Doc: `true` means the whole printed
 // subtree is reflow-safe (no multi-line verbatim node), `false` means a
-// multi-line verbatim node is buried inside. The format/print-width
+// multi-line verbatim node is buried inside. The formatPrintWidth
 // rule abstains entirely when `covered` is false, so `ttsc format`
 // either reflows correctly or leaves the bytes untouched — it never
 // emits the half-reflowed shape. Single-line verbatim is always safe:
@@ -59,7 +59,7 @@ func NewPrintContext(file *shimast.SourceFile, opts PrintOptions) *PrintContext
 // boolean: `true` when the whole printed subtree is reflow-safe,
 // `false` when a multi-line verbatim node is buried inside it.
 //
-// The format/print-width rule consults `covered` to decide whether to
+// The formatPrintWidth rule consults `covered` to decide whether to
 // emit an edit at all — see the coverage-signal note at the top of this
 // file. A `false` reading is a hard abstain, not a soft hint.
 func PrintNode(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
@@ -118,6 +118,9 @@ func dispatchNode(ctx *PrintContext, node *shimast.Node) (Doc, bool, bool) {
   case shimast.KindReturnStatement:
     doc, covered := printReturnStatement(ctx, node)
     return doc, covered, true
+  case shimast.KindConditionalExpression:
+    doc, covered := printConditionalExpression(ctx, node)
+    return doc, covered, true
   }
   return Doc{}, false, false
 }

package/linthost/print_engine.go

@@ -68,11 +68,11 @@ import "strings"
 //
 //   - "all"  (default)  every multi-line list gets one.
 //   - "es5"             arrays, objects, named imports / exports get one;
-//                       call arguments, parameter lists, and type-level
-//                       lists do not — those positions accepted trailing
-//                       commas only in ES2017+, so es5 mode skips them
-//                       to match Prettier and avoid oscillating against
-//                       the formatter on every cascade pass.
+//     call arguments, parameter lists, and type-level
+//     lists do not — those positions accepted trailing
+//     commas only in ES2017+, so es5 mode skips them
+//     to match Prettier and avoid oscillating against
+//     the formatter on every cascade pass.
 //   - "none"            no list gets one.
 //
 // An empty string is treated as "all", which keeps `DefaultPrintOptions()`

package/linthost/print_nodes_call.go

@@ -46,12 +46,16 @@ 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)
+  // 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)
+  argDoc, argCovered := printArgList(ctx, call.Arguments, addComma)
   parts = append(parts, argDoc)
   return Concat(parts...), covered && argCovered
 }
@@ -77,13 +81,13 @@ 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)))
   }
   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())
     parts = append(parts, argDoc)
     covered = covered && argCovered
   }
@@ -116,7 +120,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) (Doc, bool) {
   if list == nil {
     return Text("()"), true
   }
@@ -127,24 +138,65 @@ 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({ … }, () => { … })`).
+  hugLast := shouldHugLastArgument(list.Nodes) &&
+    !anyLeadingArgIsFunctionLike(list.Nodes) &&
+    !anyLeadingItemBreaks(items)
   shape := listShape{
     OpenTok:  "(",
     CloseTok: ")",
     Items:    items,
     Space:    false,
-    AddComma: ctx.allowsCallArgumentTrailingComma(),
-    HugLast:  shouldHugLastArgument(list.Nodes),
+    AddComma: addComma,
+    HugLast:  hugLast,
+    HugFirst: !hugLast && shouldHugFirstArgument(list.Nodes),
   }
   return printList(ctx, shape), covered
 }
 
+// anyLeadingArgIsFunctionLike reports whether any argument before the last
+// is a function or arrow expression. Prettier declines last-argument
+// hugging when a non-last argument is itself a function/arrow, regardless
+// of its body, so `useMemo(() => compute(), [deps])` explodes rather than
+// hugging the trailing array. This complements anyLeadingItemBreaks, which
+// only catches leads with hard line breaks (a block body) and so misses an
+// expression-bodied arrow.
+func anyLeadingArgIsFunctionLike(args []*shimast.Node) bool {
+  for i := 0; i+1 < len(args); i++ {
+    if args[i] == nil {
+      continue
+    }
+    switch args[i].Kind {
+    case shimast.KindArrowFunction, shimast.KindFunctionExpression:
+      return true
+    }
+  }
+  return false
+}
+
+// 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
@@ -195,6 +247,74 @@ func shouldHugLastArgument(args []*shimast.Node) bool {
   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(args []*shimast.Node) bool {
+  if len(args) != 2 {
+    return false
+  }
+  first, second := args[0], args[1]
+  if first == nil || second == nil {
+    return false
+  }
+  return isFirstArgHuggableCallback(first) && isSimpleTrailingArg(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 array literal — most notably the `useEffect(() => { … }, [deps])`
+// idiom. An object literal, function, arrow, or conditional is excluded so
+// first-argument hugging declines and the whole list explodes.
+//
+// A call expression is deliberately NOT included: the conditional-group
+// fit check only measures an option's first line, so a hugged-first option
+// whose trailing call overflows the closing line (`}, deeplyNested(…))`)
+// would still be selected, where Prettier explodes. The array case shares
+// that limitation in principle, but dependency arrays are short in
+// practice, the same way the identifier/member cases already are.
+func isSimpleTrailingArg(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,
+    shimast.KindArrayLiteralExpression:
+    return true
+  }
+  return false
+}
+
 // 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 +345,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] == '<' {
+  for i := list.Nodes[0].Pos() - 1; i >= 0; i-- {
+    if src[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] == '<' {
-      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
     }
   }

package/linthost/print_nodes_function.go

@@ -25,7 +25,7 @@ import (
 // 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.
+// taints the whole subtree and the formatPrintWidth rule abstains.
 //
 // The expression- and return-statement printers carry the same
 // discipline one level deeper: a callback body whose statements are
@@ -180,6 +180,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 +206,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
@@ -224,7 +249,7 @@ func blankLineBetweenStatements(src string, prevEnd, nextPos int) bool {
 // 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 formatPrintWidth rule abstain.
 //
 // The scan mirrors rules_format_print_width.go::hasNonChildComments:
 // comment-shaped bytes inside a complete statement token range (string

package/linthost/print_nodes_list.go

@@ -35,6 +35,12 @@ 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
   // 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
@@ -50,19 +56,22 @@ func printList(ctx *PrintContext, shape listShape) Doc {
     return Text(shape.OpenTok + shape.CloseTok)
   }
   plain := printListPlain(ctx, shape)
-  if !shape.HugLast {
+  if !shape.HugLast && !shape.HugFirst {
     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)
+  }
   if allFlat, ok := flatten(plain); ok {
     return ConditionalGroup(allFlat, hugged, plain)
   }
@@ -143,3 +152,29 @@ 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 {
+    parts = append(parts, Text(", "), item)
+  }
+  parts = append(parts, Text(shape.CloseTok))
+  return Concat(parts...)
+}

package/linthost/print_nodes_object.go

@@ -74,7 +74,7 @@ func printObjectLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
 //
 // Prettier's objectWrap:"preserve" default keeps such an object
 // expanded even when it would fit flat, treating the author's line
-// break as intentional structure. format/print-width mirrors that:
+// break as intentional structure. formatPrintWidth mirrors that:
 // without it a deliberately multi-line object that happens to fit
 // would be silently collapsed onto one line, which Prettier never
 // does.

package/linthost/print_nodes_ternary.go

@@ -0,0 +1,86 @@
+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, so the Doc engine's Indent stack
+// accumulates `tabWidth` columns per level.
+//
+// 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)
+  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) (Doc, bool) {
+  cond := node.AsConditionalExpression()
+  if cond == nil || cond.Condition == nil || cond.WhenTrue == nil || cond.WhenFalse == nil {
+    return Doc{}, true
+  }
+  testDoc, c1 := PrintNode(ctx, cond.Condition)
+  consDoc, c2 := ternaryArm(ctx, cond.WhenTrue)
+  altDoc, c3 := ternaryArm(ctx, cond.WhenFalse)
+  doc := Concat(
+    testDoc,
+    Indent(ctx.indentUnit(),
+      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.
+func ternaryArm(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node != nil && node.Kind == shimast.KindConditionalExpression {
+    return buildConditionalChain(ctx, node)
+  }
+  doc, covered := PrintNode(ctx, node)
+  return Align(doc), covered
+}

package/linthost/rule_names.go

@@ -0,0 +1,14 @@
+package linthost
+
+import "strings"
+
+// normalizeBuiltinRuleName strips the optional `eslint/` namespace prefix
+// so users may write either the bare rule id or the explicit `eslint/<id>`
+// form. `@ttsc/lint` deliberately rejects the legacy `@typescript-eslint/`
+// and `typescript-eslint/` prefixes — TypeScript-only rules live under
+// the canonical `typescript/<id>` namespace.
+func normalizeBuiltinRuleName(name string) string {
+  name = strings.TrimSpace(name)
+  name = strings.TrimPrefix(name, "eslint/")
+  return name
+}

package/linthost/rules_arrays.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-sparse-arrays: `[1, , 2]` — the implied undefined slot is almost
+// noSparseArrays: `[1, , 2]` — the implied undefined slot is almost
 // always a typo.
 // https://eslint.org/docs/latest/rules/no-sparse-arrays
 type noSparseArrays struct{}
@@ -24,7 +24,7 @@ func (noSparseArrays) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-array-constructor: forbid `new Array(0)` / `Array(1, 2, 3)` (use
+// noArrayConstructor: forbid `new Array(0)` / `Array(1, 2, 3)` (use
 // array literals). The single-argument form is intentionally excluded from
 // the ban: `Array(n)` is commonly used to pre-allocate a sparse array by
 // length, and banning it would generate noise on existing idiomatic code.