@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_numeric_separators_style.go

@@ -0,0 +1,75 @@
+// unicorn/numeric-separators-style: ES2021 numeric separators (`_`)
+// only help readability when the grouping itself is conventional —
+// thousands for decimal (`1_000_000`) and four-digit groups for hex /
+// binary / octal (`0xFFFF_FFFF`). Off-by-one groupings (`1_2345`) read
+// worse than the unseparated form. The rule fires when any literal
+// already uses `_` but its groups don't match the canonical pattern.
+//
+// AST-only: visit `KindNumericLiteral`, read the raw source via
+// `nodeText` so the underscores survive parser normalization, pick the
+// canonical group size from the prefix (`0x`/`0X` → 4, `0b`/`0B` → 4,
+// `0o`/`0O` → 4, anything else → 3), and reject any literal that
+// contains an underscore but whose integer portion fails the
+// canonical-grouping regex.
+//
+// Conservative MVP: only the integer portion is checked. Floats and
+// scientific notation that contain `_` follow the decimal grouping
+// rule applied to the leading integer digits.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/numeric-separators-style.md
+package linthost
+
+import (
+  "regexp"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+var (
+  unicornNumericSeparatorsDecimal = regexp.MustCompile(`^[0-9]{1,3}(_[0-9]{3})*$`)
+  unicornNumericSeparatorsRadix4  = regexp.MustCompile(`^[0-9A-Fa-f]{1,4}(_[0-9A-Fa-f]{4})*$`)
+)
+
+type unicornNumericSeparatorsStyle struct{}
+
+func (unicornNumericSeparatorsStyle) Name() string { return "unicorn/numeric-separators-style" }
+func (unicornNumericSeparatorsStyle) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNumericLiteral, shimast.KindBigIntLiteral}
+}
+func (unicornNumericSeparatorsStyle) Check(ctx *Context, node *shimast.Node) {
+  source := strings.TrimSpace(nodeText(ctx.File, node))
+  if source == "" || !strings.Contains(source, "_") {
+    return
+  }
+  // Strip a trailing BigInt `n` so the digit-grouping regex doesn't see it.
+  source = strings.TrimSuffix(source, "n")
+
+  // Pick the integer portion and the canonical grouping pattern based
+  // on prefix; floats fall through to the decimal rule applied to the
+  // leading integer digits before the `.` or `e`/`E`.
+  integer := source
+  pattern := unicornNumericSeparatorsDecimal
+  if len(source) >= 2 && source[0] == '0' {
+    switch source[1] {
+    case 'x', 'X', 'b', 'B', 'o', 'O':
+      integer = source[2:]
+      pattern = unicornNumericSeparatorsRadix4
+    }
+  }
+  if pattern == unicornNumericSeparatorsDecimal {
+    if dot := strings.IndexAny(integer, ".eE"); dot >= 0 {
+      integer = integer[:dot]
+    }
+  }
+  if !strings.Contains(integer, "_") {
+    return
+  }
+  if !pattern.MatchString(integer) {
+    ctx.Report(node, "Use canonical separator grouping for numeric literals (3 digits for decimal, 4 for hex).")
+  }
+}
+
+func init() {
+  Register(unicornNumericSeparatorsStyle{})
+}

package/linthost/rules_unicorn_prefer_add_event_listener.go

@@ -0,0 +1,66 @@
+// unicorn/prefer-add-event-listener: assigning a function to an
+// `on*` DOM property (`el.onclick = …`) installs at most one handler
+// — any prior assignment is silently overwritten. `addEventListener`
+// composes: every listener that registers receives the event, and
+// `removeEventListener` revokes exactly the listener that was added.
+// The property-assignment form is therefore a fragile shape that the
+// rule encourages replacing with the explicit listener API.
+//
+// AST-only: visit each `BinaryExpression`, restrict to `=` assignments
+// whose LHS is a property access, and match property names that start
+// with `on` followed by at least one lowercase letter (so unrelated
+// names like `onnxruntime` or `onClickHandler` don't fire). The
+// assignment node itself is reported so the diagnostic underlines the
+// statement the reader needs to rewrite.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-add-event-listener.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferAddEventListener struct{}
+
+func (unicornPreferAddEventListener) Name() string { return "unicorn/prefer-add-event-listener" }
+func (unicornPreferAddEventListener) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornPreferAddEventListener) Check(ctx *Context, node *shimast.Node) {
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil {
+    return
+  }
+  if bin.OperatorToken.Kind != shimast.KindEqualsToken {
+    return
+  }
+  lhs := stripParens(bin.Left)
+  if lhs == nil || lhs.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := lhs.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  name := identifierText(access.Name())
+  if !isUnicornOnEventName(name) {
+    return
+  }
+  ctx.Report(node, "Prefer `addEventListener` / `removeEventListener` over assigning to `on*` properties.")
+}
+
+// isUnicornOnEventName reports whether `name` is `on<lower>...` of at
+// least 3 characters. The third-character lowercase gate prevents
+// matches on `onClick`, `onnxruntime`, and other names that begin with
+// `on` but are not DOM event handlers.
+func isUnicornOnEventName(name string) bool {
+  if len(name) < 3 {
+    return false
+  }
+  if name[0] != 'o' || name[1] != 'n' {
+    return false
+  }
+  c := name[2]
+  return c >= 'a' && c <= 'z'
+}
+
+func init() {
+  Register(unicornPreferAddEventListener{})
+}

package/linthost/rules_unicorn_prefer_array_find.go

@@ -0,0 +1,51 @@
+// unicorn/prefer-array-find: `arr.filter(predicate)[0]` walks the full
+// array and allocates an intermediate result just to discard everything
+// after the first match. `arr.find(predicate)` returns the same value
+// without the wasted work and reads as the actual intent.
+//
+// AST-only: visit each `ElementAccessExpression`. The receiver must be a
+// `CallExpression` whose callee is a `PropertyAccess(_, filter)` and the
+// index argument must be the numeric literal `0`. Reports on the element
+// access so editors highlight the whole `.filter(...)[0]` chain.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-find.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferArrayFind struct{}
+
+func (unicornPreferArrayFind) Name() string { return "unicorn/prefer-array-find" }
+func (unicornPreferArrayFind) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindElementAccessExpression}
+}
+func (unicornPreferArrayFind) Check(ctx *Context, node *shimast.Node) {
+  access := node.AsElementAccessExpression()
+  if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
+    return
+  }
+  index := stripParens(access.ArgumentExpression)
+  if index == nil || index.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  if numericLiteralText(index) != "0" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := receiver.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  prop := call.Expression.AsPropertyAccessExpression()
+  if prop == nil || identifierText(prop.Name()) != "filter" {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#find()` over `Array#filter(...)[0]`.")
+}
+
+func init() {
+  Register(unicornPreferArrayFind{})
+}

package/linthost/rules_unicorn_prefer_array_flat.go

@@ -0,0 +1,52 @@
+// unicorn/prefer-array-flat: `[].concat(a, b, c)` is the legacy flatten
+// idiom — it works because `Array#concat` spreads array arguments — but
+// it loses readability the moment a non-array sneaks into the argument
+// list (it then gets pushed in as a single element instead of being
+// flattened). `Array#flat()` has stable, type-aware semantics and is the
+// supported one-line equivalent.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose receiver is an empty array-literal expression and whose method
+// identifier is `concat`, and fire when at least one argument is
+// supplied. The empty-array receiver gate is what isolates the
+// flattening idiom from ordinary `.concat()` usage on real arrays.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-flat.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferArrayFlat struct{}
+
+func (unicornPreferArrayFlat) Name() string { return "unicorn/prefer-array-flat" }
+func (unicornPreferArrayFlat) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferArrayFlat) 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
+  }
+  if identifierText(access.Name()) != "concat" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  arr := receiver.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 0 {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#flat()` over `[].concat(...arrays)`.")
+}
+
+func init() {
+  Register(unicornPreferArrayFlat{})
+}

package/linthost/rules_unicorn_prefer_array_flat_map.go

@@ -0,0 +1,63 @@
+// unicorn/prefer-array-flat-map: the pair `someArr.map(fn).flat()` walks
+// the source array twice — once to map and once to flatten — when a
+// single `flatMap` call would do both in one pass. The rule flags the
+// chained shape so authors collapse it to the built-in.
+//
+// AST-only: a `CallExpression` whose callee is `.flat` AND whose
+// receiver is itself a `CallExpression` whose callee is `.map` matches.
+// The `.flat(...)` call must be argument-less or explicitly `.flat(1)`
+// — `.map(fn).flat(2)` is NOT equivalent to `.flatMap(fn)` because the
+// latter only flattens one level. The diagnostic anchors on the outer
+// call so editors highlight the whole `.map(...).flat(...)` chain.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-flat-map.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferArrayFlatMap struct{}
+
+func (unicornPreferArrayFlatMap) Name() string { return "unicorn/prefer-array-flat-map" }
+func (unicornPreferArrayFlatMap) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferArrayFlatMap) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  outerAccess := call.Expression.AsPropertyAccessExpression()
+  if outerAccess == nil || identifierText(outerAccess.Name()) != "flat" {
+    return
+  }
+  // `.flat(2)` and deeper are NOT equivalent to `.flatMap` — only the
+  // default depth (no arg) or explicit depth 1 collapse cleanly.
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    if len(call.Arguments.Nodes) != 1 {
+      return
+    }
+    arg := stripParens(call.Arguments.Nodes[0])
+    if arg == nil || arg.Kind != shimast.KindNumericLiteral ||
+      numericLiteralText(arg) != "1" {
+      return
+    }
+  }
+  receiver := stripParens(outerAccess.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindCallExpression {
+    return
+  }
+  innerCall := receiver.AsCallExpression()
+  if innerCall == nil || innerCall.Expression == nil ||
+    innerCall.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  innerAccess := innerCall.Expression.AsPropertyAccessExpression()
+  if innerAccess == nil || identifierText(innerAccess.Name()) != "map" {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#flatMap` over `Array#map().flat()`.")
+}
+
+func init() {
+  Register(unicornPreferArrayFlatMap{})
+}

package/linthost/rules_unicorn_prefer_array_index_of.go

@@ -0,0 +1,147 @@
+// unicorn/prefer-array-index-of: `arr.findIndex(x => x === literal)` is
+// the long-hand spelling of `arr.indexOf(literal)`. Both return the
+// index of the first matching element; `indexOf` is a direct comparison
+// against a value and is faster, shorter, and clearer about intent.
+//
+// AST-only: visit each `CallExpression` whose callee is
+// `PropertyAccess(_, findIndex)`. The single argument must be a
+// function (`ArrowFunction` or `FunctionExpression`) with exactly one
+// parameter. The function body — concise body, or a block body whose
+// single statement is a `return` — must be a strict-equality comparison
+// between the parameter identifier and a literal (string, number,
+// boolean, null, bigint). Reports on the call.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-index-of.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferArrayIndexOf struct{}
+
+func (unicornPreferArrayIndexOf) Name() string { return "unicorn/prefer-array-index-of" }
+func (unicornPreferArrayIndexOf) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferArrayIndexOf) 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()) != "findIndex" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  fn := stripParens(call.Arguments.Nodes[0])
+  if fn == nil {
+    return
+  }
+  var body *shimast.Node
+  switch fn.Kind {
+  case shimast.KindArrowFunction:
+    arrow := fn.AsArrowFunction()
+    if arrow == nil {
+      return
+    }
+    body = arrow.Body
+  case shimast.KindFunctionExpression:
+    expr := fn.AsFunctionExpression()
+    if expr == nil {
+      return
+    }
+    body = expr.Body
+  default:
+    return
+  }
+  params := fn.Parameters()
+  if len(params) != 1 {
+    return
+  }
+  paramName := parameterIdentifierName(params[0])
+  if paramName == "" {
+    return
+  }
+  expr := unicornPreferArrayIndexOfBodyExpression(body)
+  if expr == nil {
+    return
+  }
+  bin := expr.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil ||
+    bin.OperatorToken.Kind != shimast.KindEqualsEqualsEqualsToken {
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if left == nil || right == nil {
+    return
+  }
+  if unicornPreferArrayIndexOfMatchesParam(left, paramName) &&
+    unicornPreferArrayIndexOfIsLiteral(right) {
+    ctx.Report(node, "Prefer `Array#indexOf()` over `Array#findIndex(x => x === literal)`.")
+    return
+  }
+  if unicornPreferArrayIndexOfMatchesParam(right, paramName) &&
+    unicornPreferArrayIndexOfIsLiteral(left) {
+    ctx.Report(node, "Prefer `Array#indexOf()` over `Array#findIndex(x => x === literal)`.")
+  }
+}
+
+// unicornPreferArrayIndexOfBodyExpression normalizes the function body to
+// the comparison expression: a concise arrow body returns its expression,
+// a block body with a single `return expr;` returns the expression.
+func unicornPreferArrayIndexOfBodyExpression(body *shimast.Node) *shimast.Node {
+  if body == nil {
+    return nil
+  }
+  if body.Kind != shimast.KindBlock {
+    expr := stripParens(body)
+    if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+      return nil
+    }
+    return expr
+  }
+  block := body.AsBlock()
+  if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+    return nil
+  }
+  stmt := block.Statements.Nodes[0]
+  if stmt == nil || stmt.Kind != shimast.KindReturnStatement {
+    return nil
+  }
+  ret := stmt.AsReturnStatement()
+  if ret == nil || ret.Expression == nil {
+    return nil
+  }
+  expr := stripParens(ret.Expression)
+  if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+    return nil
+  }
+  return expr
+}
+
+func unicornPreferArrayIndexOfMatchesParam(node *shimast.Node, name string) bool {
+  return identifierText(node) == name
+}
+
+func unicornPreferArrayIndexOfIsLiteral(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindNullKeyword,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword:
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(unicornPreferArrayIndexOf{})
+}

package/linthost/rules_unicorn_prefer_array_some.go

@@ -0,0 +1,67 @@
+// unicorn/prefer-array-some: `arr.filter(predicate).length > 0` walks the
+// whole array and allocates an intermediate filtered array just to ask
+// the boolean question "does any element match?". `arr.some(predicate)`
+// short-circuits at the first hit and reads as the intent.
+//
+// AST-only: visit each `BinaryExpression`. The operator must be one of
+// `>`, `>=`, `!==`, `!=`. The left operand must be
+// `PropertyAccess(CallExpression(_, filter), length)`. The right operand
+// must be the numeric literal `0`. Reports on the binary expression.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-some.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferArraySome struct{}
+
+func (unicornPreferArraySome) Name() string { return "unicorn/prefer-array-some" }
+func (unicornPreferArraySome) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornPreferArraySome) 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.KindGreaterThanToken,
+    shimast.KindGreaterThanEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken:
+  default:
+    return
+  }
+  right := stripParens(bin.Right)
+  if right == nil || right.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  if numericLiteralText(right) != "0" {
+    return
+  }
+  left := stripParens(bin.Left)
+  if left == nil || left.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  outer := left.AsPropertyAccessExpression()
+  if outer == nil || identifierText(outer.Name()) != "length" {
+    return
+  }
+  receiver := stripParens(outer.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := receiver.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "filter" {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#some()` over `.filter(...).length > 0`.")
+}
+
+func init() {
+  Register(unicornPreferArraySome{})
+}

package/linthost/rules_unicorn_prefer_at.go

@@ -0,0 +1,77 @@
+// unicorn/prefer-at: `arr[arr.length - 1]` is the legacy spelling of
+// "last element". ES2022 introduced `Array#at(-N)` (and `String#at(-N)`)
+// which lets you reach for the same value from the tail without
+// repeating the receiver and the subtraction. The rule pushes authors
+// toward the built-in.
+//
+// AST-only: visit each `ElementAccessExpression`. The index expression
+// must be a `BinaryExpression` whose operator is `-`, whose left side is
+// `PropertyAccess(_, length)`, and whose right side is a positive
+// numeric literal. The receiver of the `.length` access does not need
+// to match the element-access receiver textually; mismatches are
+// uncommon enough that the AST-only check stays useful in practice.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-at.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferAt struct{}
+
+func (unicornPreferAt) Name() string { return "unicorn/prefer-at" }
+func (unicornPreferAt) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindElementAccessExpression}
+}
+func (unicornPreferAt) Check(ctx *Context, node *shimast.Node) {
+  access := node.AsElementAccessExpression()
+  if access == nil || access.ArgumentExpression == nil {
+    return
+  }
+  index := stripParens(access.ArgumentExpression)
+  if index == nil || index.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  bin := index.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil ||
+    bin.OperatorToken.Kind != shimast.KindMinusToken {
+    return
+  }
+  left := stripParens(bin.Left)
+  if left == nil || left.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  prop := left.AsPropertyAccessExpression()
+  if prop == nil || identifierText(prop.Name()) != "length" {
+    return
+  }
+  right := stripParens(bin.Right)
+  if right == nil || right.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  text := numericLiteralText(right)
+  if !unicornPreferAtIsPositiveInteger(text) {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#at(-N)` / `String#at(-N)` over `arr[arr.length - N]`.")
+}
+
+// unicornPreferAtIsPositiveInteger reports whether `text` is the literal
+// form of a positive integer (>= 1). Leading zeros are accepted because
+// the JS scanner already normalized them; the only rejections are the
+// empty string, plain `0`, and anything containing a non-digit (decimals,
+// `e`-notation, hex, bigint suffix).
+func unicornPreferAtIsPositiveInteger(text string) bool {
+  if text == "" || text == "0" {
+    return false
+  }
+  for i := 0; i < len(text); i++ {
+    c := text[i]
+    if c < '0' || c > '9' {
+      return false
+    }
+  }
+  return true
+}
+
+func init() {
+  Register(unicornPreferAt{})
+}

package/linthost/rules_unicorn_prefer_bigint_literals.go

@@ -0,0 +1,77 @@
+// unicorn/prefer-bigint-literals: `BigInt(1)` and `BigInt("1")` both
+// allocate a BigInt at runtime through a constructor call, while the
+// equivalent `1n` literal is one parse-time token with no call
+// overhead. The rule asks authors to use the literal form when the
+// argument is a known integer.
+//
+// AST-only: visit `KindCallExpression`, fire when the callee is the
+// bare `BigInt` identifier called with exactly one argument that is
+// either a numeric literal of any shape, or a string literal whose
+// content is a decimal-digit-only integer (optionally signed). The
+// conservative string check avoids flagging `BigInt("0x10")` and
+// other shapes that need a runtime parse.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-bigint-literals.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferBigintLiterals struct{}
+
+func (unicornPreferBigintLiterals) Name() string { return "unicorn/prefer-bigint-literals" }
+func (unicornPreferBigintLiterals) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferBigintLiterals) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || identifierText(call.Expression) != "BigInt" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil {
+    return
+  }
+  switch arg.Kind {
+  case shimast.KindNumericLiteral:
+    // `BigInt(1)` — always rewritable to `1n`.
+  case shimast.KindStringLiteral:
+    text := stringLiteralText(arg)
+    if !unicornPreferBigintLiteralsIsDecimalInteger(text) {
+      return
+    }
+  default:
+    return
+  }
+  ctx.Report(node, "Prefer BigInt literal `1n` over `BigInt(1)`.")
+}
+
+// unicornPreferBigintLiteralsIsDecimalInteger reports whether `text` is
+// a non-empty decimal-integer literal — digits only, optional leading
+// minus. The check is intentionally conservative; anything more exotic
+// (hex prefix, exponent, decimal point) leaves the BigInt call alone.
+func unicornPreferBigintLiteralsIsDecimalInteger(text string) bool {
+  if text == "" {
+    return false
+  }
+  i := 0
+  if text[0] == '-' || text[0] == '+' {
+    i++
+  }
+  if i == len(text) {
+    return false
+  }
+  for ; i < len(text); i++ {
+    ch := text[i]
+    if ch < '0' || ch > '9' {
+      return false
+    }
+  }
+  return true
+}
+
+func init() {
+  Register(unicornPreferBigintLiterals{})
+}