@ttsc/lint 0.13.1 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_no_this_assignment.go

@@ -0,0 +1,35 @@
+// unicorn/no-this-assignment: capturing `this` into a local variable —
+// the classic `const self = this;` / `var that = this;` — was a workaround
+// before arrow functions existed. Modern callers should close over the
+// outer `this` with an arrow function instead so the binding cannot drift
+// or be reassigned.
+//
+// AST-only: dispatch on `KindVariableDeclaration` and fire when the
+// initializer (after stripping parentheses, so `const self = (this);`
+// also matches) is `KindThisKeyword`. The diagnostic anchors on the
+// declaration node so reporters surface the whole `name = this` line.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-this-assignment.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoThisAssignment struct{}
+
+func (unicornNoThisAssignment) Name() string { return "unicorn/no-this-assignment" }
+func (unicornNoThisAssignment) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindVariableDeclaration}
+}
+func (unicornNoThisAssignment) Check(ctx *Context, node *shimast.Node) {
+  decl := node.AsVariableDeclaration()
+  if decl == nil || decl.Initializer == nil {
+    return
+  }
+  if stripParens(decl.Initializer).Kind != shimast.KindThisKeyword {
+    return
+  }
+  ctx.Report(node, "Don't assign `this` to a variable — capture via an arrow function instead.")
+}
+
+func init() {
+  Register(unicornNoThisAssignment{})
+}

package/linthost/rules_unicorn_no_typeof_undefined.go

@@ -0,0 +1,58 @@
+// unicorn/no-typeof-undefined: comparing `typeof X` against the string
+// literal `"undefined"` is a leftover guard from pre-strict-mode code,
+// when referencing an undeclared identifier threw a ReferenceError.
+// Modern code can compare the value to `undefined` directly, which is
+// shorter and reads as the intent it actually expresses.
+//
+// AST-only: each visited BinaryExpression is rejected when its operator
+// is one of `===`, `==`, `!==`, `!=` and its two operands include
+// exactly one TypeOfExpression and exactly one string-shaped literal
+// (StringLiteral or NoSubstitutionTemplateLiteral) whose text value is
+// `undefined`. Either side may carry the typeof; either side may carry
+// the literal.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-typeof-undefined.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoTypeofUndefined struct{}
+
+func (unicornNoTypeofUndefined) Name() string { return "unicorn/no-typeof-undefined" }
+func (unicornNoTypeofUndefined) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornNoTypeofUndefined) Check(ctx *Context, node *shimast.Node) {
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  switch expr.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindEqualsEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken:
+  default:
+    return
+  }
+  left := stripParens(expr.Left)
+  right := stripParens(expr.Right)
+  if left == nil || right == nil {
+    return
+  }
+  var literal *shimast.Node
+  if left.Kind == shimast.KindTypeOfExpression {
+    literal = right
+  } else if right.Kind == shimast.KindTypeOfExpression {
+    literal = left
+  } else {
+    return
+  }
+  if stringLiteralText(literal) != "undefined" {
+    return
+  }
+  ctx.Report(node, "Compare with `undefined` directly instead of using `typeof`.")
+}
+
+func init() {
+  Register(unicornNoTypeofUndefined{})
+}

package/linthost/rules_unicorn_no_unnecessary_array_flat_depth.go

@@ -0,0 +1,49 @@
+// unicorn/no-unnecessary-array-flat-depth: `Array#flat()` already defaults
+// to depth `1`, so writing `.flat(1)` is a redundant spelling that adds
+// noise without changing behavior. The rule flags the explicit `1` so
+// the call collapses to the dependency-free `.flat()` shorthand.
+//
+// AST-only: dispatch on `KindCallExpression`, require a property-access
+// callee whose method identifier is `flat`, exactly one argument, and
+// that argument's NumericLiteral text to be "1". Other numeric arguments
+// are handled by `unicorn/no-magic-array-flat-depth`; this sibling rule
+// only owns the literal-`1` shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-array-flat-depth.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUnnecessaryArrayFlatDepth struct{}
+
+func (unicornNoUnnecessaryArrayFlatDepth) Name() string {
+  return "unicorn/no-unnecessary-array-flat-depth"
+}
+func (unicornNoUnnecessaryArrayFlatDepth) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoUnnecessaryArrayFlatDepth) 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()) != "flat" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  if numericLiteralText(arg) != "1" {
+    return
+  }
+  ctx.Report(node, "`Array#flat()` already defaults to depth 1 — omit the argument.")
+}
+
+func init() {
+  Register(unicornNoUnnecessaryArrayFlatDepth{})
+}

package/linthost/rules_unicorn_no_unnecessary_array_splice_count.go

@@ -0,0 +1,70 @@
+// unicorn/no-unnecessary-array-splice-count: `arr.splice(start, arr.length)`
+// and `arr.splice(start, Infinity)` both say "delete from `start` to the
+// end", but `splice` already does that when the count argument is
+// omitted entirely. Dropping the redundant count makes the intent read
+// directly: "splice from `start`."
+//
+// AST-only: each visited `CallExpression` checks a `splice` /
+// `toSpliced` callee with at least two arguments and inspects the
+// second. A `.length` property access (on any receiver — the rule
+// doesn't try to reconcile receivers) or a bare `Infinity` identifier
+// both fire. Anything else is a real count.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-array-splice-count.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUnnecessaryArraySpliceCount struct{}
+
+func (unicornNoUnnecessaryArraySpliceCount) Name() string {
+  return "unicorn/no-unnecessary-array-splice-count"
+}
+func (unicornNoUnnecessaryArraySpliceCount) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoUnnecessaryArraySpliceCount) 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
+  }
+  method := identifierText(access.Name())
+  if method != "splice" && method != "toSpliced" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
+    return
+  }
+  second := stripParens(call.Arguments.Nodes[1])
+  if !unicornUnnecessaryCountArgument(second) {
+    return
+  }
+  ctx.Report(call.Arguments.Nodes[1], "Use `splice(start)` without the count — `.length` / `Infinity` is the default.")
+}
+
+// unicornUnnecessaryCountArgument reports whether `node` is one of the
+// two redundant "until the end" shapes — a `.length` property access on
+// any receiver, or the bare `Infinity` identifier.
+func unicornUnnecessaryCountArgument(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindPropertyAccessExpression {
+    access := node.AsPropertyAccessExpression()
+    if access == nil {
+      return false
+    }
+    return identifierText(access.Name()) == "length"
+  }
+  if node.Kind == shimast.KindIdentifier {
+    return identifierText(node) == "Infinity"
+  }
+  return false
+}
+
+func init() {
+  Register(unicornNoUnnecessaryArraySpliceCount{})
+}

package/linthost/rules_unicorn_no_unnecessary_await.go

@@ -0,0 +1,51 @@
+// unicorn/no-unnecessary-await: `await x` only changes anything when
+// `x` is thenable; awaiting a value that the language guarantees is
+// not a promise (a literal, an object/array literal, the result of a
+// non-async constructor call, etc.) just costs one extra microtask and
+// reads as if the author forgot what type they were holding.
+//
+// AST-only minimum-viable port: visit each `AwaitExpression` and only
+// fire when the operand (after `stripParens`) is a node whose value the
+// parser already pins as not-thenable: a string/number/bigint/regex
+// literal, a template literal, an array or object literal, `true`,
+// `false`, or `null`. Without type information, identifiers and
+// function calls are unsafe to flag — their values can be promises.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-await.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUnnecessaryAwait struct{}
+
+func (unicornNoUnnecessaryAwait) Name() string { return "unicorn/no-unnecessary-await" }
+func (unicornNoUnnecessaryAwait) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindAwaitExpression}
+}
+func (unicornNoUnnecessaryAwait) Check(ctx *Context, node *shimast.Node) {
+  await := node.AsAwaitExpression()
+  if await == nil || await.Expression == nil {
+    return
+  }
+  operand := stripParens(await.Expression)
+  if operand == nil {
+    return
+  }
+  switch operand.Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindTemplateExpression,
+    shimast.KindRegularExpressionLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindArrayLiteralExpression,
+    shimast.KindObjectLiteralExpression:
+    ctx.Report(node, "Don't `await` a non-thenable expression.")
+  }
+}
+
+func init() {
+  Register(unicornNoUnnecessaryAwait{})
+}

package/linthost/rules_unicorn_no_unnecessary_polyfills.go

@@ -0,0 +1,32 @@
+// unicorn/no-unnecessary-polyfills: rejects imports of polyfill
+// packages (`core-js/…`, `es6-promise`, …) for APIs the project's
+// targeted runtime already supports natively. The signal is "this
+// dependency is dead weight for our `engines.node` / `browserslist`
+// floor".
+//
+// Escape-hatch / no-op port: the rule needs two external inputs the
+// AST-only engine in this package does not yet have a place for: the
+// project's targeted runtime baseline (read upstream from
+// `package.json#engines`, `browserslist`, or a rule option) and a
+// curated polyfill-package → API map kept in lockstep with caniuse /
+// MDN. Until both are wired through the linthost configuration, firing
+// would either be uninformed (no baseline) or wrong (stale map).
+// Registered so the typed-key/Go-registry parity check passes and so
+// users can configure the rule, but it intentionally reports nothing
+// until the inputs land in a follow-up.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-polyfills.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUnnecessaryPolyfills struct{}
+
+func (unicornNoUnnecessaryPolyfills) Name() string           { return "unicorn/no-unnecessary-polyfills" }
+func (unicornNoUnnecessaryPolyfills) Visits() []shimast.Kind { return nil }
+func (unicornNoUnnecessaryPolyfills) Check(_ *Context, _ *shimast.Node) {
+  // Intentionally empty — see file header for the escape-hatch rationale.
+}
+
+func init() {
+  Register(unicornNoUnnecessaryPolyfills{})
+}

package/linthost/rules_unicorn_no_unnecessary_slice_end.go

@@ -0,0 +1,48 @@
+// unicorn/no-unnecessary-slice-end: `arr.slice(start, arr.length)` and
+// `arr.slice(start, Infinity)` both clamp the end to the array's tail,
+// which is exactly what `slice(start)` already does. Removing the
+// redundant end argument shortens the call without changing behavior.
+//
+// AST-only: each visited `CallExpression` checks a `slice` callee with
+// exactly two arguments and inspects the second. A `.length` property
+// access (on any receiver) or a bare `Infinity` identifier both fire.
+// Three or more arguments is out of shape for `Array#slice` and is
+// ignored.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-slice-end.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUnnecessarySliceEnd struct{}
+
+func (unicornNoUnnecessarySliceEnd) Name() string {
+  return "unicorn/no-unnecessary-slice-end"
+}
+func (unicornNoUnnecessarySliceEnd) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoUnnecessarySliceEnd) 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()) != "slice" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+    return
+  }
+  second := stripParens(call.Arguments.Nodes[1])
+  if !unicornUnnecessaryCountArgument(second) {
+    return
+  }
+  ctx.Report(call.Arguments.Nodes[1], "Use `slice(start)` without the end — `.length` / `Infinity` is the default.")
+}
+
+func init() {
+  Register(unicornNoUnnecessarySliceEnd{})
+}

package/linthost/rules_unicorn_no_unreadable_array_destructuring.go

@@ -0,0 +1,115 @@
+// unicorn/no-unreadable-array-destructuring: a destructuring pattern
+// like `[, , a]` uses a run of comma holes to skip array positions
+// before the binding the caller actually wants. The hole run is
+// positional, silent, and trivial to miscount, so the rule flags
+// patterns with two or more consecutive holes followed by a real
+// element. A single leading hole (`[, second]`) is a common idiom and
+// is not flagged. The recommended replacement is an indexed read
+// (`arr[2]`).
+//
+// AST-only and syntactic: dispatch on `ArrayBindingPattern` for
+// declaration / parameter destructuring AND `ArrayLiteralExpression`
+// for the assignment-destructuring form (which the parser models as an
+// array literal in LHS position). A run of three or more
+// `OmittedExpression` holes followed by a non-hole element trips the
+// diagnostic; runs that are not followed by anything (trailing holes)
+// are not actionable and are out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unreadable-array-destructuring.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUnreadableArrayDestructuring struct{}
+
+func (unicornNoUnreadableArrayDestructuring) Name() string {
+  return "unicorn/no-unreadable-array-destructuring"
+}
+func (unicornNoUnreadableArrayDestructuring) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindArrayBindingPattern, shimast.KindArrayLiteralExpression}
+}
+func (unicornNoUnreadableArrayDestructuring) Check(ctx *Context, node *shimast.Node) {
+  var elements []*shimast.Node
+  switch node.Kind {
+  case shimast.KindArrayBindingPattern:
+    pattern := node.AsBindingPattern()
+    if pattern == nil || pattern.Elements == nil {
+      return
+    }
+    elements = pattern.Elements.Nodes
+  case shimast.KindArrayLiteralExpression:
+    // Array literals fire only when they appear in a destructuring-
+    // assignment position; otherwise the holes are just sparse-array
+    // construction, which a different rule covers.
+    if !isAssignmentDestructuringTarget(node) {
+      return
+    }
+    arr := node.AsArrayLiteralExpression()
+    if arr == nil || arr.Elements == nil {
+      return
+    }
+    elements = arr.Elements.Nodes
+  default:
+    return
+  }
+  run := 0
+  for _, el := range elements {
+    if isArrayDestructuringHole(el) {
+      run++
+      continue
+    }
+    if run >= 2 {
+      ctx.Report(node, "Don't use unreadable array destructuring with long hole runs.")
+      return
+    }
+    run = 0
+  }
+}
+
+// isArrayDestructuringHole reports whether `el` is a comma "hole" in an
+// array destructuring/literal context. The TypeScript parser models a
+// hole in an `ArrayLiteralExpression` as `OmittedExpression`, but a
+// hole in an `ArrayBindingPattern` as a `BindingElement` with no name
+// (and no initializer / dotdotdot). Both shapes contribute to a run.
+func isArrayDestructuringHole(el *shimast.Node) bool {
+  if el == nil {
+    return false
+  }
+  if el.Kind == shimast.KindOmittedExpression {
+    return true
+  }
+  if el.Kind == shimast.KindBindingElement {
+    be := el.AsBindingElement()
+    if be != nil && be.Name() == nil && be.Initializer == nil && be.DotDotDotToken == nil {
+      return true
+    }
+  }
+  return false
+}
+
+// isAssignmentDestructuringTarget reports whether `node` (an
+// ArrayLiteralExpression) appears on the LHS of an `=` assignment or
+// in another write-target position. The parser models destructuring
+// assignment as an array-literal expression in LHS slot; without this
+// gate every plain sparse array literal would trip the rule.
+func isAssignmentDestructuringTarget(node *shimast.Node) bool {
+  parent := node.Parent
+  for parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
+    parent = parent.Parent
+  }
+  if parent == nil {
+    return false
+  }
+  if parent.Kind == shimast.KindBinaryExpression {
+    bin := parent.AsBinaryExpression()
+    if bin != nil && bin.OperatorToken != nil &&
+      bin.OperatorToken.Kind == shimast.KindEqualsToken &&
+      stripParens(bin.Left) == node {
+      return true
+    }
+  }
+  return false
+}
+
+func init() {
+  Register(unicornNoUnreadableArrayDestructuring{})
+}

package/linthost/rules_unicorn_no_unreadable_iife.go

@@ -0,0 +1,50 @@
+// unicorn/no-unreadable-iife: an IIFE whose body is itself another
+// call expression — `(() => f())()` — reads as two layers of
+// invocation for one effective call. The shape obscures the actual
+// computation and the rule asks authors to extract the call site so
+// the inner function name appears at the top level instead of being
+// hidden behind an anonymous arrow.
+//
+// AST-only: visit `KindCallExpression`, accept when the callee is a
+// `KindParenthesizedExpression` wrapping a `KindArrowFunction` whose
+// body is a `KindCallExpression`. Block-bodied arrows and arrows that
+// return a non-call expression don't match — only the arrow → call
+// shape is "unreadable" in the upstream sense.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unreadable-iife.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUnreadableIIFE struct{}
+
+func (unicornNoUnreadableIIFE) Name() string { return "unicorn/no-unreadable-iife" }
+func (unicornNoUnreadableIIFE) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoUnreadableIIFE) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if call.Expression.Kind != shimast.KindParenthesizedExpression {
+    return
+  }
+  paren := call.Expression.AsParenthesizedExpression()
+  if paren == nil || paren.Expression == nil ||
+    paren.Expression.Kind != shimast.KindArrowFunction {
+    return
+  }
+  arrow := paren.Expression.AsArrowFunction()
+  if arrow == nil || arrow.Body == nil {
+    return
+  }
+  if arrow.Body.Kind != shimast.KindCallExpression {
+    return
+  }
+  ctx.Report(node, "Avoid unreadable IIFEs — extract the function.")
+}
+
+func init() {
+  Register(unicornNoUnreadableIIFE{})
+}

package/linthost/rules_unicorn_no_unused_properties.go

@@ -0,0 +1,30 @@
+// unicorn/no-unused-properties: flags object-literal properties that
+// are never read after the object is constructed. The signal is "this
+// key sits in a literal that nothing reaches into" — analogous to
+// `no-unused-vars` but for one level deeper inside object data.
+//
+// Escape-hatch / no-op port: implementing this faithfully requires
+// per-object reachability and read tracking across the file (and across
+// destructuring patterns, spread, computed access, and exports). That
+// is a scope-and-flow problem the AST-only engine in this package
+// cannot yet model without false positives every time a property is
+// read through dynamic access. Registered so the typed-key/Go-registry
+// parity check passes and so users can configure the rule, but it
+// intentionally reports nothing until the analysis lands in a
+// follow-up.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unused-properties.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUnusedProperties struct{}
+
+func (unicornNoUnusedProperties) Name() string           { return "unicorn/no-unused-properties" }
+func (unicornNoUnusedProperties) Visits() []shimast.Kind { return nil }
+func (unicornNoUnusedProperties) Check(_ *Context, _ *shimast.Node) {
+  // Intentionally empty — see file header for the escape-hatch rationale.
+}
+
+func init() {
+  Register(unicornNoUnusedProperties{})
+}

package/linthost/rules_unicorn_no_useless_collection_argument.go

@@ -0,0 +1,63 @@
+// unicorn/no-useless-collection-argument: `new Set()`, `new Map()`,
+// `new WeakSet()`, and `new WeakMap()` already start empty. Passing an
+// explicit `null`, `undefined`, or `[]` reads as if the author meant to
+// seed the collection with entries but came up empty — it adds noise
+// without changing behavior. Zero-argument calls are the canonical
+// correct form and are NOT flagged.
+//
+// AST-only and identifier-text-driven: visit every `NewExpression`
+// whose callee identifier is one of the four collection constructors,
+// then match a single argument that is a `null`/`undefined` literal,
+// an `undefined` identifier, or an empty array literal. The receiver
+// chain is not inspected; shadowed `Set`/`Map` bindings are out of
+// scope, mirroring the other constructor-name-only unicorn rules.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-collection-argument.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessCollectionArgument struct{}
+
+func (unicornNoUselessCollectionArgument) Name() string {
+  return "unicorn/no-useless-collection-argument"
+}
+func (unicornNoUselessCollectionArgument) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNewExpression}
+}
+func (unicornNoUselessCollectionArgument) Check(ctx *Context, node *shimast.Node) {
+  ne := node.AsNewExpression()
+  if ne == nil {
+    return
+  }
+  switch identifierText(ne.Expression) {
+  case "Set", "Map", "WeakSet", "WeakMap":
+  default:
+    return
+  }
+  if ne.Arguments == nil || len(ne.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(ne.Arguments.Nodes[0])
+  if arg == nil {
+    return
+  }
+  switch arg.Kind {
+  case shimast.KindNullKeyword, shimast.KindUndefinedKeyword:
+    ctx.Report(node, "Don't pass a useless initializer to `new <Collection>()`.")
+    return
+  case shimast.KindIdentifier:
+    if identifierText(arg) == "undefined" {
+      ctx.Report(node, "Don't pass a useless initializer to `new <Collection>()`.")
+    }
+    return
+  case shimast.KindArrayLiteralExpression:
+    if arr := arg.AsArrayLiteralExpression(); arr != nil &&
+      (arr.Elements == nil || len(arr.Elements.Nodes) == 0) {
+      ctx.Report(node, "Don't pass a useless initializer to `new <Collection>()`.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornNoUselessCollectionArgument{})
+}

package/linthost/rules_unicorn_no_useless_error_capture_stack_trace.go

@@ -0,0 +1,46 @@
+// unicorn/no-useless-error-capture-stack-trace: `new Error()` already
+// captures a stack trace by default, so calling
+// `Error.captureStackTrace(this, …)` inside an Error-subclass
+// constructor just rebuilds the same trace and adds noise without
+// changing behavior. The rule flags the redundant call.
+//
+// AST-only MVP: visit each `CallExpression`, match when the callee is
+// `Error.captureStackTrace` and the first argument is the `this`
+// keyword. Detecting "inside an Error subclass constructor" is left to
+// a future iteration — the MVP covers the common shape directly and is
+// safe because `Error.captureStackTrace(this, …)` is uniformly useless
+// inside subclasses anyway.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-error-capture-stack-trace.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessErrorCaptureStackTrace struct{}
+
+func (unicornNoUselessErrorCaptureStackTrace) Name() string {
+  return "unicorn/no-useless-error-capture-stack-trace"
+}
+func (unicornNoUselessErrorCaptureStackTrace) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoUselessErrorCaptureStackTrace) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if !isMatchingPropertyAccess(call.Expression, "Error", "captureStackTrace") {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 1 {
+    return
+  }
+  first := stripParens(call.Arguments.Nodes[0])
+  if first == nil || first.Kind != shimast.KindThisKeyword {
+    return
+  }
+  ctx.Report(node, "Don't call `Error.captureStackTrace(this, ...)` in an `Error` subclass — the default capture already happens.")
+}
+
+func init() {
+  Register(unicornNoUselessErrorCaptureStackTrace{})
+}