@ttsc/lint 0.25.0 → 0.26.0

package/linthost/rules_format_clause_join.go

@@ -13,16 +13,38 @@ import (
 //  if (a)
 //    b();
 //
-// becomes `if (a) b();` when the joined line fits printWidth. The same
-// applies to `for`, `for-in`, `for-of`, and `while` headers. A braced
-// body, a body that already shares the header line, a multi-line body,
-// or a join that would overflow printWidth is left untouched.
+// becomes `if (a) b();` when the joined line fits printWidth. The covered set
+// is Prettier's, not the set whose header happens to end in `)`: the `if`
+// consequent and alternate, the `for`, `for-in`, `for-of`, and `while` bodies,
+// the `do` body, the `with` body, and a labeled statement's body. A braced
+// body, a body that already shares the header line, a multi-line body, or a
+// join that would overflow printWidth is left untouched.
 //
-// The rule only ever rewrites the whitespace gap between a header's
-// closing `)` and the controlled statement, so its edits never overlap
-// `format/indent` (leading whitespace of a line) or `format/print-width`
-// (interior reflow). Idempotent: once joined the gap holds no newline
-// and the rule abstains.
+// Two clauses join unconditionally because Prettier gives them no group of
+// their own: an `else` whose alternate is another `if` (the `else if` chain),
+// and a labeled statement, which prints `label: statement` on one line whatever
+// the statement is, braces included. Those are the only clauses that can hoist a
+// multi-line body, and their continuation lines move by the same column delta
+// their first line travels, so the join does not settle on output Prettier would
+// still reindent.
+//
+// A continuation line whose newline sits inside a string, a template, or a
+// block comment is skipped rather than shifted: those bytes are content, and
+// moving them would change what the program prints or what a comment says. The
+// join itself still happens, because abandoning it leaves `format/indent` to
+// move the body's interior anyway and settles the file on a hybrid layout
+// Prettier never emits.
+//
+// The rule rewrites the whitespace gap between the clause's own header token
+// and the controlled statement, and, when it hoists a multi-line body, the
+// leading whitespace of that body's continuation lines. That surface overlaps
+// `format/indent`, which owns the same column for a hoisted body that contains
+// a block and cedes it only for a braceless control-flow body. The two agree on
+// the target column, so a collision costs a dropped finding and a re-fire rather
+// than a fight. Hoisting also contends with a nested join over the same bytes,
+// so a staircase settles roughly one level per cascade pass. Idempotent: once
+// joined the gap holds no newline, the shift compares against the text it would
+// write, and the rule abstains.
 type formatClauseJoin struct{ optionsRule }
 
 // formatClauseJoinOptions mirrors the printWidth/indent keys the rule
@@ -46,6 +68,9 @@ func (formatClauseJoin) Visits() []shimast.Kind {
     shimast.KindForStatement,
     shimast.KindForInStatement,
     shimast.KindForOfStatement,
+    shimast.KindDoStatement,
+    shimast.KindWithStatement,
+    shimast.KindLabeledStatement,
   }
 }
 
@@ -63,24 +88,67 @@ func (formatClauseJoin) Check(ctx *Context, node *shimast.Node) {
   if opts.TabWidth != nil && *opts.TabWidth > 0 {
     tabWidth = *opts.TabWidth
   }
-  joinClauseBody(ctx, ctx.File.Text(), node, clauseControlledBody(node), printWidth, tabWidth)
+  src := ctx.File.Text()
+  for _, target := range clauseControlledBodies(node) {
+    joinClauseBody(ctx, src, node, target, printWidth, tabWidth)
+  }
 }
 
-// clauseControlledBody returns the single controlled statement of a
-// control-flow header, the `then` branch for `if`, the loop body for
-// the iteration statements. The `else` branch is intentionally excluded:
-// its body is anchored after the `else` keyword rather than a `)`, so it
-// does not share this rule's `)`-anchored join shape.
-func clauseControlledBody(node *shimast.Node) *shimast.Node {
+// clauseJoinTarget is one joinable clause body plus the token that ends the
+// clause header immediately before it. The anchor is what generalizes the rule
+// past the `)`-headed statements: `else` and `do` end in a keyword, a labeled
+// statement ends in `:`, and requiring the exact token still keeps a comment
+// between header and body from being swallowed.
+type clauseJoinTarget struct {
+  body   *shimast.Node
+  anchor string
+  // alwaysJoin marks a clause Prettier keeps on the header line regardless of
+  // the body's own line count or the joined width: an `else if` chain and a
+  // labeled statement.
+  alwaysJoin bool
+}
+
+// clauseControlledBodies returns every clause body of `node` that Prettier
+// keeps on its header line, paired with the token that header ends in. The set
+// is Prettier's, not the AST's: the `if` consequent and alternate, the loop
+// bodies, the `do` body, the `with` body, and a labeled statement's body.
+func clauseControlledBodies(node *shimast.Node) []clauseJoinTarget {
   switch node.Kind {
   case shimast.KindIfStatement:
-    return node.AsIfStatement().ThenStatement
+    stmt := node.AsIfStatement()
+    if stmt == nil {
+      return nil
+    }
+    targets := []clauseJoinTarget{{body: stmt.ThenStatement, anchor: ")"}}
+    if stmt.ElseStatement != nil {
+      targets = append(targets, clauseJoinTarget{
+        body:   stmt.ElseStatement,
+        anchor: "else",
+        // Prettier prints an `else if` chain flat, so the alternate being an
+        // `if` joins even when that nested statement spans lines.
+        alwaysJoin: stmt.ElseStatement.Kind == shimast.KindIfStatement,
+      })
+    }
+    return targets
   case shimast.KindWhileStatement:
-    return node.AsWhileStatement().Statement
+    return []clauseJoinTarget{{body: node.AsWhileStatement().Statement, anchor: ")"}}
   case shimast.KindForStatement:
-    return node.AsForStatement().Statement
+    return []clauseJoinTarget{{body: node.AsForStatement().Statement, anchor: ")"}}
   case shimast.KindForInStatement, shimast.KindForOfStatement:
-    return node.AsForInOrOfStatement().Statement
+    return []clauseJoinTarget{{body: node.AsForInOrOfStatement().Statement, anchor: ")"}}
+  case shimast.KindDoStatement:
+    return []clauseJoinTarget{{body: node.AsDoStatement().Statement, anchor: "do"}}
+  case shimast.KindWithStatement:
+    return []clauseJoinTarget{{body: node.AsWithStatement().Statement, anchor: ")"}}
+  case shimast.KindLabeledStatement:
+    // A label carries no group of its own in Prettier: `label: statement` is
+    // one line whatever the statement is, so the body may be a block and may
+    // span lines.
+    return []clauseJoinTarget{{
+      body:       node.AsLabeledStatement().Statement,
+      anchor:     ":",
+      alwaysJoin: true,
+    }}
   }
   return nil
 }
@@ -89,18 +157,25 @@ func joinClauseBody(
   ctx *Context,
   src string,
   node *shimast.Node,
-  body *shimast.Node,
+  target clauseJoinTarget,
   printWidth int,
   tabWidth int,
 ) {
-  if body == nil || body.Kind == shimast.KindBlock {
+  body := target.body
+  if body == nil {
     return
   }
-  // An empty-statement body (`while (x)\n;`) glues directly to the header with
-  // NO space: Prettier's adjustClause special-cases EmptyStatement and returns
-  // the bare `;` (`while (x);`), only prepending a space when the empty
-  // statement carries a leading comment. This rule's gap->" " rewrite cannot
-  // produce the spaceless `);` glue, so abstain and leave the source shape.
+  // A braced body already owns its own line layout, except behind a label,
+  // where Prettier writes `label: {`.
+  if body.Kind == shimast.KindBlock && !target.alwaysJoin {
+    return
+  }
+  // An empty-statement body glues directly to the header with NO space:
+  // Prettier's adjustClause special-cases EmptyStatement and returns the bare
+  // `;` (`while (x);`, `else;`, `do;`, `label:;`), only prepending a space when
+  // the empty statement carries a leading comment. This rule joins with a
+  // single space and deliberately does not take on the spaceless variant, so it
+  // abstains and leaves the source shape rather than emitting `while (x) ;`.
   if body.Kind == shimast.KindEmptyStatement {
     return
   }
@@ -110,24 +185,29 @@ func joinClauseBody(
     return
   }
   // The gap is the whitespace run immediately before the body. Walk back
-  // over horizontal whitespace and newlines; the byte before it must be
-  // the header's closing `)` so a comment between header and body (which
+  // over horizontal whitespace and newlines; the bytes before it must be the
+  // clause's own header token so a comment between header and body (which
   // SkipTrivia would have stepped over) can never be swallowed.
   gapStart := bodyStart
   for gapStart > 0 && isClauseGapByte(src[gapStart-1]) {
     gapStart--
   }
-  if gapStart == 0 || src[gapStart-1] != ')' {
+  anchorStart := gapStart - len(target.anchor)
+  if anchorStart < 0 || src[anchorStart:gapStart] != target.anchor {
     return
   }
   gap := src[gapStart:bodyStart]
   if !strings.Contains(gap, "\n") {
     return // body already shares the header line
   }
-  // The header and the body must each be single-line; a multi-line body
-  // (e.g. a nested clause not yet joined) waits for the cascade to settle
-  // its inner join first.
+  // The header line is measured from the token that opens the clause. For a
+  // `)`-headed statement and a label that is the statement's own start; for
+  // `else` and `do` it is the keyword, which is where Prettier starts the line
+  // it would print.
   headerStart := shimscanner.SkipTrivia(src, node.Pos())
+  if isClauseAnchorWord(target.anchor) {
+    headerStart = anchorStart
+  }
   if headerStart < 0 || headerStart > gapStart {
     return
   }
@@ -135,28 +215,197 @@ func joinClauseBody(
   if strings.ContainsRune(src[headerLineStart:gapStart], '\n') {
     return
   }
-  if strings.ContainsRune(src[bodyStart:bodyEnd], '\n') {
-    return
+  if !target.alwaysJoin {
+    // The body must be single-line; a multi-line body (e.g. a nested clause
+    // not yet joined) waits for the cascade to settle its inner join first.
+    if strings.ContainsRune(src[bodyStart:bodyEnd], '\n') {
+      return
+    }
+    joined := visualWidth(src[headerLineStart:gapStart], tabWidth) + 1 +
+      visualWidth(src[bodyStart:bodyEnd], tabWidth)
+    if joined > printWidth {
+      return
+    }
   }
-  joined := visualWidth(src[headerLineStart:gapStart], tabWidth) + 1 +
-    visualWidth(src[bodyStart:bodyEnd], tabWidth)
-  if joined > printWidth {
-    return
+  edits := []TextEdit{{Pos: gapStart, End: bodyStart, Text: " "}}
+  // Hoisting the body's first line moves its base column. Every continuation
+  // line has to move with it, or the join settles on output Prettier would
+  // still reindent (#1139). Only an alwaysJoin clause can reach a multi-line
+  // body; the others already abstained above.
+  if strings.ContainsRune(src[bodyStart:bodyEnd], '\n') {
+    edits = append(edits, reindentJoinedClauseBody(
+      ctx, src, headerLineStart, bodyStart, bodyEnd, loadFormatLayout(ctx),
+    )...)
   }
   ctx.ReportRangeFix(
     gapStart,
     bodyStart,
     "Single-statement clause body should join its header line.",
-    TextEdit{Pos: gapStart, End: bodyStart, Text: " "},
+    edits...,
   )
 }
 
+// reindentJoinedClauseBody returns the edits that move a hoisted body's
+// continuation lines by the same column delta its first line travels.
+//
+// The delta is the header line's own indent minus the indent of the line the
+// body currently starts on, because the body's first line lands on the header
+// line and Prettier prints its continuations relative to that. Measuring from
+// the anchor token instead would charge the width of a `} ` prefix and shift
+// every continuation line two columns too far.
+//
+// A line the shift must not touch is skipped, not made to abandon the join.
+// Abandoning is strictly worse: `format/indent` still moves the body's interior
+// to its post-join column, so the file settles on a hybrid layout Prettier never
+// emits, which is the very property this shift exists to remove. Three kinds of
+// line are skipped: one whose newline sits inside a string, template, or block
+// comment, where the bytes are content rather than layout; a blank one, which
+// has no column; and one whose indent is shorter than an outdent needs.
+func reindentJoinedClauseBody(
+  ctx *Context,
+  src string,
+  headerLineStart int,
+  bodyStart int,
+  bodyEnd int,
+  layout formatLayout,
+) []TextEdit {
+  protected := collectClauseJoinProtectedRanges(ctx.File, src)
+  headerIndentEnd := headerLineStart
+  for headerIndentEnd < len(src) &&
+    (src[headerIndentEnd] == ' ' || src[headerIndentEnd] == '\t') {
+    headerIndentEnd++
+  }
+  bodyLineStart := lineStartOffset(src, bodyStart)
+  delta := visualWidth(src[headerLineStart:headerIndentEnd], layout.tabWidth) -
+    visualWidth(src[bodyLineStart:bodyStart], layout.tabWidth)
+  if delta == 0 {
+    return nil
+  }
+  var edits []TextEdit
+  for offset := bodyStart; offset < bodyEnd; offset++ {
+    if src[offset] != '\n' {
+      continue
+    }
+    if inTemplate(protected, offset) {
+      continue
+    }
+    lineStart := offset + 1
+    indentEnd := lineStart
+    for indentEnd < bodyEnd && (src[indentEnd] == ' ' || src[indentEnd] == '\t') {
+      indentEnd++
+    }
+    if indentEnd >= bodyEnd || src[indentEnd] == '\n' || src[indentEnd] == '\r' {
+      continue // a blank line carries no column
+    }
+    width := visualWidth(src[lineStart:indentEnd], layout.tabWidth) + delta
+    if width < 0 {
+      continue
+    }
+    next := clauseJoinIndentOfWidth(layout, width)
+    if src[lineStart:indentEnd] == next {
+      continue
+    }
+    edits = append(edits, TextEdit{Pos: lineStart, End: indentEnd, Text: next})
+  }
+  return edits
+}
+
+// clauseJoinIndentOfWidth renders a column count in the project's own
+// indentation unit, so a tab-indented file keeps its tabs instead of being
+// silently respaced by the shift.
+func clauseJoinIndentOfWidth(layout formatLayout, width int) string {
+  if width <= 0 {
+    return ""
+  }
+  if layout.useTabs && layout.tabWidth > 0 {
+    // A width that is not a whole number of tabs keeps the remainder in spaces
+    // rather than dropping every tab, which is the respacing this render exists
+    // to prevent.
+    return layout.indent(width/layout.tabWidth) +
+      strings.Repeat(" ", width%layout.tabWidth)
+  }
+  return strings.Repeat(" ", width)
+}
+
+// collectClauseJoinProtectedRanges returns every byte span whose interior
+// newlines carry content rather than layout: template literals, string literals
+// spanning a line continuation, and block comments. Shifting a line inside one
+// changes what the program prints or what a comment says.
+func collectClauseJoinProtectedRanges(file *shimast.SourceFile, src string) []byteRange {
+  ranges := collectTemplateRanges(file, src)
+  var walk func(node *shimast.Node)
+  walk = func(node *shimast.Node) {
+    if node == nil {
+      return
+    }
+    if node.Kind == shimast.KindStringLiteral {
+      pos := shimscanner.SkipTrivia(src, node.Pos())
+      end := node.End()
+      if pos >= 0 && end <= len(src) && end > pos {
+        ranges = append(ranges, byteRange{pos: pos, end: end})
+      }
+    }
+    node.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  if file != nil && file.Statements != nil {
+    for _, stmt := range file.Statements.Nodes {
+      walk(stmt)
+    }
+  }
+  forEachCommentToken(file, func(kind shimast.Kind, start, end int) {
+    if kind != shimast.KindMultiLineCommentTrivia {
+      return
+    }
+    // Only a comment Prettier reprints verbatim is content. An indentable one,
+    // every continuation line starting with `*`, is realigned by Prettier to the
+    // current indentation, so protecting it would leave a well-formed JSDoc
+    // block misaligned behind a hoisted body.
+    if isIndentableBlockComment(src, start, end) {
+      return
+    }
+    ranges = append(ranges, byteRange{pos: start, end: end})
+  })
+  return ranges
+}
+
+// isIndentableBlockComment reports whether every continuation line of a block
+// comment begins with `*`, which is the shape Prettier reindents rather than
+// reproducing byte for byte.
+func isIndentableBlockComment(src string, start, end int) bool {
+  if start < 0 || end > len(src) || end <= start {
+    return false
+  }
+  body := src[start:end]
+  if !strings.Contains(body, "\n") {
+    return false
+  }
+  for _, line := range strings.Split(body, "\n")[1:] {
+    trimmed := strings.TrimLeft(line, " \t\r")
+    if !strings.HasPrefix(trimmed, "*") {
+      return false
+    }
+  }
+  return true
+}
+
 // isClauseGapByte reports whether `c` is whitespace that may appear in
 // the gap between a clause header and its controlled statement.
 func isClauseGapByte(c byte) bool {
   return c == ' ' || c == '\t' || c == '\r' || c == '\n'
 }
 
+// isClauseAnchorWord reports whether an anchor is a keyword rather than
+// punctuation, which decides where the width budget starts measuring. The
+// anchor needs no identifier-boundary check: it is read backward from the AST
+// body's own position, so the token before the gap is the clause's real keyword
+// and an identifier ending in `else` or `do` cannot reach it.
+func isClauseAnchorWord(anchor string) bool {
+  return anchor == "else" || anchor == "do"
+}
+
 // visualWidth returns the display-column width of `s`: a tab expands to a flat
 // `tabWidth` columns and everything else is charged by displayWidth, which is
 // Prettier's own measurement. The only approximation left is the flat tab

package/linthost/rules_format_parameter_properties.go

@@ -10,9 +10,8 @@ import (
 // formatParameterProperties breaks a constructor's parameter list onto
 // one-parameter-per-line when it declares parameter properties, matching
 // Prettier 3. Prettier forces the break whenever a constructor has more
-// than one parameter and at least one carries an accessibility or
-// `readonly` modifier (a parameter property), regardless of whether the
-// flat form fits printWidth:
+// than one parameter and at least one carries a parameter-property
+// modifier, regardless of whether the flat form fits printWidth:
 //
 //  constructor(
 //    private readonly repo: Repository,
@@ -155,26 +154,15 @@ func (formatParameterProperties) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
-// anyParameterProperty reports whether any parameter carries an
-// accessibility (`public`/`private`/`protected`) or `readonly` modifier,
-// which makes it a parameter property.
+// anyParameterProperty reports whether any parameter is a parameter property.
+// It defers to the package's shared `isParameterProperty` so one definition
+// answers the question for every rule that asks it; restating the modifier set
+// here is what left `override` out and made this rule abstain on a legal
+// parameter property Prettier breaks.
 func anyParameterProperty(params []*shimast.Node) bool {
   for _, p := range params {
-    if p == nil {
-      continue
-    }
-    mods := p.Modifiers()
-    if mods == nil {
-      continue
-    }
-    for _, m := range mods.Nodes {
-      switch m.Kind {
-      case shimast.KindPublicKeyword,
-        shimast.KindPrivateKeyword,
-        shimast.KindProtectedKeyword,
-        shimast.KindReadonlyKeyword:
-        return true
-      }
+    if isParameterProperty(p) {
+      return true
     }
   }
   return false

package/linthost/rules_format_whitespace.go

@@ -311,7 +311,11 @@ func collectTemplateRanges(file *shimast.SourceFile, src string) []byteRange {
       return
     }
     switch node.Kind {
-    case shimast.KindNoSubstitutionTemplateLiteral, shimast.KindTemplateExpression:
+    case shimast.KindNoSubstitutionTemplateLiteral,
+      shimast.KindTemplateExpression,
+      // A template literal TYPE spans head plus spans like the expression form
+      // and its newlines are equally part of the declared type's text.
+      shimast.KindTemplateLiteralType:
       pos := shimscanner.SkipTrivia(src, node.Pos())
       end := node.End()
       if pos >= 0 && end <= len(src) && end > pos {