@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

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

package/linthost/rules_unicorn_no_useless_fallback_in_spread.go

@@ -0,0 +1,81 @@
+// unicorn/no-useless-fallback-in-spread: spreading `null` or `undefined`
+// into an object literal is already a runtime no-op, so the common
+// defensive shape `...(x ?? {})` adds an allocation and a comparison
+// that change nothing. The same goes for `...(x || {})` and the
+// array-literal variants. Drop the fallback and spread the value
+// directly.
+//
+// AST-only: visit each spread node — `SpreadElement` only when its
+// parent is an `ArrayLiteralExpression` (call-argument spread is
+// excluded because spreading `null` / `undefined` into a function call
+// throws a `TypeError`, so the fallback is load-bearing there) and
+// `SpreadAssignment` for object spread. After stripping parentheses,
+// the spread's operand must be a binary expression using `??` or `||`
+// whose right-hand side is an empty object or array literal. The
+// diagnostic anchors on the spread node so editors highlight the
+// redundant fallback together with its `...`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-fallback-in-spread.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessFallbackInSpread struct{}
+
+func (unicornNoUselessFallbackInSpread) Name() string {
+	return "unicorn/no-useless-fallback-in-spread"
+}
+func (unicornNoUselessFallbackInSpread) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSpreadElement, shimast.KindSpreadAssignment}
+}
+func (unicornNoUselessFallbackInSpread) Check(ctx *Context, node *shimast.Node) {
+	var operand *shimast.Node
+	switch node.Kind {
+	case shimast.KindSpreadElement:
+		// Only flag array-literal spread. Call-argument spread of a
+		// null/undefined operand throws TypeError at runtime, so the
+		// `?? []` / `|| []` fallback is load-bearing in that position.
+		if node.Parent == nil || node.Parent.Kind != shimast.KindArrayLiteralExpression {
+			return
+		}
+		if spread := node.AsSpreadElement(); spread != nil {
+			operand = spread.Expression
+		}
+	case shimast.KindSpreadAssignment:
+		if spread := node.AsSpreadAssignment(); spread != nil {
+			operand = spread.Expression
+		}
+	}
+	inner := stripParens(operand)
+	if inner == nil || inner.Kind != shimast.KindBinaryExpression {
+		return
+	}
+	bin := inner.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil {
+		return
+	}
+	switch bin.OperatorToken.Kind {
+	case shimast.KindQuestionQuestionToken, shimast.KindBarBarToken:
+	default:
+		return
+	}
+	right := stripParens(bin.Right)
+	if right == nil {
+		return
+	}
+	switch right.Kind {
+	case shimast.KindObjectLiteralExpression:
+		if obj := right.AsObjectLiteralExpression(); obj != nil &&
+			(obj.Properties == nil || len(obj.Properties.Nodes) == 0) {
+			ctx.Report(node, "Don't use a useless `?? {}` or `?? []` fallback when spreading — `...null` and `...undefined` are no-ops.")
+		}
+	case shimast.KindArrayLiteralExpression:
+		if arr := right.AsArrayLiteralExpression(); arr != nil &&
+			(arr.Elements == nil || len(arr.Elements.Nodes) == 0) {
+			ctx.Report(node, "Don't use a useless `?? {}` or `?? []` fallback when spreading — `...null` and `...undefined` are no-ops.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornNoUselessFallbackInSpread{})
+}

package/linthost/rules_unicorn_no_useless_iterator_to_array.go

@@ -0,0 +1,72 @@
+// unicorn/no-useless-iterator-to-array: wrapping an iterator-producing
+// call in an array-literal spread (`[...arr.entries()]`) materializes
+// every element into a throwaway array just to walk through it again.
+// The wrappers `.entries()`, `.keys()`, `.values()` already return
+// iterables that any iteration consumer can consume directly.
+//
+// AST-only and conservative: visit each `ArrayLiteralExpression` whose
+// only element is a `SpreadElement` wrapping a `CallExpression` whose
+// callee is `PropertyAccess(_, name)` with `name ∈ {entries, keys,
+// values}`. The array literal must also be in an iterator-consuming
+// parent position — currently only `for…of` is matched, since materializing
+// an array to iterate it once is the rule's textbook case. Using the
+// materialized array as data (`[...iter][0]`, `[...iter].map(…)`,
+// `const arr = [...iter]`) is NOT flagged because the author wants the
+// array, not a fresh walk.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-iterator-to-array.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessIteratorToArray struct{}
+
+func (unicornNoUselessIteratorToArray) Name() string {
+	return "unicorn/no-useless-iterator-to-array"
+}
+func (unicornNoUselessIteratorToArray) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindArrayLiteralExpression}
+}
+func (unicornNoUselessIteratorToArray) Check(ctx *Context, node *shimast.Node) {
+	// Only fire when the array literal is the iterable of a `for…of`
+	// loop — that's the canonical wasted-materialization shape. Other
+	// uses (`[...iter][0]`, `const arr = [...iter]`, `.map`, etc.)
+	// genuinely need the materialized array.
+	if node.Parent == nil || node.Parent.Kind != shimast.KindForOfStatement {
+		return
+	}
+	arr := node.AsArrayLiteralExpression()
+	if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
+		return
+	}
+	only := arr.Elements.Nodes[0]
+	if only == nil || only.Kind != shimast.KindSpreadElement {
+		return
+	}
+	spread := only.AsSpreadElement()
+	if spread == nil {
+		return
+	}
+	inner := stripParens(spread.Expression)
+	if inner == nil || inner.Kind != shimast.KindCallExpression {
+		return
+	}
+	call := inner.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 "entries", "keys", "values":
+	default:
+		return
+	}
+	ctx.Report(node, "Don't wrap an iterator with `[...iter]` when iterating directly works.")
+}
+
+func init() {
+	Register(unicornNoUselessIteratorToArray{})
+}

package/linthost/rules_unicorn_no_useless_length_check.go

@@ -0,0 +1,144 @@
+// unicorn/no-useless-length-check: `arr.length > 0 && arr.some(…)`
+// short-circuits on an empty array, but `arr.some(…)` already returns
+// `false` for the empty case, so the leading length check is redundant.
+// The same goes for `forEach` (returns `undefined` either way). The
+// rule prunes the dead check so the call shape is the only thing the
+// reader has to track.
+//
+// `every`, `map`, and `filter` are deliberately excluded from the `&&`
+// set: `every` returns `true` on an empty array (so the length check
+// IS load-bearing); `map` and `filter` return `[]` which is truthy
+// (the length check changes the truthiness of the whole expression).
+// Upstream covers those under the complementary `||` pattern
+// (`array.length === 0 || array.every(…)`), which this MVP does not
+// implement yet.
+//
+// AST-only MVP: visit each `BinaryExpression`, match operator `&&`,
+// require LHS to be `PropertyAccess(X, length) > 0` or `!== 0`, and
+// require RHS to be `CallExpression(PropertyAccess(X, name), …)` where
+// `name` is one of `some` / `forEach` and the textual form of the two
+// `X` expressions matches. Fire on the binary expression.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-length-check.md
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+var unicornNoUselessLengthCheckMethods = map[string]struct{}{
+	"some":    {},
+	"forEach": {},
+}
+
+type unicornNoUselessLengthCheck struct{}
+
+func (unicornNoUselessLengthCheck) Name() string { return "unicorn/no-useless-length-check" }
+func (unicornNoUselessLengthCheck) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornNoUselessLengthCheck) Check(ctx *Context, node *shimast.Node) {
+	bin := node.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil ||
+		bin.OperatorToken.Kind != shimast.KindAmpersandAmpersandToken {
+		return
+	}
+	left := stripParens(bin.Left)
+	right := stripParens(bin.Right)
+	if left == nil || right == nil {
+		return
+	}
+	lengthReceiver := unicornUselessLengthCheckLHSReceiver(ctx, left)
+	if lengthReceiver == "" {
+		return
+	}
+	method, callReceiver := unicornUselessLengthCheckRHSReceiver(ctx, right)
+	if method == "" || callReceiver == "" {
+		return
+	}
+	if lengthReceiver != callReceiver {
+		return
+	}
+	ctx.Report(node, fmt.Sprintf("Useless `.length` check — `%s` already handles empty arrays correctly.", method))
+}
+
+// unicornUselessLengthCheckLHSReceiver returns the textual form of `X`
+// when `node` is `X.length > 0` or `X.length !== 0` (either operand
+// order); returns "" otherwise.
+func unicornUselessLengthCheckLHSReceiver(ctx *Context, node *shimast.Node) string {
+	bin := node.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+		return ""
+	}
+	op := bin.OperatorToken.Kind
+	if op != shimast.KindGreaterThanToken &&
+		op != shimast.KindExclamationEqualsEqualsToken &&
+		op != shimast.KindExclamationEqualsToken {
+		return ""
+	}
+	lhs := stripParens(bin.Left)
+	rhs := stripParens(bin.Right)
+	// Try `X.length <op> 0`.
+	if recv := unicornUselessLengthCheckMatchLengthAccess(ctx, lhs); recv != "" &&
+		unicornUselessLengthCheckIsZero(rhs) {
+		return recv
+	}
+	// `0 !== X.length` (no `<` form because `>` is asymmetric — covered
+	// by the LHS branch above).
+	if op == shimast.KindExclamationEqualsEqualsToken || op == shimast.KindExclamationEqualsToken {
+		if recv := unicornUselessLengthCheckMatchLengthAccess(ctx, rhs); recv != "" &&
+			unicornUselessLengthCheckIsZero(lhs) {
+			return recv
+		}
+	}
+	return ""
+}
+
+// unicornUselessLengthCheckMatchLengthAccess returns the receiver text
+// when `node` is a `PropertyAccessExpression(X, length)`; "" otherwise.
+func unicornUselessLengthCheckMatchLengthAccess(ctx *Context, node *shimast.Node) string {
+	if node == nil || node.Kind != shimast.KindPropertyAccessExpression {
+		return ""
+	}
+	access := node.AsPropertyAccessExpression()
+	if access == nil || identifierText(access.Name()) != "length" {
+		return ""
+	}
+	return nodeText(ctx.File, access.Expression)
+}
+
+// unicornUselessLengthCheckIsZero reports whether `node` is the numeric
+// literal `0`.
+func unicornUselessLengthCheckIsZero(node *shimast.Node) bool {
+	return node != nil &&
+		node.Kind == shimast.KindNumericLiteral &&
+		numericLiteralText(node) == "0"
+}
+
+// unicornUselessLengthCheckRHSReceiver returns (method, receiverText)
+// when `node` is `X.method(...)` for one of the empty-safe iteration
+// methods; ("", "") otherwise.
+func unicornUselessLengthCheckRHSReceiver(ctx *Context, node *shimast.Node) (string, string) {
+	if node == nil || node.Kind != shimast.KindCallExpression {
+		return "", ""
+	}
+	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 _, ok := unicornNoUselessLengthCheckMethods[method]; !ok {
+		return "", ""
+	}
+	return method, nodeText(ctx.File, access.Expression)
+}
+
+func init() {
+	Register(unicornNoUselessLengthCheck{})
+}

package/linthost/rules_unicorn_no_useless_promise_resolve_reject.go

@@ -0,0 +1,81 @@
+// unicorn/no-useless-promise-resolve-reject: inside an `async`
+// function, `return x` already wraps the value in a resolved promise
+// and `throw err` already produces a rejected one. Writing `return
+// Promise.resolve(x)` or `return Promise.reject(err)` rebuilds the
+// wrapper the runtime would build anyway, hides the actual value
+// behind an extra call, and reads as if the author forgot the
+// function was async.
+//
+// AST-only and parent-walking: visit each `ReturnStatement`, find the
+// nearest enclosing function-like ancestor, and require it to carry
+// the `async` modifier. The return's expression after `stripParens`
+// must be a `CallExpression` whose callee is
+// `PropertyAccess(Identifier("Promise"), name)` with
+// `name ∈ {resolve, reject}`. Arrow concise bodies are not handled
+// here because the rule's contract anchors on the `return` keyword.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-promise-resolve-reject.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessPromiseResolveReject struct{}
+
+func (unicornNoUselessPromiseResolveReject) Name() string {
+	return "unicorn/no-useless-promise-resolve-reject"
+}
+func (unicornNoUselessPromiseResolveReject) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindReturnStatement}
+}
+func (unicornNoUselessPromiseResolveReject) Check(ctx *Context, node *shimast.Node) {
+	ret := node.AsReturnStatement()
+	if ret == nil || ret.Expression == nil {
+		return
+	}
+	if !unicornNoUselessPromiseResolveRejectInAsync(node) {
+		return
+	}
+	expr := stripParens(ret.Expression)
+	if expr == nil || expr.Kind != shimast.KindCallExpression {
+		return
+	}
+	call := expr.AsCallExpression()
+	if call == nil || call.Expression == nil ||
+		call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Expression) != "Promise" {
+		return
+	}
+	switch identifierText(access.Name()) {
+	case "resolve", "reject":
+	default:
+		return
+	}
+	ctx.Report(node, "In `async` functions, `return x` and `throw e` work identically — drop the `Promise.<method>` wrapper.")
+}
+
+// unicornNoUselessPromiseResolveRejectInAsync walks ancestors of `node`
+// and reports whether the nearest enclosing function-like declaration
+// is marked `async`. Crossing a function boundary that is not async
+// stops the walk — a nested non-async function shadows the outer
+// async context.
+func unicornNoUselessPromiseResolveRejectInAsync(node *shimast.Node) bool {
+	for cur := node.Parent; cur != nil; cur = cur.Parent {
+		switch cur.Kind {
+		case shimast.KindFunctionDeclaration,
+			shimast.KindFunctionExpression,
+			shimast.KindArrowFunction,
+			shimast.KindMethodDeclaration:
+			return hasModifier(cur, shimast.KindAsyncKeyword)
+		}
+	}
+	return false
+}
+
+func init() {
+	Register(unicornNoUselessPromiseResolveReject{})
+}

package/linthost/rules_unicorn_no_useless_spread.go

@@ -0,0 +1,67 @@
+// unicorn/no-useless-spread: wrapping an already-spread literal in
+// another spread produces the original literal — `[...[1, 2, 3]]` is
+// just `[1, 2, 3]`, and `{...{a: 1}}` is `{a: 1}`. The extra spread
+// reads like an attempted clone but allocates an intermediate literal
+// for no observable effect.
+//
+// AST-only and conservative: visit every `ArrayLiteralExpression` and
+// `ObjectLiteralExpression`; match when the literal contains exactly
+// one element that is a `SpreadElement` / `SpreadAssignment` whose
+// operand (after `stripParens`) is itself a literal of the same kind.
+// The receiver expressions are not inspected — the syntactic shape
+// `[...[…]]` / `{...{…}}` is the signal regardless of the inner
+// literal's contents. Mirrors the conservative dispatch used by
+// `unicorn/prefer-set-size`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-spread.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessSpread struct{}
+
+func (unicornNoUselessSpread) Name() string { return "unicorn/no-useless-spread" }
+func (unicornNoUselessSpread) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindArrayLiteralExpression, shimast.KindObjectLiteralExpression}
+}
+func (unicornNoUselessSpread) Check(ctx *Context, node *shimast.Node) {
+	switch node.Kind {
+	case shimast.KindArrayLiteralExpression:
+		arr := node.AsArrayLiteralExpression()
+		if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
+			return
+		}
+		only := arr.Elements.Nodes[0]
+		if only == nil || only.Kind != shimast.KindSpreadElement {
+			return
+		}
+		spread := only.AsSpreadElement()
+		if spread == nil {
+			return
+		}
+		inner := stripParens(spread.Expression)
+		if inner != nil && inner.Kind == shimast.KindArrayLiteralExpression {
+			ctx.Report(node, "Don't wrap an already-spread literal in another spread.")
+		}
+	case shimast.KindObjectLiteralExpression:
+		obj := node.AsObjectLiteralExpression()
+		if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 1 {
+			return
+		}
+		only := obj.Properties.Nodes[0]
+		if only == nil || only.Kind != shimast.KindSpreadAssignment {
+			return
+		}
+		spread := only.AsSpreadAssignment()
+		if spread == nil {
+			return
+		}
+		inner := stripParens(spread.Expression)
+		if inner != nil && inner.Kind == shimast.KindObjectLiteralExpression {
+			ctx.Report(node, "Don't wrap an already-spread literal in another spread.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornNoUselessSpread{})
+}