@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_unicorn_no_single_promise_in_promise_methods.go

@@ -0,0 +1,59 @@
+// unicorn/no-single-promise-in-promise-methods:
+// `Promise.all([single])`, `Promise.allSettled([single])`,
+// `Promise.race([single])`, and `Promise.any([single])` are redundant
+// wrappers — the result is just `single` (or a one-element array
+// wrapping its resolution, which the caller can produce trivially).
+// The wrapper hides the fact that there is only one promise in flight
+// and forces an extra allocation for no behavioral difference.
+//
+// AST-only and identifier-text-driven: dispatch on `CallExpression`,
+// match a `Promise.<method>` callee against the four collection
+// methods, and require exactly one argument whose stripped form is an
+// `ArrayLiteralExpression` with exactly one element. Shadowed
+// `Promise` bindings are out of scope; the syntactic shape is the
+// signal.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-single-promise-in-promise-methods.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoSinglePromiseInPromiseMethods struct{}
+
+func (unicornNoSinglePromiseInPromiseMethods) Name() string {
+	return "unicorn/no-single-promise-in-promise-methods"
+}
+func (unicornNoSinglePromiseInPromiseMethods) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoSinglePromiseInPromiseMethods) 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.Expression) != "Promise" {
+		return
+	}
+	switch identifierText(access.Name()) {
+	case "all", "allSettled", "race", "any":
+	default:
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+		return
+	}
+	arg := stripParens(call.Arguments.Nodes[0])
+	if arg == nil || arg.Kind != shimast.KindArrayLiteralExpression {
+		return
+	}
+	arr := arg.AsArrayLiteralExpression()
+	if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
+		return
+	}
+	ctx.Report(node, "Don't wrap a single promise in `Promise.<method>([...])` — the wrapper is redundant.")
+}
+
+func init() {
+	Register(unicornNoSinglePromiseInPromiseMethods{})
+}

package/linthost/rules_unicorn_no_static_only_class.go

@@ -0,0 +1,56 @@
+// unicorn/no-static-only-class: a class whose every member is `static`
+// is a namespace dressed up as a class. The `class` keyword introduces
+// a constructor, a prototype chain, and `new`-able semantics that the
+// static-only form never uses. A plain object literal or a module
+// namespace is the more honest shape.
+//
+// AST-only: visit both `ClassDeclaration` and `ClassExpression`. The
+// rule requires at least one member (empty classes are handled by a
+// separate rule) and every member must be a method, property, getter,
+// or setter declaration with the `static` modifier. Constructors,
+// index signatures, and any non-static member disqualify the class.
+// Classes with heritage clauses (`extends`, `implements`) are also
+// skipped — the inheritance IS the reason the class exists, so it
+// can't be replaced by a plain object.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-static-only-class.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoStaticOnlyClass struct{}
+
+func (unicornNoStaticOnlyClass) Name() string { return "unicorn/no-static-only-class" }
+func (unicornNoStaticOnlyClass) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
+}
+func (unicornNoStaticOnlyClass) Check(ctx *Context, node *shimast.Node) {
+	if classHasHeritage(node) {
+		return
+	}
+	members := classMembers(node)
+	if len(members) == 0 {
+		// Empty classes are out of scope — separate rule territory.
+		return
+	}
+	for _, member := range members {
+		if member == nil {
+			return
+		}
+		switch member.Kind {
+		case shimast.KindMethodDeclaration,
+			shimast.KindPropertyDeclaration,
+			shimast.KindGetAccessor,
+			shimast.KindSetAccessor:
+			if !hasModifier(member, shimast.KindStaticKeyword) {
+				return
+			}
+		default:
+			return
+		}
+	}
+	ctx.Report(node, "A class with only static members can be replaced by a plain object or module namespace.")
+}
+
+func init() {
+	Register(unicornNoStaticOnlyClass{})
+}

package/linthost/rules_unicorn_no_thenable.go

@@ -0,0 +1,74 @@
+// unicorn/no-thenable: an object that exposes a callable `then` property
+// becomes accidentally thenable — the runtime's `Promise.resolve(value)`
+// pipeline treats every such value as a promise, so awaiting it invokes
+// the user's `then` instead of resolving to the object itself. This is a
+// common source of surprises in plain data objects and class shapes that
+// were never intended as promises.
+//
+// AST-only: dispatch on every property-defining node form (data
+// property, method, shorthand property, getter, setter) and fire when
+// the name node is an Identifier `then` or a StringLiteral `"then"`.
+// `moduleExportNameText` already returns the right textual value for
+// both shapes; computed names and other syntactic forms are skipped.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-thenable.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoThenable struct{}
+
+func (unicornNoThenable) Name() string { return "unicorn/no-thenable" }
+func (unicornNoThenable) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindPropertyAssignment,
+		shimast.KindMethodDeclaration,
+		shimast.KindShorthandPropertyAssignment,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+	}
+}
+func (unicornNoThenable) Check(ctx *Context, node *shimast.Node) {
+	var name *shimast.Node
+	switch node.Kind {
+	case shimast.KindPropertyAssignment:
+		if a := node.AsPropertyAssignment(); a != nil {
+			name = a.Name()
+		}
+	case shimast.KindMethodDeclaration:
+		if m := node.AsMethodDeclaration(); m != nil {
+			name = m.Name()
+		}
+	case shimast.KindShorthandPropertyAssignment:
+		if s := node.AsShorthandPropertyAssignment(); s != nil {
+			name = s.Name()
+		}
+	case shimast.KindGetAccessor:
+		if g := node.AsGetAccessorDeclaration(); g != nil {
+			name = g.Name()
+		}
+	case shimast.KindSetAccessor:
+		if s := node.AsSetAccessorDeclaration(); s != nil {
+			name = s.Name()
+		}
+	}
+	if name == nil {
+		return
+	}
+	switch name.Kind {
+	case shimast.KindIdentifier:
+		if identifierText(name) != "then" {
+			return
+		}
+	case shimast.KindStringLiteral:
+		if stringLiteralText(name) != "then" {
+			return
+		}
+	default:
+		return
+	}
+	ctx.Report(node, "Don't define a property named `then` — it makes the object accidentally thenable.")
+}
+
+func init() {
+	Register(unicornNoThenable{})
+}

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