@ttsc/lint 0.12.3 → 0.13.0

package/linthost/print_dispatch.go

@@ -9,10 +9,10 @@ import (
 //
 // The dispatcher is the bridge between the TypeScript-Go AST and the
 // printer engine. It walks one node at a time and emits a Doc tree
-// shaped to that node's grammar. Coverage is intentionally partial in
-// v1; the verbatim fallback below guarantees that an un-handled node
-// kind contributes its original source bytes verbatim, so the printer
-// can be wired up to a rule without breaking files that happen to use
+// shaped to that node's grammar. Coverage is intentionally partial;
+// the verbatim fallback below guarantees that an un-handled node kind
+// contributes its original source bytes verbatim, so the printer can
+// be wired up to a rule without breaking files that happen to use
 // shapes the per-node printers don't yet understand.
 //
 // The price of verbatim fallback is that reflow stops at the boundary
@@ -20,6 +20,19 @@ import (
 // dispatcher doesn't recognize stays long. That trade-off is preferable
 // to corrupting unfamiliar shapes — extension over time turns each
 // verbatim hop into a real reflow.
+//
+// Coverage signal. A verbatim slice keeps its *original* source column.
+// When an un-handled node spans multiple lines, its interior lines are
+// frozen at the columns the user wrote while the enclosing reflow
+// re-indents everything around it — the result is inconsistently
+// 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
+// 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:
+// a node confined to one source line has no interior column to freeze.
 
 // PrintContext bundles the per-file inputs every per-node printer
 // needs. The dispatcher constructs one per top-level reflow and threads
@@ -42,46 +55,96 @@ func NewPrintContext(file *shimast.SourceFile, opts PrintOptions) *PrintContext
 
 // PrintNode is the dispatcher entry. It picks a per-node printer based
 // on `node.Kind` and falls back to the verbatim source slice when no
-// printer is registered. Returns the printed Doc and a boolean
-// indicating whether the dispatch actually reformatted the node. The
-// boolean is currently only used by the format/print-width rule, which
-// skips edit emission when every printable child fell back to
-// verbatim (no behavior change, no diagnostic).
+// printer is registered. Returns the printed Doc and a `covered`
+// 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
+// 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) {
   if node == nil {
-    return Doc{}, false
+    return Doc{}, true
   }
-  if doc, reformatted, ok := dispatchNode(ctx, node); ok {
-    return doc, reformatted
+  if doc, covered, ok := dispatchNode(ctx, node); ok {
+    return doc, covered
   }
-  return verbatim(ctx, node), false
+  return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
 }
 
 // dispatchNode is the per-kind switch. Each branch returns
-// (doc, reformatted, true) when it produces a structured Doc, or
+// (doc, covered, true) when it produces a structured Doc, or
 // (zero, false, false) to let the caller fall back to verbatim. The
-// reformatted flag is true when the per-node printer asserts the
-// result may differ from the original bytes.
+// `covered` flag is `true` only when the per-node printer guarantees
+// the whole subtree it produced is free of multi-line verbatim slices.
 func dispatchNode(ctx *PrintContext, node *shimast.Node) (Doc, bool, bool) {
   switch node.Kind {
   case shimast.KindObjectLiteralExpression:
-    return printObjectLiteral(ctx, node), true, true
+    doc, covered := printObjectLiteral(ctx, node)
+    return doc, covered, true
   case shimast.KindArrayLiteralExpression:
-    return printArrayLiteral(ctx, node), true, true
+    doc, covered := printArrayLiteral(ctx, node)
+    return doc, covered, true
   case shimast.KindCallExpression:
-    return printCallExpression(ctx, node), true, true
+    doc, covered := printCallExpression(ctx, node)
+    return doc, covered, true
   case shimast.KindNewExpression:
-    return printNewExpression(ctx, node), true, true
+    doc, covered := printNewExpression(ctx, node)
+    return doc, covered, true
   case shimast.KindNamedImports:
-    return printNamedImports(ctx, node), true, true
+    doc, covered := printNamedImports(ctx, node)
+    return doc, covered, true
   case shimast.KindNamedExports:
-    return printNamedExports(ctx, node), true, true
+    doc, covered := printNamedExports(ctx, node)
+    return doc, covered, true
   case shimast.KindImportDeclaration:
-    return printImportDeclaration(ctx, node), true, true
+    doc, covered := printImportDeclaration(ctx, node)
+    return doc, covered, true
+  case shimast.KindArrowFunction:
+    doc, covered := printArrowFunction(ctx, node)
+    return doc, covered, true
+  case shimast.KindFunctionExpression:
+    doc, covered := printFunctionExpression(ctx, node)
+    return doc, covered, true
+  case shimast.KindParenthesizedExpression:
+    doc, covered := printParenthesizedExpression(ctx, node)
+    return doc, covered, true
+  case shimast.KindBlock:
+    doc, covered := printBlock(ctx, node)
+    return doc, covered, true
+  case shimast.KindExpressionStatement:
+    doc, covered := printExpressionStatement(ctx, node)
+    return doc, covered, true
+  case shimast.KindReturnStatement:
+    doc, covered := printReturnStatement(ctx, node)
+    return doc, covered, true
   }
   return Doc{}, false, false
 }
 
+// nodeSpansMultipleLines reports whether `node`'s trivia-trimmed source
+// range crosses a newline. A verbatim slice that stays on one line is
+// always reflow-safe — there is no interior column for the enclosing
+// re-indent to leave stranded — so the dispatcher treats single-line
+// verbatim as `covered`. A multi-line verbatim node freezes its
+// interior columns and is reported uncovered.
+func nodeSpansMultipleLines(ctx *PrintContext, node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  start := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  end := node.End()
+  if start < 0 || end < start || end > len(ctx.Source) {
+    return false
+  }
+  for i := start; i < end; i++ {
+    if ctx.Source[i] == '\n' {
+      return true
+    }
+  }
+  return false
+}
+
 // verbatim returns the original source bytes for `node`, leading trivia
 // trimmed. Use this whenever a printer cannot fully cover a node — the
 // surrounding doc tree still flows, but the verbatim slice carries
@@ -98,9 +161,10 @@ func verbatim(ctx *PrintContext, node *shimast.Node) Doc {
   return Text(ctx.Source[start:end])
 }
 
-// verbatimRange is the position-only sibling of verbatim — useful when
-// the printer needs to copy a sub-range that does not correspond to a
-// single AST node (e.g. tokens between two siblings).
+// verbatimRange returns a Text doc holding src[start:end] verbatim.
+// It is the position-only sibling of verbatim: use it when the sub-range
+// to copy does not correspond to a single AST node (e.g. `<T>` tokens
+// that surround a type-argument NodeList).
 func verbatimRange(src string, start, end int) Doc {
   if start < 0 || end < start || end > len(src) {
     return Doc{}
@@ -108,11 +172,47 @@ func verbatimRange(src string, start, end int) Doc {
   return Text(src[start:end])
 }
 
-// indentUnit returns one indentation step's worth of columns. Each
-// per-node printer uses this for its own list nesting.
+// indentUnit returns the number of columns in one indentation step,
+// derived from PrintOptions.TabWidth. Falls back to 2 when TabWidth
+// is not set, matching the Prettier default.
 func (ctx *PrintContext) indentUnit() int {
   if ctx.Opts.TabWidth > 0 {
     return ctx.Opts.TabWidth
   }
   return 2
 }
+
+// trailingCommaMode normalizes ctx.Opts.TrailingComma to one of "all",
+// "es5", or "none". An empty value — the zero value for the field —
+// reads as "all" to keep pre-existing callers and tests that built a
+// PrintOptions{} without setting the field on Prettier's default
+// behavior. Any other value also reads as "all"; the config layer
+// rejects unknown strings before they reach the printer (see
+// `expandFormatBlock` in config_format.go), so a stray value here is a
+// programmer error and the safest fallback is the most-commas mode.
+func (ctx *PrintContext) trailingCommaMode() string {
+  switch ctx.Opts.TrailingComma {
+  case "es5", "none":
+    return ctx.Opts.TrailingComma
+  }
+  return "all"
+}
+
+// allowsCallArgumentTrailingComma reports whether a multi-line call /
+// new argument list should emit a trailing comma under the current
+// trailingComma setting. Trailing commas in call arguments arrived in
+// ES2017, so Prettier's "es5" mode excludes them just like "none" does;
+// only "all" keeps them. Parameter lists are not printed by the
+// dispatcher today, but the same rule applies to them when they are.
+func (ctx *PrintContext) allowsCallArgumentTrailingComma() bool {
+  return ctx.trailingCommaMode() == "all"
+}
+
+// allowsEs5TrailingComma reports whether a multi-line ES5-permitted
+// list — arrays, objects, named imports / exports — should emit a
+// trailing comma. Only "none" suppresses the comma here; "es5" and
+// "all" both keep it because ES5 has accepted trailing commas in these
+// positions since the language's inception.
+func (ctx *PrintContext) allowsEs5TrailingComma() bool {
+  return ctx.trailingCommaMode() != "none"
+}

package/linthost/print_doc.go

@@ -52,10 +52,17 @@ package linthost
 //   - DocLineSuffix queues output until the next hardline/softline that
 //     actually breaks; used for trailing line comments that must stick
 //     to their source line.
+//   - DocConditionalGroup offers an ordered list of layout options; the
+//     engine renders the first whose first line fits the width budget
+//     and uses the last option as the unconditional fallback.
 //
 // The doc tree is built by helper constructors (Text, Line, Group, …)
 // below. Constructors take their children as variadic or slice
 // arguments so call sites read like a layout DSL.
+
+// DocKind is the discriminant tag for a Doc node. Only the variant
+// fields relevant to that kind are populated; all others stay at their
+// zero value.
 type DocKind uint8
 
 const (
@@ -71,6 +78,7 @@ const (
   docIfBreak
   docConcat
   docLineSuffix
+  docConditionalGroup
 )
 
 // Doc is one node in the layout tree. Only the fields relevant to the
@@ -89,6 +97,11 @@ type Doc struct {
   Text     string
   Children []Doc
   Width    int
+  // Break, meaningful only on a docGroup, forces the group to render
+  // broken regardless of whether its flat form would fit. A
+  // ConditionalGroup option uses it to commit its last argument — a
+  // hugged object literal — to the multi-line shape.
+  Break bool
   // IfBreak pairs: BreakChild stored in Children[0], FlatChild in Children[1].
 }
 
@@ -112,6 +125,16 @@ func Literalline() Doc { return Doc{Kind: docLiteralline} }
 // concatenated.
 func Group(parts ...Doc) Doc { return Doc{Kind: docGroup, Children: parts} }
 
+// ConditionalGroup picks the first option whose first line fits the
+// remaining width budget, falling back to the last option when none
+// fit. Where Group makes a single flat-or-break decision, a
+// ConditionalGroup lets a printer offer several distinct shapes — a
+// call's hugged vs. exploded argument list — and have the engine choose
+// between them. The last option must always be a safe fallback.
+func ConditionalGroup(options ...Doc) Doc {
+  return Doc{Kind: docConditionalGroup, Children: options}
+}
+
 // Indent adds `width` columns of indentation to every newline emitted by
 // the child doc. Nesting composes.
 func Indent(width int, parts ...Doc) Doc {

package/linthost/print_engine.go

@@ -63,6 +63,21 @@ import "strings"
 // makes the close brace of a reflowed list land at `BaseIndent`
 // while its children sit at `BaseIndent + indentUnit`.
 //
+// TrailingComma mirrors Prettier's `trailingComma` setting and controls
+// which broken-list shapes the printer emits a trailing comma on:
+//
+//   - "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.
+//   - "none"            no list gets one.
+//
+// An empty string is treated as "all", which keeps `DefaultPrintOptions()`
+// callers and tests that pre-date this field on their original behavior.
+//
 // Defaults of 0 keep the engine usable for top-of-file reflow without
 // a wrapper.
 type PrintOptions struct {
@@ -70,14 +85,17 @@ type PrintOptions struct {
   TabWidth       int
   UseTabs        bool
   EndOfLine      string
+  TrailingComma  string
   StartingColumn int
   BaseIndent     int
 }
 
 // DefaultPrintOptions returns the Prettier defaults: 80-column lines,
-// 2-space indentation, LF line terminators.
+// 2-space indentation, LF line terminators, trailing commas on every
+// multi-line list (the `trailingComma: "all"` default Prettier adopted
+// in v2).
 func DefaultPrintOptions() PrintOptions {
-  return PrintOptions{PrintWidth: 80, TabWidth: 2, UseTabs: false, EndOfLine: "lf"}
+  return PrintOptions{PrintWidth: 80, TabWidth: 2, UseTabs: false, EndOfLine: "lf", TrailingComma: "all"}
 }
 
 // printMode is the per-group choice made by the fit measurement.
@@ -191,13 +209,30 @@ func Print(doc Doc, opts PrintOptions) string {
       child := Concat(top.doc.Children...)
       stack = append(stack, printFrame{indent: col, mode: top.mode, doc: child})
     case docGroup:
-      // Try flat unless the group contains a hardline.
+      // Try flat unless the group is forced broken or its flat form
+      // would overflow the remaining width.
       child := Concat(top.doc.Children...)
-      if fits(child, opts.PrintWidth-col, top.indent) {
+      if !top.doc.Break && fits(child, opts.PrintWidth-col, top.indent) {
         stack = append(stack, printFrame{indent: top.indent, mode: modeFlat, doc: child})
       } else {
         stack = append(stack, printFrame{indent: top.indent, mode: modeBreak, doc: child})
       }
+    case docConditionalGroup:
+      // Render the first option whose first line fits the remaining
+      // width; fall back to the last option when none do. fitsFirstLine
+      // measures only up to an option's first break, so an option whose
+      // later lines wrap — a hugged callback body — is still eligible.
+      options := top.doc.Children
+      if len(options) > 0 {
+        chosen := options[len(options)-1]
+        for i := 0; i < len(options)-1; i++ {
+          if fitsFirstLine(options[i], opts.PrintWidth-col) {
+            chosen = options[i]
+            break
+          }
+        }
+        stack = append(stack, printFrame{indent: top.indent, mode: top.mode, doc: chosen})
+      }
     case docIfBreak:
       pick := top.doc.Children[1] // flat
       if top.mode == modeBreak {
@@ -306,6 +341,11 @@ func fits(doc Doc, remaining int, indent int) bool {
         stack = append(stack, frame{mode: top.mode, doc: top.doc.Children[i]})
       }
     case docGroup:
+      // A forced-broken group cannot contribute a flat layout; treat it
+      // like a hard line break for the enclosing measurement.
+      if top.doc.Break {
+        return false
+      }
       // Measure nested groups in flat mode too — that is the
       // standard Wadler choice: the outer group's "does my
       // flat form fit" question is answered by treating every
@@ -313,6 +353,11 @@ func fits(doc Doc, remaining int, indent int) bool {
       for i := len(top.doc.Children) - 1; i >= 0; i-- {
         stack = append(stack, frame{mode: modeFlat, doc: top.doc.Children[i]})
       }
+    case docConditionalGroup:
+      // A conditional group's flat form is its first (flattest) option.
+      if len(top.doc.Children) > 0 {
+        stack = append(stack, frame{mode: top.mode, doc: top.doc.Children[0]})
+      }
     case docIfBreak:
       pick := top.doc.Children[1]
       if top.mode == modeBreak {
@@ -341,3 +386,122 @@ func fits(doc Doc, remaining int, indent int) bool {
   }
   return true
 }
+
+// fitsFirstLine reports whether the first line of `doc` — every column
+// up to its first line break — renders within `remaining` columns. It
+// drives ConditionalGroup option selection: an option is eligible when
+// its opening line fits, even if its later lines wrap.
+//
+// The walk treats every top-level break point as broken — an IfBreak
+// takes its break branch, and a Line / Softline / Hardline ends the
+// measurement — so it counts exactly the columns the option would place
+// on the line the group starts on. A nested ConditionalGroup
+// contributes its own first option.
+//
+// A nested Group is the exception: a Group with no hard break renders
+// flat when it fits, so its Line separators collapse to spaces and stay
+// on the first line. The walk measures such a Group's flattened width
+// rather than stopping at its first Line; only a Group that carries a
+// Hardline (flatten reports it cannot render flat) ends the first line
+// at its break.
+func fitsFirstLine(doc Doc, remaining int) bool {
+  if remaining < 0 {
+    return false
+  }
+  stack := []Doc{doc}
+  for len(stack) > 0 {
+    top := stack[len(stack)-1]
+    stack = stack[:len(stack)-1]
+    switch top.Kind {
+    case docText:
+      if idx := strings.IndexByte(top.Text, '\n'); idx >= 0 {
+        // A multi-line Text ends the first line at its first newline.
+        return remaining-idx >= 0
+      }
+      remaining -= len(top.Text)
+      if remaining < 0 {
+        return false
+      }
+    case docGroup:
+      // A Group that can render flat keeps its Lines on the first line
+      // as spaces — measure the flattened form. One that cannot (a
+      // Hardline or forced break inside) breaks, so descend and let the
+      // Line/Hardline case end the first line at that break.
+      if flat, ok := flatten(top); ok {
+        stack = append(stack, flat)
+      } else {
+        for i := len(top.Children) - 1; i >= 0; i-- {
+          stack = append(stack, top.Children[i])
+        }
+      }
+    case docConcat, docIndent, docAlign:
+      for i := len(top.Children) - 1; i >= 0; i-- {
+        stack = append(stack, top.Children[i])
+      }
+    case docConditionalGroup:
+      if len(top.Children) > 0 {
+        stack = append(stack, top.Children[0])
+      }
+    case docIfBreak:
+      // Measuring in break mode: take the broken branch.
+      stack = append(stack, top.Children[0])
+    case docLine, docSoftline, docHardline, docLiteralline:
+      // The first break ends the first line; what fit so far fits.
+      return true
+    case docNil, docLineSuffix:
+      // No first-line width contribution.
+    }
+  }
+  return true
+}
+
+// flatten returns the all-flat rendering of `doc`: every Group rendered
+// flat, every IfBreak resolved to its flat branch, every Line collapsed
+// to a single space and every Softline to nothing. The second result is
+// false when the doc cannot render flat at all — it carries a Hardline,
+// a Literalline, a forced-broken Group, a multi-line Text or a queued
+// LineSuffix — and the caller must then drop the flat layout option.
+func flatten(doc Doc) (Doc, bool) {
+  switch doc.Kind {
+  case docText:
+    if strings.Contains(doc.Text, "\n") {
+      return Doc{}, false
+    }
+    return doc, true
+  case docLine:
+    return Text(" "), true
+  case docNil, docSoftline:
+    return Doc{Kind: docNil}, true
+  case docHardline, docLiteralline, docLineSuffix:
+    return Doc{}, false
+  case docIfBreak:
+    return flatten(doc.Children[1])
+  case docConditionalGroup:
+    if len(doc.Children) == 0 {
+      return Doc{Kind: docNil}, true
+    }
+    return flatten(doc.Children[0])
+  case docGroup:
+    if doc.Break {
+      return Doc{}, false
+    }
+    return flattenChildren(doc.Children)
+  case docConcat, docIndent, docAlign:
+    return flattenChildren(doc.Children)
+  }
+  return doc, true
+}
+
+// flattenChildren flattens each child and concatenates the results,
+// short-circuiting to (zero, false) when any child cannot render flat.
+func flattenChildren(children []Doc) (Doc, bool) {
+  out := make([]Doc, 0, len(children))
+  for _, c := range children {
+    fc, ok := flatten(c)
+    if !ok {
+      return Doc{}, false
+    }
+    out = append(out, fc)
+  }
+  return Concat(out...), true
+}

package/linthost/print_nodes_array.go

@@ -20,27 +20,37 @@ import (
 // Array literals do NOT carry a leading/trailing space inside the
 // brackets in flat mode (`[a, b]`, not `[ a, b ]`), matching every
 // JavaScript formatter. Empty arrays collapse to `[]`.
-func printArrayLiteral(ctx *PrintContext, node *shimast.Node) Doc {
+//
+// The second return value is the `covered` flag: see PrintNode. It is
+// the AND of every element's coverage.
+func printArrayLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if node == nil {
-    return Doc{}
+    return Doc{}, true
   }
   arr := node.AsArrayLiteralExpression()
   if arr == nil || arr.Elements == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   items := make([]Doc, 0, len(arr.Elements.Nodes))
+  covered := true
   for _, elem := range arr.Elements.Nodes {
     if elem == nil {
-      return verbatim(ctx, node)
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
     }
-    doc, _ := PrintNode(ctx, elem)
+    doc, childCovered := PrintNode(ctx, elem)
+    covered = covered && childCovered
     items = append(items, doc)
   }
+  // AddComma honors `format.trailingComma`: arrays accept trailing
+  // commas in ES5 so both "all" and "es5" keep them; only "none"
+  // suppresses. Hardcoding `true` would oscillate against Prettier on
+  // every `none` project (the trailing-comma rule wouldn't insert one
+  // and the printer would put one back).
   return printList(ctx, listShape{
     OpenTok:  "[",
     CloseTok: "]",
     Items:    items,
     Space:    false,
-    AddComma: true,
-  })
+    AddComma: ctx.allowsEs5TrailingComma(),
+  }), covered
 }