@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_curly.go

@@ -7,64 +7,64 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type curly struct{}
 
 func (curly) Name() string { return "curly" }
 func (curly) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindIfStatement,
-		shimast.KindWhileStatement,
-		shimast.KindDoStatement,
-		shimast.KindForStatement,
-		shimast.KindForInStatement,
-		shimast.KindForOfStatement,
-	}
+  return []shimast.Kind{
+    shimast.KindIfStatement,
+    shimast.KindWhileStatement,
+    shimast.KindDoStatement,
+    shimast.KindForStatement,
+    shimast.KindForInStatement,
+    shimast.KindForOfStatement,
+  }
 }
 func (curly) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindIfStatement:
-		stmt := node.AsIfStatement()
-		if stmt == nil {
-			return
-		}
-		curlyReportNonBlock(ctx, stmt.ThenStatement, "if")
-		// Allow `else if (...)` — the else branch carries another
-		// IfStatement that is itself visited and reported separately.
-		if stmt.ElseStatement != nil && stmt.ElseStatement.Kind != shimast.KindIfStatement {
-			curlyReportNonBlock(ctx, stmt.ElseStatement, "else")
-		}
-	case shimast.KindWhileStatement:
-		if stmt := node.AsWhileStatement(); stmt != nil {
-			curlyReportNonBlock(ctx, stmt.Statement, "while")
-		}
-	case shimast.KindDoStatement:
-		if stmt := node.AsDoStatement(); stmt != nil {
-			curlyReportNonBlock(ctx, stmt.Statement, "do")
-		}
-	case shimast.KindForStatement:
-		if stmt := node.AsForStatement(); stmt != nil {
-			curlyReportNonBlock(ctx, stmt.Statement, "for")
-		}
-	case shimast.KindForInStatement, shimast.KindForOfStatement:
-		if stmt := node.AsForInOrOfStatement(); stmt != nil {
-			curlyReportNonBlock(ctx, stmt.Statement, "for")
-		}
-	}
+  switch node.Kind {
+  case shimast.KindIfStatement:
+    stmt := node.AsIfStatement()
+    if stmt == nil {
+      return
+    }
+    curlyReportNonBlock(ctx, stmt.ThenStatement, "if")
+    // Allow `else if (...)` — the else branch carries another
+    // IfStatement that is itself visited and reported separately.
+    if stmt.ElseStatement != nil && stmt.ElseStatement.Kind != shimast.KindIfStatement {
+      curlyReportNonBlock(ctx, stmt.ElseStatement, "else")
+    }
+  case shimast.KindWhileStatement:
+    if stmt := node.AsWhileStatement(); stmt != nil {
+      curlyReportNonBlock(ctx, stmt.Statement, "while")
+    }
+  case shimast.KindDoStatement:
+    if stmt := node.AsDoStatement(); stmt != nil {
+      curlyReportNonBlock(ctx, stmt.Statement, "do")
+    }
+  case shimast.KindForStatement:
+    if stmt := node.AsForStatement(); stmt != nil {
+      curlyReportNonBlock(ctx, stmt.Statement, "for")
+    }
+  case shimast.KindForInStatement, shimast.KindForOfStatement:
+    if stmt := node.AsForInOrOfStatement(); stmt != nil {
+      curlyReportNonBlock(ctx, stmt.Statement, "for")
+    }
+  }
 }
 
 // curlyReportNonBlock reports `body` when it is a single bare statement
 // instead of a Block. A nil body means there is nothing to wrap (e.g. an
 // IfStatement with no else clause), so it is silently skipped.
 func curlyReportNonBlock(ctx *Context, body *shimast.Node, keyword string) {
-	if body == nil || body.Kind == shimast.KindBlock {
-		return
-	}
-	ctx.Report(body, "Expected { after '"+keyword+"' condition.")
+  if body == nil || body.Kind == shimast.KindBlock {
+    return
+  }
+  ctx.Report(body, "Expected { after '"+keyword+"' condition.")
 }
 
 func init() {
-	Register(curly{})
+  Register(curly{})
 }

package/linthost/rules_default_case.go

@@ -18,22 +18,22 @@ type defaultCase struct{}
 func (defaultCase) Name() string           { return "default-case" }
 func (defaultCase) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSwitchStatement} }
 func (defaultCase) Check(ctx *Context, node *shimast.Node) {
-	sw := node.AsSwitchStatement()
-	if sw == nil || sw.CaseBlock == nil {
-		return
-	}
-	block := sw.CaseBlock.AsCaseBlock()
-	if block == nil || block.Clauses == nil {
-		return
-	}
-	for _, clause := range block.Clauses.Nodes {
-		if clause != nil && clause.Kind == shimast.KindDefaultClause {
-			return
-		}
-	}
-	ctx.Report(node, "Expected a default case.")
+  sw := node.AsSwitchStatement()
+  if sw == nil || sw.CaseBlock == nil {
+    return
+  }
+  block := sw.CaseBlock.AsCaseBlock()
+  if block == nil || block.Clauses == nil {
+    return
+  }
+  for _, clause := range block.Clauses.Nodes {
+    if clause != nil && clause.Kind == shimast.KindDefaultClause {
+      return
+    }
+  }
+  ctx.Report(node, "Expected a default case.")
 }
 
 func init() {
-	Register(defaultCase{})
+  Register(defaultCase{})
 }

package/linthost/rules_default_case_last.go

@@ -16,31 +16,31 @@ type defaultCaseLast struct{}
 
 func (defaultCaseLast) Name() string { return "default-case-last" }
 func (defaultCaseLast) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSwitchStatement}
+  return []shimast.Kind{shimast.KindSwitchStatement}
 }
 func (defaultCaseLast) Check(ctx *Context, node *shimast.Node) {
-	sw := node.AsSwitchStatement()
-	if sw == nil || sw.CaseBlock == nil {
-		return
-	}
-	block := sw.CaseBlock.AsCaseBlock()
-	if block == nil || block.Clauses == nil {
-		return
-	}
-	clauses := block.Clauses.Nodes
-	if len(clauses) == 0 {
-		return
-	}
-	last := clauses[len(clauses)-1]
-	for i := 0; i < len(clauses)-1; i++ {
-		clause := clauses[i]
-		if clause != nil && clause.Kind == shimast.KindDefaultClause {
-			_ = last
-			ctx.Report(clause, "Default clause should be the last clause.")
-		}
-	}
+  sw := node.AsSwitchStatement()
+  if sw == nil || sw.CaseBlock == nil {
+    return
+  }
+  block := sw.CaseBlock.AsCaseBlock()
+  if block == nil || block.Clauses == nil {
+    return
+  }
+  clauses := block.Clauses.Nodes
+  if len(clauses) == 0 {
+    return
+  }
+  last := clauses[len(clauses)-1]
+  for i := 0; i < len(clauses)-1; i++ {
+    clause := clauses[i]
+    if clause != nil && clause.Kind == shimast.KindDefaultClause {
+      _ = last
+      ctx.Report(clause, "Default clause should be the last clause.")
+    }
+  }
 }
 
 func init() {
-	Register(defaultCaseLast{})
+  Register(defaultCaseLast{})
 }

package/linthost/rules_format_arrow_parens.go

@@ -0,0 +1,167 @@
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// formatArrowParens normalizes the parentheses around a single-parameter
+// arrow function, mirroring Prettier's `arrowParens`:
+//
+//   - prefer "always" (Prettier default): a bare `x => x` gains parens,
+//     becoming `(x) => x`.
+//   - prefer "avoid": `(x) => x` drops them, becoming `x => x`.
+//
+// Only a single parameter that is a plain identifier with no type
+// annotation, default, rest, optional `?`, or modifier is affected, every
+// other shape (`(x: T)`, `({ x })`, `(...x)`, `(x = 1)`, `(x?)`, `(x, y)`,
+// `()`) keeps its parentheses in both modes, exactly as Prettier does.
+// `async x => x` is handled too: the modifier sits before the parameter, so
+// the parameter-name span is unaffected.
+//
+// The rule rewrites only the parameter span (`x` <-> `(x)`), never the body
+// or the `=>`, so a chained arrow `a => b => …` has each eligible arm
+// normalized independently. Idempotent: a parameter already in the
+// preferred shape compares equal and emits nothing.
+type formatArrowParens struct{}
+
+type formatArrowParensOptions struct {
+  Prefer string `json:"prefer"`
+}
+
+func (formatArrowParens) Name() string   { return "format/arrow-parens" }
+func (formatArrowParens) IsFormat() bool { return true }
+
+func (formatArrowParens) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindArrowFunction}
+}
+
+func (formatArrowParens) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.File == nil || node == nil {
+    return
+  }
+  arrow := node.AsArrowFunction()
+  if arrow == nil || arrow.Parameters == nil {
+    return
+  }
+  params := arrow.Parameters.Nodes
+  if len(params) != 1 || params[0] == nil {
+    return
+  }
+  param := params[0]
+  if !isBareIdentifierParam(param) {
+    return
+  }
+  // A type-parameter list (`<T>(x) => …`) forces the parameter parens in
+  // both modes (a bare `<T>x =>` is not valid), so leave such an arrow
+  // alone, its parens are mandatory, not stylistic.
+  if arrow.TypeParameters != nil && len(arrow.TypeParameters.Nodes) > 0 {
+    return
+  }
+  // A return-type annotation (`(x): T => …`) also requires the parens.
+  if arrow.Type != nil {
+    return
+  }
+
+  var opts formatArrowParensOptions
+  _ = ctx.DecodeOptions(&opts)
+  prefer := opts.Prefer
+  if prefer != "avoid" {
+    prefer = "always"
+  }
+
+  src := ctx.File.Text()
+  nameStart := shimscanner.SkipTrivia(src, param.Pos())
+  nameEnd := param.End()
+  if nameStart < 0 || nameEnd <= nameStart || nameEnd > len(src) {
+    return
+  }
+
+  // Is the parameter already wrapped in `(` … `)`? Scan over whitespace on
+  // each side; the sole parameter of an arrow is delimited by the
+  // parameter-list parens when present.
+  openParen := scanBackForByte(src, nameStart, '(')
+  closeParen := scanForwardForByte(src, nameEnd, ')')
+  wrapped := openParen >= 0 && closeParen >= 0
+
+  switch prefer {
+  case "avoid":
+    if !wrapped {
+      return // already bare
+    }
+    // Replace `( … name … )` with just the name.
+    ctx.ReportRangeFix(
+      openParen,
+      closeParen+1,
+      "Single-parameter arrow should omit parentheses.",
+      TextEdit{Pos: openParen, End: closeParen + 1, Text: src[nameStart:nameEnd]},
+    )
+  default: // always
+    if wrapped {
+      return // already parenthesized
+    }
+    ctx.ReportRangeFix(
+      nameStart,
+      nameEnd,
+      "Single-parameter arrow should keep parentheses.",
+      TextEdit{Pos: nameStart, End: nameEnd, Text: "(" + src[nameStart:nameEnd] + ")"},
+    )
+  }
+}
+
+// isBareIdentifierParam reports whether `param` is a plain identifier
+// parameter: no rest `...`, no optional `?`, no type annotation, no default,
+// no modifier (a parameter property), and an identifier name. Only such a
+// parameter is eligible for arrow-paren normalization; every richer shape
+// keeps its parentheses in both Prettier modes.
+func isBareIdentifierParam(param *shimast.Node) bool {
+  decl := param.AsParameterDeclaration()
+  if decl == nil {
+    return false
+  }
+  if decl.DotDotDotToken != nil || decl.QuestionToken != nil ||
+    decl.Type != nil || decl.Initializer != nil {
+    return false
+  }
+  if mods := param.Modifiers(); mods != nil && len(mods.Nodes) > 0 {
+    return false
+  }
+  name := param.Name()
+  return name != nil && name.Kind == shimast.KindIdentifier
+}
+
+// scanBackForByte returns the offset of the nearest `target` byte at or
+// before `from`-1, scanning over whitespace only; -1 if a non-whitespace,
+// non-target byte is reached first.
+func scanBackForByte(src string, from int, target byte) int {
+  for i := from - 1; i >= 0; i-- {
+    c := src[i]
+    if c == target {
+      return i
+    }
+    if c != ' ' && c != '\t' && c != '\r' && c != '\n' {
+      return -1
+    }
+  }
+  return -1
+}
+
+// scanForwardForByte returns the offset of the nearest `target` byte at or
+// after `from`, scanning over whitespace only; -1 if a non-whitespace,
+// non-target byte is reached first.
+func scanForwardForByte(src string, from int, target byte) int {
+  for i := from; i < len(src); i++ {
+    c := src[i]
+    if c == target {
+      return i
+    }
+    if c != ' ' && c != '\t' && c != '\r' && c != '\n' {
+      return -1
+    }
+  }
+  return -1
+}
+
+func init() {
+  Register(formatArrowParens{})
+}

package/linthost/rules_format_bracket_spacing.go

@@ -0,0 +1,117 @@
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// formatBracketSpacing normalizes the inner padding of single-line brace
+// pairs, mirroring Prettier's `bracketSpacing`:
+//
+//   - prefer true (Prettier default): one space just inside the braces,
+//     `{ x: 1 }`, `{ a, b }`, `import { foo } from "m"`.
+//   - prefer false: no inner space, `{x: 1}`, `{a, b}`, `import {foo}`.
+//
+// It applies to object literals, object binding patterns (destructuring),
+// named imports/exports, and type literals, the brace kinds Prettier's
+// bracketSpacing governs. Block, class, interface, enum, and module braces
+// are NOT affected (their layout is owned by the indentation rules).
+//
+// The rule touches only a brace pair that opens and closes on the SAME
+// line: a multi-line container's interior is the indentation rules' surface,
+// and an empty `{}` has no interior to pad. It rewrites just the whitespace
+// run immediately inside each brace, so it never disturbs the contents.
+// Idempotent: a pair already in the preferred shape compares equal.
+type formatBracketSpacing struct{}
+
+type formatBracketSpacingOptions struct {
+  Spacing *bool `json:"spacing"`
+}
+
+func (formatBracketSpacing) Name() string   { return "format/bracket-spacing" }
+func (formatBracketSpacing) IsFormat() bool { return true }
+
+func (formatBracketSpacing) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindObjectLiteralExpression,
+    shimast.KindObjectBindingPattern,
+    shimast.KindNamedImports,
+    shimast.KindNamedExports,
+    shimast.KindTypeLiteral,
+  }
+}
+
+func (formatBracketSpacing) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.File == nil || node == nil {
+    return
+  }
+  var opts formatBracketSpacingOptions
+  _ = ctx.DecodeOptions(&opts)
+  spacing := true
+  if opts.Spacing != nil {
+    spacing = *opts.Spacing
+  }
+
+  src := ctx.File.Text()
+  start := shimscanner.SkipTrivia(src, node.Pos())
+  end := node.End()
+  if start < 0 || end <= start || end > len(src) {
+    return
+  }
+  // The node's first byte should be `{` and last `}`; a parenthesized or
+  // otherwise-wrapped form is out of scope.
+  if src[start] != '{' || src[end-1] != '}' {
+    return
+  }
+  inner := src[start+1 : end-1]
+  if len(inner) == 0 {
+    return // empty `{}`, nothing to pad
+  }
+  // Multi-line: the interior belongs to the indentation rules.
+  for i := 0; i < len(inner); i++ {
+    if inner[i] == '\n' || inner[i] == '\r' {
+      return
+    }
+  }
+  // Only-whitespace interior (`{   }`) is treated as empty: collapse to the
+  // canonical empty form rather than padding nothing.
+  trimmed := trimASCIISpace(inner)
+  if len(trimmed) == 0 {
+    return
+  }
+
+  // Compute the desired interior: exactly one leading+trailing space when
+  // spacing is on, none when off.
+  var want string
+  if spacing {
+    want = " " + trimmed + " "
+  } else {
+    want = trimmed
+  }
+  if inner == want {
+    return
+  }
+  ctx.ReportRangeFix(
+    start+1,
+    end-1,
+    "Normalize brace spacing to match bracketSpacing.",
+    TextEdit{Pos: start + 1, End: end - 1, Text: want},
+  )
+}
+
+// trimASCIISpace strips leading and trailing spaces and tabs from s.
+func trimASCIISpace(s string) string {
+  i := 0
+  for i < len(s) && (s[i] == ' ' || s[i] == '\t') {
+    i++
+  }
+  j := len(s)
+  for j > i && (s[j-1] == ' ' || s[j-1] == '\t') {
+    j--
+  }
+  return s[i:j]
+}
+
+func init() {
+  Register(formatBracketSpacing{})
+}

package/linthost/rules_format_clause_join.go

@@ -0,0 +1,172 @@
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// formatClauseJoin joins a single non-block statement that sits on its
+// own line back onto its control-flow header, mirroring Prettier:
+//
+//  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.
+//
+// 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.
+type formatClauseJoin struct{}
+
+// formatClauseJoinOptions mirrors the printWidth/indent keys the rule
+// needs to decide whether the joined line fits. The config layer mirrors
+// `format.printWidth`/`tabWidth`/`useTabs` into this rule's option blob
+// (see expandFormatBlock).
+type formatClauseJoinOptions struct {
+  PrintWidth *int    `json:"printWidth"`
+  TabWidth   *int    `json:"tabWidth"`
+  UseTabs    *bool   `json:"useTabs"`
+  EndOfLine  *string `json:"endOfLine"`
+}
+
+func (formatClauseJoin) Name() string   { return "format/clause-join" }
+func (formatClauseJoin) IsFormat() bool { return true }
+
+func (formatClauseJoin) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindIfStatement,
+    shimast.KindWhileStatement,
+    shimast.KindForStatement,
+    shimast.KindForInStatement,
+    shimast.KindForOfStatement,
+  }
+}
+
+func (formatClauseJoin) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.File == nil || node == nil {
+    return
+  }
+  var opts formatClauseJoinOptions
+  _ = ctx.DecodeOptions(&opts)
+  printWidth := 80
+  if opts.PrintWidth != nil && *opts.PrintWidth > 0 {
+    printWidth = *opts.PrintWidth
+  }
+  tabWidth := 2
+  if opts.TabWidth != nil && *opts.TabWidth > 0 {
+    tabWidth = *opts.TabWidth
+  }
+  joinClauseBody(ctx, ctx.File.Text(), node, clauseControlledBody(node), 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 {
+  switch node.Kind {
+  case shimast.KindIfStatement:
+    return node.AsIfStatement().ThenStatement
+  case shimast.KindWhileStatement:
+    return node.AsWhileStatement().Statement
+  case shimast.KindForStatement:
+    return node.AsForStatement().Statement
+  case shimast.KindForInStatement, shimast.KindForOfStatement:
+    return node.AsForInOrOfStatement().Statement
+  }
+  return nil
+}
+
+func joinClauseBody(
+  ctx *Context,
+  src string,
+  node *shimast.Node,
+  body *shimast.Node,
+  printWidth int,
+  tabWidth int,
+) {
+  if body == nil || body.Kind == shimast.KindBlock {
+    return
+  }
+  bodyStart := shimscanner.SkipTrivia(src, body.Pos())
+  bodyEnd := body.End()
+  if bodyStart < 0 || bodyEnd < bodyStart || bodyEnd > len(src) {
+    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
+  // 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] != ')' {
+    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.
+  headerStart := shimscanner.SkipTrivia(src, node.Pos())
+  if headerStart < 0 || headerStart > gapStart {
+    return
+  }
+  headerLineStart := lineStartOffset(src, headerStart)
+  if strings.ContainsRune(src[headerLineStart:gapStart], '\n') {
+    return
+  }
+  if strings.ContainsRune(src[bodyStart:bodyEnd], '\n') {
+    return
+  }
+  joined := visualWidth(src[headerLineStart:gapStart], tabWidth) + 1 +
+    visualWidth(src[bodyStart:bodyEnd], tabWidth)
+  if joined > printWidth {
+    return
+  }
+  ctx.ReportRangeFix(
+    gapStart,
+    bodyStart,
+    "Single-statement clause body should join its header line.",
+    TextEdit{Pos: gapStart, End: bodyStart, Text: " "},
+  )
+}
+
+// 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'
+}
+
+// visualWidth returns the column width of `s`, expanding tab characters
+// to `tabWidth` columns. Non-tab bytes count as one column, which is
+// exact for the ASCII that dominates control-flow headers and the common
+// case; it can under/over-count multi-byte runes, but clause bodies that
+// land exactly on the printWidth boundary are rare enough that the
+// approximation never changes a real join decision.
+func visualWidth(s string, tabWidth int) int {
+  width := 0
+  for _, r := range s {
+    if r == '\t' {
+      width += tabWidth
+      continue
+    }
+    width += runeWidth(r)
+  }
+  return width
+}
+
+func init() {
+  Register(formatClauseJoin{})
+}