@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

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,213 @@
+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
+  }
+
+  // A comment in the parameter region (leading trivia, or between the name and
+  // its `)`/`=>`) defeats the whitespace-only paren scan below: the scan stops
+  // at the comment byte and reports "not wrapped", so the "always" branch would
+  // wrap an already-parenthesized name a second time and emit invalid
+  // `(/* c */ (x)) => x`. Prettier leaves such an arrow alone
+  // (canPrintParamsWithoutParens requires `!hasComment(parameters[0])`), so
+  // abstain rather than corrupt.
+  if arrowParamRegionHasComment(src, param.Pos(), nameStart, nameEnd) {
+    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
+}
+
+// arrowParamRegionHasComment reports whether a `//` or `/*` comment sits in the
+// single parameter's region — its leading trivia (`[paramPos, nameStart)`) or
+// the trailing trivia after the name up to the first real token (`)` or `=>`).
+// The byte scan is safe here because a bare-identifier parameter region holds
+// only comments, whitespace, the identifier, and parentheses (no strings:
+// typed/defaulted params are already excluded by isBareIdentifierParam).
+func arrowParamRegionHasComment(src string, paramPos, nameStart, nameEnd int) bool {
+  for i := paramPos; i+1 < nameStart && i+1 < len(src); i++ {
+    if src[i] == '/' && (src[i+1] == '*' || src[i+1] == '/') {
+      return true
+    }
+  }
+  // Trailing trivia after the identifier, up to `=>`. Tolerate one closing
+  // paren so a comment between `)` and `=>` (`(x) /* c */ => x`) — which in
+  // "avoid" mode would otherwise be stranded when the parens are stripped — is
+  // also detected (Prettier keeps the parens of an arrow with such a dangling
+  // comment).
+  sawParen := false
+  for i := nameEnd; i+1 < len(src); i++ {
+    c := src[i]
+    if c == ' ' || c == '\t' || c == '\r' || c == '\n' {
+      continue
+    }
+    if c == '/' && (src[i+1] == '*' || src[i+1] == '/') {
+      return true
+    }
+    if c == ')' && !sawParen {
+      sawParen = true
+      continue
+    }
+    break
+  }
+  return false
+}
+
+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{})
+}