@ttsc/lint 0.12.4 → 0.13.0

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
 }

package/linthost/print_nodes_call.go

@@ -20,17 +20,23 @@ import (
 // Type arguments (`foo<A, B>(x)`) are preserved verbatim. Trailing
 // commas on type arguments are intentionally avoided — Prettier omits
 // them too (see prettier#10353).
-func printCallExpression(ctx *PrintContext, node *shimast.Node) Doc {
+//
+// The second return value is the `covered` flag: see PrintNode. The
+// callee, optional `?.` token and type arguments are verbatim, so a
+// multi-line callee taints coverage just as a multi-line argument does.
+func printCallExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if node == nil {
-    return Doc{}
+    return Doc{}, true
   }
   call := node.AsCallExpression()
   if call == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   parts := []Doc{}
+  covered := true
   if call.Expression != nil {
     parts = append(parts, verbatim(ctx, call.Expression))
+    covered = covered && !nodeSpansMultipleLines(ctx, call.Expression)
   }
   // Question-dot for optional call: `foo?.(x)`. The token byte range
   // lives between Expression.End() and the open paren; copy
@@ -43,38 +49,45 @@ func printCallExpression(ctx *PrintContext, node *shimast.Node) Doc {
     parts = append(parts, verbatimRange(ctx.Source, callTypeArgsStart(ctx, call), callTypeArgsEnd(ctx, call)))
   }
   if hasNilEntry(call.Arguments) {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
-  parts = append(parts, printArgList(ctx, call.Arguments))
-  return Concat(parts...)
+  argDoc, argCovered := printArgList(ctx, call.Arguments)
+  parts = append(parts, argDoc)
+  return Concat(parts...), covered && argCovered
 }
 
 // printNewExpression renders a NewExpression. It mirrors the call
 // expression printer; the only difference is the leading `new ` keyword
 // and the optional argument list (NewExpression may omit args entirely,
 // e.g. `new Foo`).
-func printNewExpression(ctx *PrintContext, node *shimast.Node) Doc {
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printNewExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if node == nil {
-    return Doc{}
+    return Doc{}, true
   }
   ne := node.AsNewExpression()
   if ne == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   parts := []Doc{Text("new ")}
+  covered := true
   if ne.Expression != nil {
     parts = append(parts, verbatim(ctx, ne.Expression))
+    covered = covered && !nodeSpansMultipleLines(ctx, ne.Expression)
   }
   if ne.TypeArguments != nil {
     parts = append(parts, verbatimRange(ctx.Source, newTypeArgsStart(ctx, ne), newTypeArgsEnd(ctx, ne)))
   }
   if ne.Arguments != nil {
     if hasNilEntry(ne.Arguments) {
-      return verbatim(ctx, node)
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
     }
-    parts = append(parts, printArgList(ctx, ne.Arguments))
+    argDoc, argCovered := printArgList(ctx, ne.Arguments)
+    parts = append(parts, argDoc)
+    covered = covered && argCovered
   }
-  return Concat(parts...)
+  return Concat(parts...), covered
 }
 
 // hasNilEntry reports whether any entry of `list` is a nil pointer.
@@ -94,24 +107,120 @@ func hasNilEntry(list *shimast.NodeList) bool {
 }
 
 // printArgList renders an argument node list. The shared printList
-// handles the open-comma-close shape; this helper just gathers the
-// per-argument docs.
-func printArgList(ctx *PrintContext, list *shimast.NodeList) Doc {
+// handles the open-comma-close shape; this helper gathers the
+// per-argument docs and threads each argument's `covered` flag up.
+//
+// When the final argument is a block-bodied callback or object literal,
+// the list renders in the "last-argument hugging" shape (see
+// printListHuggingLast): the callback's own body carries the multi-line
+// 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) {
   if list == nil {
-    return Text("()")
+    return Text("()"), true
   }
   items := make([]Doc, 0, len(list.Nodes))
+  covered := true
   for _, arg := range list.Nodes {
-    doc, _ := PrintNode(ctx, arg)
+    doc, childCovered := PrintNode(ctx, arg)
+    covered = covered && childCovered
     items = append(items, doc)
   }
-  return printList(ctx, listShape{
+  // 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).
+  shape := listShape{
     OpenTok:  "(",
     CloseTok: ")",
     Items:    items,
     Space:    false,
-    AddComma: true,
-  })
+    AddComma: ctx.allowsCallArgumentTrailingComma(),
+    HugLast:  shouldHugLastArgument(list.Nodes),
+  }
+  return printList(ctx, shape), covered
+}
+
+// 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
+// block, an object literal, or an array literal. Hugging only applies
+// when that argument is genuinely the last one; a callback in the
+// middle of the list does not trigger the shape.
+//
+// An arrow with any other expression body (`(x) => x.id`) is
+// deliberately excluded. Such a body carries no internal break point,
+// so the hugging shape — a flat `Concat` with no Group — would pin the
+// whole call to one line even when that line overflows printWidth.
+// Routing it through the normal list shape instead lets the argument
+// list explode onto its own line when the call does not fit, which is
+// what Prettier does.
+func shouldHugLastArgument(args []*shimast.Node) bool {
+  if len(args) == 0 {
+    return false
+  }
+  last := args[len(args)-1]
+  if last == nil {
+    return false
+  }
+  switch last.Kind {
+  case shimast.KindFunctionExpression,
+    shimast.KindObjectLiteralExpression,
+    shimast.KindArrayLiteralExpression:
+    return true
+  case shimast.KindArrowFunction:
+    arrow := last.AsArrowFunction()
+    if arrow == nil || arrow.Body == nil {
+      return false
+    }
+    body := arrow.Body
+    // `(x) => ({ … })` parenthesizes its object body; hug on the inner
+    // expression, mirroring Prettier's couldExpandArg.
+    if body.Kind == shimast.KindParenthesizedExpression {
+      if p := body.AsParenthesizedExpression(); p != nil && p.Expression != nil {
+        body = p.Expression
+      }
+    }
+    switch body.Kind {
+    case shimast.KindBlock,
+      shimast.KindObjectLiteralExpression,
+      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
+// argument — an object or array literal, possibly nested inside an
+// arrow body (`(x) => ({ … })`) — to its multi-line shape. The caller
+// guards the walk with flatten: it is only run on an item that has no
+// hard line breaks of its own, so the first Group reached is the
+// hugged literal itself, never an unrelated Group inside a block body.
+func forceBreakFirstGroup(doc Doc) (Doc, bool) {
+  switch doc.Kind {
+  case docGroup:
+    doc.Break = true
+    return doc, true
+  case docConcat, docIndent, docAlign:
+    children := make([]Doc, len(doc.Children))
+    copy(children, doc.Children)
+    for i, child := range children {
+      broken, done := forceBreakFirstGroup(child)
+      if done {
+        children[i] = broken
+        doc.Children = children
+        return doc, true
+      }
+    }
+  }
+  return doc, false
 }
 
 // Type-argument byte-range helpers. The shim's NodeList.End() points