@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_default_case.go

@@ -0,0 +1,39 @@
+// defaultCase: a `switch` statement that omits the `default` clause
+// silently drops every discriminant value not matched by an explicit
+// `case` label. The rule wants the catch-all path written out so an
+// unhandled discriminant becomes an intentional branch — even if that
+// branch is a `// no default` comment marker.
+//
+// AST-only: each visited `SwitchStatement` checks its `CaseBlock`
+// clauses for any node of kind `DefaultClause`. The rule reports on the
+// switch keyword itself rather than the case block so the diagnostic
+// lands at the head of the statement.
+// https://eslint.org/docs/latest/rules/default-case
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+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.")
+}
+
+func init() {
+  Register(defaultCase{})
+}

package/linthost/rules_default_case_last.go

@@ -0,0 +1,46 @@
+// defaultCaseLast: a `switch` statement whose `default` clause is not
+// the final clause changes fall-through semantics in a way that almost
+// never matches the author's intent — running `default` then falling
+// into `case "b"` is rarely what a misordered switch wants. The rule
+// requires `default` to appear after every `case` label.
+//
+// AST-only: each visited `SwitchStatement` walks its `CaseBlock`
+// clauses, and any `DefaultClause` that is not the last element is
+// reported on the clause itself.
+// https://eslint.org/docs/latest/rules/default-case-last
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type defaultCaseLast struct{}
+
+func (defaultCaseLast) Name() string { return "default-case-last" }
+func (defaultCaseLast) Visits() []shimast.Kind {
+  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.")
+    }
+  }
+}
+
+func init() {
+  Register(defaultCaseLast{})
+}

package/linthost/rules_dupes.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-duplicate-case: duplicated `case` labels in a single switch.
+// noDuplicateCase: duplicated `case` labels in a single switch.
 // https://eslint.org/docs/latest/rules/no-duplicate-case
 type noDuplicateCase struct{}
 
@@ -38,7 +38,7 @@ func (noDuplicateCase) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-dupe-keys: duplicated property names in a single object literal.
+// noDupeKeys: duplicated property names in a single object literal.
 // https://eslint.org/docs/latest/rules/no-dupe-keys
 type noDupeKeys struct{}
 
@@ -63,7 +63,7 @@ func (noDupeKeys) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-dupe-args: duplicated parameter names in a single function head.
+// noDupeArgs: duplicated parameter names in a single function head.
 // https://eslint.org/docs/latest/rules/no-dupe-args
 type noDupeArgs struct{}
 

package/linthost/rules_empty.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-empty: empty block statements (`{}`), but allow empty catch
+// noEmpty: empty block statements (`{}`), but allow empty catch
 // clauses since they're idiomatic for "ignore the error".
 // https://eslint.org/docs/latest/rules/no-empty
 type noEmpty struct{}
@@ -27,7 +27,7 @@ func (noEmpty) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Empty block statement.")
 }
 
-// no-empty-function: empty function / method / arrow / accessor bodies.
+// noEmptyFunction: empty function / method / arrow / accessor bodies.
 // https://eslint.org/docs/latest/rules/no-empty-function
 type noEmptyFunction struct{}
 
@@ -60,7 +60,7 @@ func (noEmptyFunction) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-empty-pattern: `({}) => x` or `function ({}) {}` — destructuring
+// noEmptyPattern: `({}) => x` or `function ({}) {}` — destructuring
 // patterns with no bindings are usually a bug.
 // https://eslint.org/docs/latest/rules/no-empty-pattern
 type noEmptyPattern struct{}

package/linthost/rules_escape.go

@@ -6,7 +6,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-// no-useless-escape: flag backslashes that escape characters which do not
+// noUselessEscape: flag backslashes that escape characters which do not
 // require escaping. Inside string/template literals the meaningful
 // escapes are limited to a fixed set; everywhere else the backslash is
 // noise from a copy/paste accident or a confused author. ESLint
@@ -41,13 +41,16 @@ func (noUselessEscape) Check(ctx *Context, node *shimast.Node) {
   if isInsideTaggedTemplate(node) {
     return
   }
-  src := ctx.File.Text()
-  pos := node.Pos()
-  end := node.End()
-  if pos < 0 || end > len(src) || pos >= end {
+  // tsgo's `node.Pos()` points at the start of leading trivia; the regex
+  // scanner relies on `raw[0] == '/'`, so we have to anchor on the
+  // post-trivia token start. String/template scans tolerate leading
+  // trivia bytes by accident, but using `tokenRange` for every branch
+  // keeps reported offsets aligned with the actual literal.
+  pos, end := tokenRange(ctx.File, node)
+  if pos < 0 || pos >= end {
     return
   }
-  raw := src[pos:end]
+  raw := ctx.File.Text()[pos:end]
   // Determine quote/scan delimiters based on node kind so the
   // single-char escape whitelist matches ESLint per-context.
   switch node.Kind {
@@ -66,12 +69,18 @@ func (noUselessEscape) Check(ctx *Context, node *shimast.Node) {
 const stringValidEscapes = "'\"\\bfnrtv0xuU\n\r"
 const templateValidEscapes = "`'\"\\bfnrtv0xuU$\n\r"
 
-// regexValidEscapes covers characters that are *always* meaningful when
-// preceded by `\` in a regex pattern. Character classes and group syntax
-// inside a regex add more legitimate escapes (`\d`, `\w`, …); we handle
-// those by allowing every ASCII letter (which makes the fix conservative
-// — it never deletes a backslash whose meaning could be context-sensitive).
-const regexValidEscapes = "^$\\.*+?()[]{}|/-\n\r"
+// regexNonClassValidEscapes covers characters that are meaningful when
+// preceded by `\` outside a character class — every regex meta-char plus
+// the line terminators. Inside a `[...]` most of these characters lose
+// their special meaning (`.`, `*`, `+`, `?`, `(`, `)`, `{`, `}`, `|`, `$`,
+// `/` are all literal in a class), so the in-class allowlist is narrower:
+// backslash, the class-delimiting `]`, the range operator `-`, and `^`
+// (which would otherwise turn the class into a negation if the escape
+// were stripped). Standard shorthand escapes (`\d`, `\w`, …) and the
+// Unicode/hex/control escapes are handled separately in
+// `isUselessRegexEscape` and apply in both contexts.
+const regexNonClassValidEscapes = "^$\\.*+?()[]{}|/-\n\r"
+const regexClassValidEscapes = "\\]-^\n\r"
 
 // reportStringEscapes walks the raw source bytes of a string or template
 // literal and reports each backslash whose following character is not in
@@ -212,29 +221,40 @@ func isUselessStringEscape(ch byte, whitelist string) bool {
 
 // isUselessRegexEscape reports whether a backslash before `ch` is redundant
 // in a regex pattern. `inClass` is true when the escape occurs inside a `[…]`
-// character class, which widens the set of meaningful escapes.
+// character class, which narrows the set of meaningful meta-char escapes:
+// most regex meta-chars (`.`, `*`, `+`, `?`, `(`, `)`, `{`, `}`, `|`, `^`,
+// `$`, `/`) are literal inside a class, so escaping them there is noise.
 func isUselessRegexEscape(ch byte, inClass bool) bool {
   if ch < 0x20 {
     return false
   }
-  // Regex meta-chars and their friends.
-  if strings.IndexByte(regexValidEscapes, ch) >= 0 {
-    return false
-  }
-  // Inside a character class `]`, `\`, and `-` are still meaningful
-  // beyond the always-list; everything else stays useless.
   if inClass {
-    switch ch {
-    case ']', '\\', '-', 'b':
+    if strings.IndexByte(regexClassValidEscapes, ch) >= 0 {
       return false
     }
+  } else if strings.IndexByte(regexNonClassValidEscapes, ch) >= 0 {
+    return false
   }
-  // Common regex shorthand: \d \D \w \W \s \S \b \B \f \n \r \t \v \0
+  // Common regex shorthand: \d \D \w \W \s \S \b \f \n \r \t \v \0 \x \u \c \p \P,
+  // plus decimal back-references \1..\9. `\B` (non-word-boundary) and `\k<name>`
+  // (named backref) are only meaningful outside a character class; `\q{...}` is
+  // a v-flag string-disjunction escape that is also class-only-meaningful.
   switch ch {
-  case 'd', 'D', 'w', 'W', 's', 'S', 'b', 'B', 'f', 'n', 'r', 't', 'v', '0',
-    'x', 'u', 'c', 'p', 'P', 'k', 'q':
+  case 'd', 'D', 'w', 'W', 's', 'S', 'b', 'f', 'n', 'r', 't', 'v', '0',
+    'x', 'u', 'c', 'p', 'P',
+    '1', '2', '3', '4', '5', '6', '7', '8', '9':
     return false
   }
+  if !inClass {
+    switch ch {
+    case 'B', 'k':
+      return false
+    }
+  } else {
+    if ch == 'q' {
+      return false
+    }
+  }
   return true
 }
 

package/linthost/rules_eval.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-eval: forbid `eval(...)` calls. Members of nested namespaces (e.g.
+// noEval: forbid `eval(...)` calls. Members of nested namespaces (e.g.
 // `globalThis.eval(...)`) are not flagged here — that's
 // `no-implied-eval`, which we don't ship in v0.
 // https://eslint.org/docs/latest/rules/no-eval
@@ -20,7 +20,7 @@ func (noEval) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-script-url: forbid `"javascript:..."` literals. Often used to inject
+// noScriptUrl: forbid `"javascript:..."` literals. Often used to inject
 // inline JS via DOM `href`/`src`; legacy and dangerous.
 // https://eslint.org/docs/latest/rules/no-script-url
 type noScriptURL struct{}

package/linthost/rules_finally.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-unsafe-finally: `return` / `break` / `continue` / `throw` inside a
+// noUnsafeFinally: `return` / `break` / `continue` / `throw` inside a
 // `finally` clause silently overrides the in-flight exception or value.
 // https://eslint.org/docs/latest/rules/no-unsafe-finally
 type noUnsafeFinally struct{}
@@ -83,7 +83,7 @@ func keywordOfControl(node *shimast.Node) string {
   return "control flow"
 }
 
-// no-useless-catch: `catch (err) { throw err; }` adds no behavior.
+// noUselessCatch: `catch (err) { throw err; }` adds no behavior.
 // https://eslint.org/docs/latest/rules/no-useless-catch
 type noUselessCatch struct{}
 

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{})
+}