@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

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()`
@@ -192,10 +192,10 @@ func Print(doc Doc, opts PrintOptions) string {
       // Update column. A text fragment may contain embedded
       // newlines (verbatim slices). The column tracker counts
       // from the last newline.
-      if idx := strings.LastIndex(top.doc.Text, "\n"); idx >= 0 {
-        col = len(top.doc.Text) - idx - 1
+      if strings.Contains(top.doc.Text, "\n") {
+        col = displayWidthAfterLastNewline(top.doc.Text)
       } else {
-        col += len(top.doc.Text)
+        col += displayWidth(top.doc.Text)
       }
     case docConcat:
       // Push children in reverse so they pop in source order.
@@ -241,6 +241,51 @@ func Print(doc Doc, opts PrintOptions) string {
       stack = append(stack, printFrame{indent: top.indent, mode: top.mode, doc: pick})
     case docLineSuffix:
       lineSuffix = append(lineSuffix, top.doc.Children...)
+    case docFill:
+      // Prettier's fill: lay out [content, sep, content, sep, …] packing as
+      // many contents per line as fit, breaking a separator only when the
+      // current content (or the content+sep+next-content pair) overflows.
+      parts := top.doc.Children
+      if len(parts) == 0 {
+        break
+      }
+      rem := opts.PrintWidth - col
+      content := parts[0]
+      contentFits := fits(content, rem, top.indent)
+      if len(parts) == 1 {
+        m := modeBreak
+        if contentFits {
+          m = modeFlat
+        }
+        stack = append(stack, printFrame{indent: top.indent, mode: m, doc: content})
+        break
+      }
+      sep := parts[1]
+      if len(parts) == 2 {
+        cm, sm := modeBreak, modeBreak
+        if contentFits {
+          cm, sm = modeFlat, modeFlat
+        }
+        stack = append(stack, printFrame{indent: top.indent, mode: sm, doc: sep})
+        stack = append(stack, printFrame{indent: top.indent, mode: cm, doc: content})
+        break
+      }
+      rest := Doc{Kind: docFill, Children: parts[2:]}
+      pairFits := fits(Concat(content, sep, parts[2]), rem, top.indent)
+      // Push rest (bottom), then sep, then content (top) so they render in
+      // order content, sep, rest.
+      stack = append(stack, printFrame{indent: top.indent, mode: top.mode, doc: rest})
+      switch {
+      case pairFits:
+        stack = append(stack, printFrame{indent: top.indent, mode: modeFlat, doc: sep})
+        stack = append(stack, printFrame{indent: top.indent, mode: modeFlat, doc: content})
+      case contentFits:
+        stack = append(stack, printFrame{indent: top.indent, mode: modeBreak, doc: sep})
+        stack = append(stack, printFrame{indent: top.indent, mode: modeFlat, doc: content})
+      default:
+        stack = append(stack, printFrame{indent: top.indent, mode: modeBreak, doc: sep})
+        stack = append(stack, printFrame{indent: top.indent, mode: modeBreak, doc: content})
+      }
     case docLine:
       if top.mode == modeFlat {
         out.WriteByte(' ')
@@ -320,7 +365,7 @@ func fits(doc Doc, remaining int, indent int) bool {
     switch top.doc.Kind {
     case docNil:
     case docText:
-      remaining -= len(top.doc.Text)
+      remaining -= displayWidth(top.doc.Text)
       if remaining < 0 {
         return false
       }
@@ -364,6 +409,11 @@ func fits(doc Doc, remaining int, indent int) bool {
         pick = top.doc.Children[0]
       }
       stack = append(stack, frame{mode: top.mode, doc: pick})
+    case docFill:
+      // A fill's flat form is every content and separator flat.
+      for i := len(top.doc.Children) - 1; i >= 0; i-- {
+        stack = append(stack, frame{mode: modeFlat, doc: top.doc.Children[i]})
+      }
     case docLineSuffix:
       // Line suffix never contributes to flat width — it queues
       // for a future break. Skip.
@@ -416,9 +466,9 @@ func fitsFirstLine(doc Doc, remaining int) bool {
     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
+        return remaining-displayWidth(top.Text[:idx]) >= 0
       }
-      remaining -= len(top.Text)
+      remaining -= displayWidth(top.Text)
       if remaining < 0 {
         return false
       }
@@ -488,6 +538,13 @@ func flatten(doc Doc) (Doc, bool) {
     return flattenChildren(doc.Children)
   case docConcat, docIndent, docAlign:
     return flattenChildren(doc.Children)
+  case docFill:
+    // A fill's flat form is every content and separator rendered flat (its
+    // Line separators collapse to spaces). Without this case flatten returned
+    // the live Fill unchanged, so a supposedly all-flat option still carried a
+    // breakable fill and a hugged numeric array (`new Float32Array([ … ])`)
+    // rendered with the fill broken inside unbroken brackets.
+    return flattenChildren(doc.Children)
   }
   return doc, true
 }

package/linthost/print_nodes_array.go

@@ -31,6 +31,13 @@ func printArrayLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if arr == nil || arr.Elements == nil {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
+  // A comment between elements (or after `[`) would be dropped by the fresh
+  // separators; bail to verbatim and report UNCOVERED (hard `false`, not
+  // `!nodeSpansMultipleLines`) so an enclosing reflow abstains instead of
+  // breaking around this single-line verbatim array and moving it off its line.
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
   items := make([]Doc, 0, len(arr.Elements.Nodes))
   covered := true
   for _, elem := range arr.Elements.Nodes {
@@ -47,10 +54,165 @@ func printArrayLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   // 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: ctx.allowsEs5TrailingComma(),
+    OpenTok:     "[",
+    CloseTok:    "]",
+    Items:       items,
+    Space:       false,
+    AddComma:    ctx.allowsEs5TrailingComma(),
+    Fill:        isConciselyPrintedArray(arr.Elements.Nodes),
+    ForceBreak:  arrayShouldForceBreak(arr.Elements.Nodes),
+    BlankBefore: blankBeforeItems(ctx.Source, arr.Elements.Nodes),
   }), covered
 }
+
+// arrayShouldForceBreak reports whether an array literal takes Prettier's
+// forced one-element-per-line layout even when it would fit flat: more than one
+// element, every element an array or object literal carrying more than one
+// child, and consecutive elements of the same kind (`[["(", ")"], ["{", "}"]]`
+// and `new Map([[k, v], [k, v]])` break; a mixed `[[1, 2], { c: 3 }]` and a
+// lone `[[1, 2]]` or single-child inners stay flat). Mirrors Prettier's array
+// shouldBreak heuristic.
+func arrayShouldForceBreak(elems []*shimast.Node) bool {
+  if len(elems) < 2 {
+    return false
+  }
+  for i, e := range elems {
+    if !isMultiChildArrayOrObject(e) {
+      return false
+    }
+    if i+1 < len(elems) && elems[i+1] != nil && elems[i+1].Kind != e.Kind {
+      return false
+    }
+  }
+  return true
+}
+
+// isMultiChildArrayOrObject reports whether `node` is an array or object literal
+// with more than one element/property.
+func isMultiChildArrayOrObject(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindArrayLiteralExpression:
+    if a := node.AsArrayLiteralExpression(); a != nil && a.Elements != nil {
+      return len(a.Elements.Nodes) > 1
+    }
+  case shimast.KindObjectLiteralExpression:
+    if o := node.AsObjectLiteralExpression(); o != nil && o.Properties != nil {
+      return len(o.Properties.Nodes) > 1
+    }
+  }
+  return false
+}
+
+// arrayForcesBreak reports whether `node` is an array literal that Prettier's
+// shouldBreak heuristic explodes regardless of width. The print-width rule
+// consults it so its flat-fit fast path does not leave such an array inline
+// when the source wrote it on one line.
+func arrayForcesBreak(node *shimast.Node) bool {
+  if node == nil || node.Kind != shimast.KindArrayLiteralExpression {
+    return false
+  }
+  arr := node.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil {
+    return false
+  }
+  return arrayShouldForceBreak(arr.Elements.Nodes)
+}
+
+// fastPathForcesBreak reports whether `node`, OR a force-breaking node nested
+// within the subtree a reflow of `node` would print (its call/new arguments and
+// array elements, recursively), must explode even though it fits flat. Prettier
+// breaks such a descendant — an array `shouldBreak` or a function-composition
+// call/new — when the enclosing node reflows; ttsc's print-width fast path
+// returns first while the descendant abstains via hasReflowAncestor, leaving
+// both flat (`new Map([["a", 1], ["b", 2]])`, `foo([[1, 2], [3, 4]])`). So the
+// fast path must consult this, not only the visited node itself.
+func fastPathForcesBreak(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  if callForcesFunctionBreak(node) || arrayForcesBreak(node) {
+    return true
+  }
+  var children []*shimast.Node
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    if c := node.AsCallExpression(); c != nil && c.Arguments != nil {
+      children = c.Arguments.Nodes
+    }
+  case shimast.KindNewExpression:
+    if n := node.AsNewExpression(); n != nil && n.Arguments != nil {
+      children = n.Arguments.Nodes
+    }
+  case shimast.KindArrayLiteralExpression:
+    if a := node.AsArrayLiteralExpression(); a != nil && a.Elements != nil {
+      children = a.Elements.Nodes
+    }
+  case shimast.KindObjectLiteralExpression:
+    // A force-breaking array/object nested in an object PROPERTY value
+    // (`{ m: [[1, 2], [3, 4]] }`) must also deny the fast path: the value
+    // abstains to its object ancestor via hasReflowAncestor, and the object
+    // itself fits flat, so without descending into property initializers both
+    // would stay flat where Prettier breaks them.
+    if o := node.AsObjectLiteralExpression(); o != nil && o.Properties != nil {
+      for _, p := range o.Properties.Nodes {
+        if p != nil && p.Kind == shimast.KindPropertyAssignment {
+          if pa := p.AsPropertyAssignment(); pa != nil && pa.Initializer != nil {
+            children = append(children, pa.Initializer)
+          }
+        }
+      }
+    }
+  }
+  for _, ch := range children {
+    if fastPathForcesBreak(ch) {
+      return true
+    }
+  }
+  return false
+}
+
+// isConciselyPrintedArray reports whether an array should use Prettier's
+// concise "fill" layout: at least one element and every element a numeric
+// literal (optionally a `+`/`-` signed numeric). Prettier packs such arrays
+// several per line; mixed / string / identifier arrays stay one-per-line.
+// Prettier's predicate gates on `elements.length > 0` (array.js), so a
+// single-element numeric array counts — which also makes a `[42]` last
+// argument decline last-argument hugging, matching shouldExpandLastArg.
+func isConciselyPrintedArray(elems []*shimast.Node) bool {
+  if len(elems) < 1 {
+    return false
+  }
+  for _, e := range elems {
+    if !isNumericArrayElement(e) {
+      return false
+    }
+  }
+  return true
+}
+
+// isNumericArrayElement reports whether `node` is a numeric literal or a
+// `+`/`-` prefix applied to one. A BigInt literal is NOT numeric here: Prettier's
+// isNumericLiteral matches only a number-valued literal, so `[1n, 2n]` prints
+// one element per line rather than filling.
+func isNumericArrayElement(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindNumericLiteral:
+    return true
+  case shimast.KindPrefixUnaryExpression:
+    u := node.AsPrefixUnaryExpression()
+    if u == nil || u.Operand == nil {
+      return false
+    }
+    if u.Operator != shimast.KindPlusToken && u.Operator != shimast.KindMinusToken {
+      return false
+    }
+    return u.Operand.Kind == shimast.KindNumericLiteral
+  }
+  return false
+}