@ttsc/lint 0.13.1 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_prefer_single_call.go

@@ -0,0 +1,96 @@
+// unicorn/prefer-single-call: `xs.push(1); xs.push(2);` repeats the
+// `xs.push` lookup and the call dispatch for what is conceptually one
+// "append these values" operation. Variadic methods like `push`,
+// `unshift`, `addEventListener`, and `removeEventListener` accept
+// multiple arguments specifically so authors can collapse the back-to-
+// back form into a single call.
+//
+// AST-only: visit each `Block` AND `SourceFile`, scan the statement
+// list for any pair of consecutive `ExpressionStatement`s whose
+// expressions are `CallExpression`s targeting
+// `PropertyAccess(<sameReceiverText>, <sameMethod>)` where the method
+// is one of the variadic appenders. Receiver equivalence is decided
+// by source-text comparison so chained receivers (e.g. `obj.list.push`)
+// line up exactly. Report on the second statement so the diagnostic
+// anchors to the redundant call.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-single-call.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSingleCall struct{}
+
+func (unicornPreferSingleCall) Name() string { return "unicorn/prefer-single-call" }
+func (unicornPreferSingleCall) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBlock, shimast.KindSourceFile}
+}
+func (unicornPreferSingleCall) Check(ctx *Context, node *shimast.Node) {
+  var stmts []*shimast.Node
+  switch node.Kind {
+  case shimast.KindBlock:
+    block := node.AsBlock()
+    if block == nil || block.Statements == nil {
+      return
+    }
+    stmts = block.Statements.Nodes
+  case shimast.KindSourceFile:
+    file := node.AsSourceFile()
+    if file == nil || file.Statements == nil {
+      return
+    }
+    stmts = file.Statements.Nodes
+  default:
+    return
+  }
+  for i := 1; i < len(stmts); i++ {
+    prevReceiver, prevMethod := unicornPreferSingleCallExtract(ctx, stmts[i-1])
+    if prevReceiver == "" {
+      continue
+    }
+    currReceiver, currMethod := unicornPreferSingleCallExtract(ctx, stmts[i])
+    if currReceiver == "" {
+      continue
+    }
+    if prevReceiver != currReceiver || prevMethod != currMethod {
+      continue
+    }
+    ctx.Report(stmts[i], "Combine consecutive `"+currMethod+"` calls with multiple arguments into a single call.")
+  }
+}
+
+// unicornPreferSingleCallExtract returns (receiverText, methodName) for a
+// statement of the shape `<receiver>.<method>(…);` where `method` is one
+// of the variadic appenders the rule targets. Returns ("", "") for any
+// other shape.
+func unicornPreferSingleCallExtract(ctx *Context, stmt *shimast.Node) (string, string) {
+  if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+    return "", ""
+  }
+  exprStmt := stmt.AsExpressionStatement()
+  if exprStmt == nil || exprStmt.Expression == nil {
+    return "", ""
+  }
+  call := stripParens(exprStmt.Expression)
+  if call == nil || call.Kind != shimast.KindCallExpression {
+    return "", ""
+  }
+  c := call.AsCallExpression()
+  if c == nil || c.Expression == nil || c.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return "", ""
+  }
+  access := c.Expression.AsPropertyAccessExpression()
+  if access == nil || access.Expression == nil {
+    return "", ""
+  }
+  method := identifierText(access.Name())
+  switch method {
+  case "push", "unshift", "addEventListener", "removeEventListener":
+  default:
+    return "", ""
+  }
+  return nodeText(ctx.File, access.Expression), method
+}
+
+func init() {
+  Register(unicornPreferSingleCall{})
+}

package/linthost/rules_unicorn_prefer_spread.go

@@ -0,0 +1,51 @@
+// unicorn/prefer-spread: `Array.from(x)` with a single iterable argument
+// is equivalent to a spread copy `[...x]`. The spread form is shorter,
+// reads as a value-level operation rather than a constructor call, and
+// removes the `Array` global from the read path entirely.
+//
+// AST-only: visit each `CallExpression`, match `Array.from(x)` — a
+// callee that is a property access reading `from` on a bare identifier
+// `Array`, with exactly one argument. The single-argument restriction
+// is load-bearing: `Array.from(x, mapFn)` and `Array.from(x, mapFn,
+// thisArg)` have observable behavior the spread does not (the mapper
+// receives the index, and `thisArg` is bound on a non-arrow mapper), so
+// the rule deliberately stays away from them.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-spread.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSpread struct{}
+
+func (unicornPreferSpread) Name() string { return "unicorn/prefer-spread" }
+func (unicornPreferSpread) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferSpread) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "from" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if identifierText(receiver) != "Array" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  ctx.Report(node, "Prefer spread `[...x]` over `Array.from(x)` for single-arg shallow copies.")
+}
+
+func init() {
+  Register(unicornPreferSpread{})
+}

package/linthost/rules_unicorn_prefer_string_raw.go

@@ -0,0 +1,43 @@
+// unicorn/prefer-string-raw: a string literal whose source contains
+// `\\` (an escaped backslash) is using the escape syntax to represent a
+// literal backslash. The same value, written through `String.raw` as
+// a template literal, drops every backslash escape and reads as the
+// literal text the author meant — particularly noticeable for Windows
+// paths, regex source strings, and TeX-shaped snippets.
+//
+// AST-only: visit `KindStringLiteral` and
+// `KindNoSubstitutionTemplateLiteral`. The match keys on the raw source
+// bytes of the literal node — `nodeText` returns the as-written source
+// — and fires when those bytes contain the two-character sequence `\\`,
+// i.e. an escaped backslash that `String.raw` would render literally.
+// Untagged template literals with substitutions are out of scope; this
+// rule only addresses the "single literal of fixed text" case.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-raw.md
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornPreferStringRaw struct{}
+
+func (unicornPreferStringRaw) Name() string { return "unicorn/prefer-string-raw" }
+func (unicornPreferStringRaw) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+}
+func (unicornPreferStringRaw) Check(ctx *Context, node *shimast.Node) {
+  raw := nodeText(ctx.File, node)
+  if raw == "" {
+    return
+  }
+  if !strings.Contains(raw, `\\`) {
+    return
+  }
+  ctx.Report(node, "Prefer `String.raw` for strings with backslash escapes.")
+}
+
+func init() {
+  Register(unicornPreferStringRaw{})
+}

package/linthost/rules_unicorn_prefer_string_replace_all.go

@@ -0,0 +1,95 @@
+// unicorn/prefer-string-replace-all: `"abc".replace(/a/g, "x")` is the
+// pre-ES2021 idiom for "replace every occurrence". ES2021's
+// `String#replaceAll` does the same thing without the regex flag
+// detour. The rule fires on `.replace(/<pattern>/g, replacement)` so
+// authors switch to the explicit method.
+//
+// AST-only: a `CallExpression` whose callee is `.replace` AND whose
+// first argument is a `RegularExpressionLiteral` carrying the `g` flag
+// in its trailing flag block matches. The flag is read from the raw
+// source text — the AST does not split pattern from flags — using the
+// shared `nodeText` accessor.
+//
+// To preserve semantics, the pattern body must also be literal — any
+// regex metacharacter (`\`, `.`, `*`, `+`, `?`, `[`, `]`, `(`, `)`,
+// `{`, `}`, `|`, `^`, `$`) disqualifies the rewrite, because
+// `/<pat>/g` and `.replaceAll(<pat>, ...)` mean different things when
+// the pattern is anything but a fixed string.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-replace-all.md
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornPreferStringReplaceAll struct{}
+
+func (unicornPreferStringReplaceAll) Name() string { return "unicorn/prefer-string-replace-all" }
+func (unicornPreferStringReplaceAll) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferStringReplaceAll) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "replace" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 1 {
+    return
+  }
+  first := stripParens(call.Arguments.Nodes[0])
+  if first == nil || first.Kind != shimast.KindRegularExpressionLiteral {
+    return
+  }
+  raw := nodeText(ctx.File, first)
+  if !unicornPreferStringReplaceAllHasGlobalFlag(raw) {
+    return
+  }
+  if !unicornPreferStringReplaceAllIsLiteralPattern(raw) {
+    return
+  }
+  ctx.Report(node, "Prefer `String#replaceAll(literal, replacement)` over `replace(/literal/g, replacement)`.")
+}
+
+// unicornPreferStringReplaceAllHasGlobalFlag returns true when `raw` (the
+// source text of a RegularExpressionLiteral, including the surrounding
+// `/` delimiters and trailing flag block) carries the `g` flag.
+func unicornPreferStringReplaceAllHasGlobalFlag(raw string) bool {
+  if len(raw) < 3 || raw[0] != '/' {
+    return false
+  }
+  closing := strings.LastIndexByte(raw, '/')
+  if closing <= 0 {
+    return false
+  }
+  flags := raw[closing+1:]
+  return strings.ContainsRune(flags, 'g')
+}
+
+// unicornPreferStringReplaceAllIsLiteralPattern returns true when the
+// pattern body of `raw` (the source text of a RegularExpressionLiteral)
+// contains no regex metacharacters. Conservative: any metachar — even
+// an escaped one like `\.` — disqualifies the rewrite, because
+// recovering the original character cleanly from raw source requires
+// regex-aware parsing we don't do here.
+func unicornPreferStringReplaceAllIsLiteralPattern(raw string) bool {
+  if len(raw) < 3 || raw[0] != '/' {
+    return false
+  }
+  closing := strings.LastIndexByte(raw, '/')
+  if closing <= 0 {
+    return false
+  }
+  body := raw[1:closing]
+  return !strings.ContainsAny(body, `\.*+?[](){}|^$`)
+}
+
+func init() {
+  Register(unicornPreferStringReplaceAll{})
+}

package/linthost/rules_unicorn_prefer_string_slice.go

@@ -0,0 +1,43 @@
+// unicorn/prefer-string-slice: `String#substr` is deprecated and
+// `String#substring` has surprising "swap arguments when end < start"
+// semantics. `String#slice` is the single modern alternative whose
+// behavior matches author intent. The rule fires on any `.substr(…)`
+// or `.substring(…)` callsite so the codebase converges on `.slice`.
+//
+// AST-only: a `CallExpression` whose callee is a
+// `PropertyAccessExpression` ending in `substr` or `substring`
+// matches. Receiver typing is intentionally not checked — both names
+// exist almost exclusively on strings in real code, and the
+// upstream rule treats them as banned regardless.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-slice.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferStringSlice struct{}
+
+func (unicornPreferStringSlice) Name() string { return "unicorn/prefer-string-slice" }
+func (unicornPreferStringSlice) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferStringSlice) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "substr", "substring":
+  default:
+    return
+  }
+  ctx.Report(node, "Prefer `String#slice()` over `substr` / `substring`.")
+}
+
+func init() {
+  Register(unicornPreferStringSlice{})
+}

package/linthost/rules_unicorn_prefer_string_starts_ends_with.go

@@ -0,0 +1,148 @@
+// unicorn/prefer-string-starts-ends-with: `s.slice(0, 4) === "http"` and
+// `s.slice(-3) === "abc"` are the legacy spellings of `s.startsWith(...)`
+// and `s.endsWith(...)`. The String methods are clearer about intent, do
+// not allocate the intermediate substring, and have been available for
+// over a decade.
+//
+// AST-only: visit each `BinaryExpression` whose operator is `===` or
+// `!==`. One operand must be a `CallExpression` of the shape
+// `_.slice(0, N)` or `_.slice(-N)` (the `-N` form being a unary minus
+// over a numeric literal) and the other operand must be a string literal
+// whose text length matches N. Reports on the binary expression.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-starts-ends-with.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferStringStartsEndsWith struct{}
+
+func (unicornPreferStringStartsEndsWith) Name() string {
+  return "unicorn/prefer-string-starts-ends-with"
+}
+func (unicornPreferStringStartsEndsWith) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornPreferStringStartsEndsWith) Check(ctx *Context, node *shimast.Node) {
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken:
+  default:
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if unicornPreferStringStartsEndsWithMatches(left, right) ||
+    unicornPreferStringStartsEndsWithMatches(right, left) {
+    ctx.Report(node, "Prefer `String#startsWith()` / `String#endsWith()` over slice-and-compare.")
+  }
+}
+
+// unicornPreferStringStartsEndsWithMatches reports whether `callSide` is
+// the slice call and `literalSide` is a matching string literal.
+func unicornPreferStringStartsEndsWithMatches(callSide, literalSide *shimast.Node) bool {
+  if callSide == nil || literalSide == nil {
+    return false
+  }
+  if callSide.Kind != shimast.KindCallExpression {
+    return false
+  }
+  if literalSide.Kind != shimast.KindStringLiteral &&
+    literalSide.Kind != shimast.KindNoSubstitutionTemplateLiteral {
+    return false
+  }
+  call := callSide.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "slice" {
+    return false
+  }
+  if call.Arguments == nil {
+    return false
+  }
+  args := call.Arguments.Nodes
+  wantLen := -1
+  switch len(args) {
+  case 2:
+    first := stripParens(args[0])
+    second := stripParens(args[1])
+    if first == nil || first.Kind != shimast.KindNumericLiteral ||
+      numericLiteralText(first) != "0" {
+      return false
+    }
+    if second == nil || second.Kind != shimast.KindNumericLiteral {
+      return false
+    }
+    if !unicornPreferStringStartsEndsWithDigits(numericLiteralText(second)) {
+      return false
+    }
+    wantLen = unicornPreferStringStartsEndsWithToInt(numericLiteralText(second))
+  case 1:
+    // `.slice(-N)` — a unary minus over a positive numeric literal.
+    only := stripParens(args[0])
+    if only == nil || only.Kind != shimast.KindPrefixUnaryExpression {
+      return false
+    }
+    prefix := only.AsPrefixUnaryExpression()
+    if prefix == nil || prefix.Operator != shimast.KindMinusToken ||
+      prefix.Operand == nil ||
+      prefix.Operand.Kind != shimast.KindNumericLiteral {
+      return false
+    }
+    text := numericLiteralText(prefix.Operand)
+    if !unicornPreferStringStartsEndsWithDigits(text) {
+      return false
+    }
+    wantLen = unicornPreferStringStartsEndsWithToInt(text)
+  default:
+    return false
+  }
+  if wantLen <= 0 {
+    return false
+  }
+  return len(stringLiteralText(literalSide)) == wantLen
+}
+
+// unicornPreferStringStartsEndsWithDigits reports whether `text` is a
+// non-empty ASCII decimal-integer literal. Decimals, hex, and `e`-notation
+// are rejected since the rule only handles fixed-length prefixes.
+func unicornPreferStringStartsEndsWithDigits(text string) bool {
+  if text == "" {
+    return false
+  }
+  for i := 0; i < len(text); i++ {
+    c := text[i]
+    if c < '0' || c > '9' {
+      return false
+    }
+  }
+  return true
+}
+
+// unicornPreferStringStartsEndsWithToInt parses an ASCII decimal-integer
+// literal into an int. Callers must have validated the input first; this
+// helper returns -1 only as a defensive fallback for an overflow guard.
+func unicornPreferStringStartsEndsWithToInt(text string) int {
+  n := 0
+  for i := 0; i < len(text); i++ {
+    c := text[i]
+    if c < '0' || c > '9' {
+      return -1
+    }
+    n = n*10 + int(c-'0')
+    if n > 1<<30 {
+      return -1
+    }
+  }
+  return n
+}
+
+func init() {
+  Register(unicornPreferStringStartsEndsWith{})
+}

package/linthost/rules_unicorn_prefer_string_trim_start_end.go

@@ -0,0 +1,48 @@
+// unicorn/prefer-string-trim-start-end: `String#trimLeft` and
+// `String#trimRight` are the deprecated names for what
+// `String#trimStart` / `String#trimEnd` express directly. The deprecated
+// names are still callable but should be replaced for consistency with
+// the modern naming. The rule fires on zero-argument calls to either
+// deprecated method.
+//
+// AST-only: a `CallExpression` whose callee is `.trimLeft` or
+// `.trimRight` and whose argument list is empty matches. Arguments are
+// theoretically not allowed on either method, but the AST does not
+// know that — the rule defends against the syntactic shape only.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-trim-start-end.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferStringTrimStartEnd struct{}
+
+func (unicornPreferStringTrimStartEnd) Name() string {
+  return "unicorn/prefer-string-trim-start-end"
+}
+func (unicornPreferStringTrimStartEnd) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferStringTrimStartEnd) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "trimLeft", "trimRight":
+  default:
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    return
+  }
+  ctx.Report(node, "Prefer `String#trimStart` / `String#trimEnd` over the deprecated `trimLeft` / `trimRight`.")
+}
+
+func init() {
+  Register(unicornPreferStringTrimStartEnd{})
+}

package/linthost/rules_unicorn_prefer_structured_clone.go

@@ -0,0 +1,71 @@
+// unicorn/prefer-structured-clone: `JSON.parse(JSON.stringify(x))` is
+// the historical deep-clone idiom. It silently drops everything JSON
+// cannot round-trip — `Date`, `Map`, `Set`, typed arrays, cyclic
+// references — and re-allocates a large intermediate string. The
+// platform-native `structuredClone(x)` handles every transferable type,
+// supports cycles, and avoids the string round-trip entirely.
+//
+// AST-only: visit each `CallExpression`, match `JSON.parse(arg)` whose
+// single `arg` is itself a `JSON.stringify(...)` call. Both gates lock
+// the receiver to the bare `JSON` identifier so member-access chains
+// reading `parse`/`stringify` on a renamed alias do not trip the rule.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-structured-clone.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferStructuredClone struct{}
+
+func (unicornPreferStructuredClone) Name() string {
+  return "unicorn/prefer-structured-clone"
+}
+func (unicornPreferStructuredClone) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferStructuredClone) Check(ctx *Context, node *shimast.Node) {
+  if !isJSONMethodCall(node, "parse") {
+    return
+  }
+  outer := node.AsCallExpression()
+  if outer == nil || outer.Arguments == nil || len(outer.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(outer.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindCallExpression {
+    return
+  }
+  if !isJSONMethodCall(arg, "stringify") {
+    return
+  }
+  ctx.Report(node, "Prefer `structuredClone(x)` over `JSON.parse(JSON.stringify(x))`.")
+}
+
+// isJSONMethodCall reports whether `node` is a CallExpression whose
+// callee is `JSON.<method>` — a property access reading `method` on a
+// bare `JSON` identifier. The bare-identifier gate keeps the rule from
+// firing on `aliased.parse(...)` shapes that happen to share the
+// method name.
+func isJSONMethodCall(node *shimast.Node, method string) bool {
+  if node == nil || node.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return false
+  }
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return false
+  }
+  if identifierText(access.Name()) != method {
+    return false
+  }
+  return identifierText(stripParens(access.Expression)) == "JSON"
+}
+
+func init() {
+  Register(unicornPreferStructuredClone{})
+}