@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_ts_switch_exhaustiveness_check.go

@@ -0,0 +1,147 @@
+// switchExhaustivenessCheck reports `switch (e)` statements where the
+// discriminant is a union of literal types or an enum and at least one
+// constituent has no matching `case` clause AND the switch carries no
+// `default` clause. Either covering every member explicitly or adding a
+// `default` arm makes the intent visible and forces the compiler to
+// flag any future addition to the union/enum at every switch site.
+// typescript-eslint strict-type-checked:
+// https://typescript-eslint.io/rules/switch-exhaustiveness-check/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// switchExhaustivenessCheck is type-aware: the discriminant is resolved
+// via the Checker, and uncovered members are computed by removing every
+// case-clause expression's type from the union's constituent set. The
+// rule only fires when the discriminant resolves to a union — plain
+// `string` or `number` discriminants are open-ended and outside the
+// rule's scope, matching typescript-eslint's behavior.
+//
+// Identity is established by `*Type` pointer comparison rather than
+// literal value comparison: TypeScript canonicalizes string and number
+// literal types (`stringLiteralTypes` / `numberLiteralTypes` maps inside
+// the checker), so two references to `"a"` resolve to the same `*Type`
+// instance. Enum literal types are likewise canonicalized per enum
+// member, so `case E.A:` and the `E.A` constituent of the discriminant's
+// union share their `*Type` pointer.
+type switchExhaustivenessCheck struct{}
+
+func (switchExhaustivenessCheck) Name() string { return "typescript/switch-exhaustiveness-check" }
+func (switchExhaustivenessCheck) NeedsTypeChecker() bool {
+	return true
+}
+func (switchExhaustivenessCheck) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSwitchStatement}
+}
+func (switchExhaustivenessCheck) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	sw := node.AsSwitchStatement()
+	if sw == nil || sw.Expression == nil || sw.CaseBlock == nil {
+		return
+	}
+	block := sw.CaseBlock.AsCaseBlock()
+	if block == nil || block.Clauses == nil {
+		return
+	}
+	// A `default` clause covers anything not enumerated above, so the
+	// rule has nothing to add. typescript-eslint also exits early in
+	// this case.
+	for _, clause := range block.Clauses.Nodes {
+		if clause != nil && clause.Kind == shimast.KindDefaultClause {
+			return
+		}
+	}
+	discriminantType := ctx.Checker.GetTypeAtLocation(sw.Expression)
+	if discriminantType == nil {
+		return
+	}
+	// Only consider discriminants whose static type is a finite union of
+	// literal-like constituents. Plain `string` / `number` / `unknown`
+	// are open-ended and never exhaustively coverable.
+	members := switchExhaustivenessCheckCollectMembers(discriminantType)
+	if len(members) == 0 {
+		return
+	}
+	covered := make(map[*shimchecker.Type]bool, len(members))
+	for _, clause := range block.Clauses.Nodes {
+		if clause == nil || clause.Kind != shimast.KindCaseClause {
+			continue
+		}
+		caseClause := clause.AsCaseOrDefaultClause()
+		if caseClause == nil || caseClause.Expression == nil {
+			continue
+		}
+		caseType := ctx.Checker.GetTypeAtLocation(caseClause.Expression)
+		if caseType == nil {
+			continue
+		}
+		covered[caseType] = true
+	}
+	missing := 0
+	for _, member := range members {
+		if !covered[member] {
+			missing++
+		}
+	}
+	if missing == 0 {
+		return
+	}
+	ctx.Report(node, "Switch is not exhaustive. Cases not matched: add a `case` for every union/enum member, or include a `default` clause.")
+}
+
+// switchExhaustivenessCheckCollectMembers returns the finite literal /
+// enum-literal constituents of t when t is a discriminable union, and
+// nil when t is open-ended (plain `string`, `number`, `any`, `unknown`,
+// etc.). A union whose constituents are all literals or enum literals
+// is treated as exhaustively coverable; any non-literal constituent
+// (e.g. `string` mixed into `"a" | "b" | string`) widens the union and
+// disqualifies the whole discriminant.
+func switchExhaustivenessCheckCollectMembers(t *shimchecker.Type) []*shimchecker.Type {
+	if t == nil {
+		return nil
+	}
+	flags := t.Flags()
+	if flags&shimchecker.TypeFlagsUnion == 0 {
+		return nil
+	}
+	parts := t.Types()
+	if len(parts) == 0 {
+		return nil
+	}
+	members := make([]*shimchecker.Type, 0, len(parts))
+	for _, part := range parts {
+		if part == nil {
+			return nil
+		}
+		if !switchExhaustivenessCheckIsLiteralLike(part) {
+			return nil
+		}
+		members = append(members, part)
+	}
+	return members
+}
+
+// switchExhaustivenessCheckIsLiteralLike reports whether t is a
+// constituent that participates in finite enumeration: a unit type
+// (string/number/bigint/boolean literal), an enum literal, or one of
+// the nullish singletons. The matching set mirrors typescript-eslint's
+// `lib.isTypeFlagSet(constituent, TypeFlags.Literal | ...)` filter.
+func switchExhaustivenessCheckIsLiteralLike(t *shimchecker.Type) bool {
+	flags := t.Flags()
+	if flags&shimchecker.TypeFlagsLiteral != 0 {
+		return true
+	}
+	if flags&(shimchecker.TypeFlagsUndefined|shimchecker.TypeFlagsNull|shimchecker.TypeFlagsVoid) != 0 {
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(switchExhaustivenessCheck{})
+}

package/linthost/rules_ts_unbound_method.go

@@ -0,0 +1,126 @@
+// unboundMethod reports a property access that names a class instance
+// method but is used as a value instead of being immediately invoked.
+// JavaScript methods are not bound to their receiver — `obj.method`,
+// once extracted, loses the `this` binding the body relies on, so
+// passing it as a callback (`setTimeout(obj.method, 0)`) or aliasing
+// it (`const f = obj.method`) silently breaks at the first `this.x`
+// dereference. typescript-eslint:
+// https://typescript-eslint.io/rules/unbound-method/
+//
+// Type-aware. The Checker resolves the property's symbol; the rule
+// fires when any of the symbol's declarations is a class
+// MethodDeclaration. The conservative baseline skips:
+//
+//   - the callee position of a call (`obj.method()` is fine);
+//   - the left-hand side of an assignment (`obj.method = fn`);
+//   - the operand of `typeof`, `delete`, `instanceof`, and `in`;
+//   - tagged-template tag positions;
+//   - static methods (the constructor that owns them is stably bound);
+//   - methods declared only as MethodSignature on an interface or
+//     type literal (those are structural — the runtime value may be a
+//     plain function property, and flagging them at every consumer
+//     produces too many false positives).
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unboundMethod struct{}
+
+func (unboundMethod) Name() string { return "typescript/unbound-method" }
+func (unboundMethod) NeedsTypeChecker() bool {
+	return true
+}
+func (unboundMethod) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unboundMethod) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	access := node.AsPropertyAccessExpression()
+	if access == nil || access.Name() == nil {
+		return
+	}
+	if unboundMethodSafePosition(node) {
+		return
+	}
+	symbol := ctx.Checker.GetSymbolAtLocation(access.Name())
+	if symbol == nil {
+		return
+	}
+	if !unboundMethodSymbolIsClassMethod(symbol) {
+		return
+	}
+	ctx.Report(node, "Avoid referencing an unbound method which may cause unintentional scoping of `this`.")
+}
+
+// unboundMethodSafePosition reports whether the property access sits in
+// a syntactic position that already discharges the unbound-method risk.
+// The list mirrors typescript-eslint's safe-position whitelist: an
+// immediately-invoked call, an assignment target, a typeof / delete
+// operand, an instanceof / in operand, and a tagged-template tag are
+// all positions where the method reference is consumed in place rather
+// than carried away as a free function value.
+func unboundMethodSafePosition(node *shimast.Node) bool {
+	parent := node.Parent
+	if parent == nil {
+		return false
+	}
+	switch parent.Kind {
+	case shimast.KindCallExpression:
+		call := parent.AsCallExpression()
+		if call != nil && call.Expression == node {
+			return true
+		}
+	case shimast.KindTaggedTemplateExpression:
+		return true
+	case shimast.KindBinaryExpression:
+		bin := parent.AsBinaryExpression()
+		if bin == nil || bin.OperatorToken == nil {
+			return false
+		}
+		switch bin.OperatorToken.Kind {
+		case shimast.KindEqualsToken,
+			shimast.KindInstanceOfKeyword,
+			shimast.KindInKeyword:
+			return true
+		}
+	case shimast.KindTypeOfExpression, shimast.KindDeleteExpression:
+		return true
+	}
+	return false
+}
+
+// unboundMethodSymbolIsClassMethod reports whether symbol denotes a
+// non-static class instance method. The rule ignores plain method
+// signatures on interfaces and type literals because those are
+// structural — the runtime value may be a regular function rather
+// than a bound class member, and flagging them at every consumer
+// would produce a high false-positive volume. Static methods slip
+// past this check because they are accessed through the class
+// constructor itself, which is bound for the lifetime of the
+// program.
+func unboundMethodSymbolIsClassMethod(symbol *shimast.Symbol) bool {
+	if symbol == nil {
+		return false
+	}
+	for _, decl := range symbol.Declarations {
+		if decl == nil {
+			continue
+		}
+		if decl.Kind != shimast.KindMethodDeclaration {
+			continue
+		}
+		if hasModifier(decl, shimast.KindStaticKeyword) {
+			continue
+		}
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(unboundMethod{})
+}

package/linthost/rules_tsdoc.go

@@ -0,0 +1,136 @@
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// tsdocSyntax validates a conservative subset of eslint-plugin-tsdoc's
+// `tsdoc/syntax` rule. It intentionally starts with structural diagnostics
+// that can be checked from source text alone: malformed top-level block tags
+// and malformed or unclosed inline tags.
+type tsdocSyntax struct{}
+
+func (tsdocSyntax) Name() string           { return "jsdoc/tsdoc-syntax" }
+func (tsdocSyntax) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+
+func (tsdocSyntax) Check(ctx *Context, node *shimast.Node) {
+	if ctx == nil || ctx.File == nil {
+		return
+	}
+	src := ctx.File.Text()
+	for _, block := range findJSDocBlocks(src) {
+		checkTSDocBlockTags(ctx, src, block)
+		checkTSDocInlineTags(ctx, src, block)
+	}
+}
+
+func checkTSDocBlockTags(ctx *Context, src string, block jsdocBlock) {
+	walkJSDocLines(src, block, func(contentStart, lineEnd int, inFence bool) {
+		if inFence || contentStart >= lineEnd || src[contentStart] != '@' {
+			return
+		}
+		tagStart := contentStart + 1
+		if tagStart >= lineEnd || !isTSDocTagStart(src[tagStart]) {
+			ctx.ReportRange(contentStart, minInt(lineEnd, contentStart+2), "Malformed TSDoc block tag.")
+		}
+	})
+}
+
+func checkTSDocInlineTags(ctx *Context, src string, block jsdocBlock) {
+	walkJSDocLines(src, block, func(contentStart, lineEnd int, inFence bool) {
+		if inFence {
+			return
+		}
+		for i := contentStart; i+1 < lineEnd; i++ {
+			if src[i] != '{' || src[i+1] != '@' {
+				continue
+			}
+			tagStart := i + 2
+			if tagStart >= lineEnd || !isTSDocTagStart(src[tagStart]) {
+				ctx.ReportRange(i, minInt(lineEnd, i+2), "Malformed TSDoc inline tag.")
+				continue
+			}
+			tagEnd := tagStart + 1
+			for tagEnd < lineEnd && isTSDocTagContinue(src[tagEnd]) {
+				tagEnd++
+			}
+			close := findByteInRange(src, '}', tagEnd, block.bodyEnd)
+			if close < 0 {
+				ctx.ReportRange(i, tagEnd, "Unclosed TSDoc inline tag.")
+				i = tagEnd - 1
+				continue
+			}
+			i = close
+		}
+	})
+}
+
+func walkJSDocLines(src string, block jsdocBlock, visit func(contentStart, lineEnd int, inFence bool)) {
+	inFence := false
+	for lineStart := block.bodyStart; lineStart < block.bodyEnd; {
+		lineEnd := lineStart
+		for lineEnd < block.bodyEnd && src[lineEnd] != '\n' {
+			lineEnd++
+		}
+		contentStart := tsdocLineContentStart(src, lineStart, lineEnd)
+		visit(contentStart, trimLineEnd(src, lineEnd), inFence)
+		if startsWithFenceMarker(src, contentStart, trimLineEnd(src, lineEnd)) {
+			inFence = !inFence
+		}
+		if lineEnd >= block.bodyEnd {
+			break
+		}
+		lineStart = lineEnd + 1
+	}
+}
+
+func tsdocLineContentStart(src string, lineStart, lineEnd int) int {
+	i := lineStart
+	for i < lineEnd && (src[i] == ' ' || src[i] == '\t' || src[i] == '\r') {
+		i++
+	}
+	if i < lineEnd && src[i] == '*' {
+		i++
+		if i < lineEnd && src[i] == ' ' {
+			i++
+		}
+	}
+	return i
+}
+
+func trimLineEnd(src string, lineEnd int) int {
+	for lineEnd > 0 && src[lineEnd-1] == '\r' {
+		lineEnd--
+	}
+	return lineEnd
+}
+
+func startsWithFenceMarker(src string, start, end int) bool {
+	return end-start >= 3 && src[start] == '`' && src[start+1] == '`' && src[start+2] == '`'
+}
+
+func findByteInRange(src string, target byte, start, end int) int {
+	for i := start; i < end; i++ {
+		if src[i] == target {
+			return i
+		}
+	}
+	return -1
+}
+
+func isTSDocTagStart(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}
+
+func isTSDocTagContinue(b byte) bool {
+	return isTSDocTagStart(b) || (b >= '0' && b <= '9') || b == '-'
+}
+
+func minInt(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func init() {
+	Register(tsdocSyntax{})
+}

package/linthost/rules_unicorn_better_regex.go

@@ -0,0 +1,27 @@
+// unicorn/better-regex: the upstream rule rewrites regex literals into
+// the shortest equivalent form (e.g. `[0-9]` -> `\d`, `[^\W\D]` -> `\d`,
+// dedupes character classes, collapses redundant quantifiers). That
+// rewrite requires a full regex parser with character-class semantics —
+// far beyond the AST-only scope of this slice — so the rule is
+// registered as a no-op stub to keep `TestTypedKeysMatchRegisteredRules`
+// honest with the typed `ITtscLintUnicornRules` surface.
+//
+// Replace this stub with a real implementation when a regex AST helper
+// lands; the matching fixture under
+// `tests/test-lint/src/cases/unicorn-better-regex.ts` carries the
+// `@ttsc-corpus-skip` directive so the corpus test suite walks past it.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/better-regex.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornBetterRegex struct{}
+
+func (unicornBetterRegex) Name() string           { return "unicorn/better-regex" }
+func (unicornBetterRegex) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornBetterRegex) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+	Register(unicornBetterRegex{})
+}

package/linthost/rules_unicorn_catch_error_name.go

@@ -0,0 +1,46 @@
+// unicorn/catch-error-name: a `catch (err)` clause whose binding is
+// anything other than `error` violates the project convention. The
+// stylistic point is that readers should see `catch (error)` and
+// immediately know the binding is the thrown value — bespoke names
+// like `e`, `err`, or `exception` create one-character variance for
+// no semantic gain.
+//
+// AST-only: visit each `CatchClause`, skip clauses with no binding
+// (optional catch-binding) and clauses whose binding is a destructuring
+// pattern (out of scope — the rule cannot rename a pattern in place).
+// When the binding identifier text is not `error`, report on the
+// identifier node so the diagnostic underlines the offending name.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/catch-error-name.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornCatchErrorName struct{}
+
+func (unicornCatchErrorName) Name() string { return "unicorn/catch-error-name" }
+func (unicornCatchErrorName) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCatchClause}
+}
+func (unicornCatchErrorName) Check(ctx *Context, node *shimast.Node) {
+	catch := node.AsCatchClause()
+	if catch == nil || catch.VariableDeclaration == nil {
+		return
+	}
+	binding := catch.VariableDeclaration.Name()
+	if binding == nil {
+		return
+	}
+	// Destructuring (object/array binding pattern) is out of scope.
+	if binding.Kind != shimast.KindIdentifier {
+		return
+	}
+	name := identifierText(binding)
+	if name == "" || name == "error" {
+		return
+	}
+	ctx.Report(binding, "The catch parameter should be named `error`.")
+}
+
+func init() {
+	Register(unicornCatchErrorName{})
+}

package/linthost/rules_unicorn_consistent_assert.go

@@ -0,0 +1,47 @@
+// unicorn/consistent-assert: `assert.equal` and `assert.notEqual` perform
+// loose equality (`==` / `!=`) at the runtime layer. The Node `assert`
+// module ships strict counterparts — `assert.strictEqual` and
+// `assert.notStrictEqual` — that read identically at the call site but
+// hold the stronger invariant. The rule pins the strict variants so
+// equality assertions don't silently accept type coercions.
+//
+// AST-only: visit each `CallExpression`. Match a callee of the shape
+// `assert.equal` or `assert.notEqual` (a `PropertyAccessExpression`
+// whose object identifier is `assert` and method name is one of the
+// loose-equality pair). The diagnostic anchors on the call so editors
+// can offer a strict-variant fix at the same position.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-assert.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentAssert struct{}
+
+func (unicornConsistentAssert) Name() string { return "unicorn/consistent-assert" }
+func (unicornConsistentAssert) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornConsistentAssert) 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 || access.Expression == nil {
+		return
+	}
+	if identifierText(access.Expression) != "assert" {
+		return
+	}
+	switch identifierText(access.Name()) {
+	case "equal", "notEqual":
+	default:
+		return
+	}
+	ctx.Report(node, "Use the strict variant — `assert.strictEqual` / `assert.notStrictEqual`.")
+}
+
+func init() {
+	Register(unicornConsistentAssert{})
+}

package/linthost/rules_unicorn_consistent_date_clone.go

@@ -0,0 +1,54 @@
+// unicorn/consistent-date-clone: the `Date` constructor copies a date
+// directly when handed another `Date` instance, so the common
+// `new Date(other.getTime())` shape adds a redundant `getTime()` hop
+// that yields the same instant. The shorter `new Date(other)` form is
+// the canonical clone.
+//
+// AST-only: visit each `NewExpression` whose callee identifier is
+// `Date` and whose single argument is `<receiver>.getTime()` with no
+// arguments. The receiver itself is opaque — only the call shape
+// matters because any `Date`-valued expression yields the same clone
+// when passed directly. The diagnostic anchors on the new-expression.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-date-clone.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentDateClone struct{}
+
+func (unicornConsistentDateClone) Name() string {
+	return "unicorn/consistent-date-clone"
+}
+func (unicornConsistentDateClone) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNewExpression}
+}
+func (unicornConsistentDateClone) Check(ctx *Context, node *shimast.Node) {
+	ne := node.AsNewExpression()
+	if ne == nil || identifierText(ne.Expression) != "Date" {
+		return
+	}
+	if ne.Arguments == nil || len(ne.Arguments.Nodes) != 1 {
+		return
+	}
+	arg := stripParens(ne.Arguments.Nodes[0])
+	if arg == nil || arg.Kind != shimast.KindCallExpression {
+		return
+	}
+	call := arg.AsCallExpression()
+	if call == nil || call.Expression == nil ||
+		call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil || identifierText(access.Name()) != "getTime" {
+		return
+	}
+	if call.Arguments != nil && len(call.Arguments.Nodes) != 0 {
+		return
+	}
+	ctx.Report(node, "Pass the `Date` directly to `new Date(...)` — `getTime()` is redundant.")
+}
+
+func init() {
+	Register(unicornConsistentDateClone{})
+}

package/linthost/rules_unicorn_consistent_destructuring.go

@@ -0,0 +1,25 @@
+// MVP: registers the rule so the typed-key parity test passes; the
+// upstream behavior needs scope analysis (track each destructured
+// binding through subsequent member-access sites in the same scope),
+// which is out of scope for this AST-only port.
+//
+// unicorn/consistent-destructuring:
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-destructuring.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentDestructuring struct{}
+
+func (unicornConsistentDestructuring) Name() string {
+	return "unicorn/consistent-destructuring"
+}
+func (unicornConsistentDestructuring) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornConsistentDestructuring) Check(ctx *Context, node *shimast.Node) {
+}
+
+func init() {
+	Register(unicornConsistentDestructuring{})
+}

package/linthost/rules_unicorn_consistent_empty_array_spread.go

@@ -0,0 +1,62 @@
+// unicorn/consistent-empty-array-spread: when an array literal contains
+// a spread of a ternary, both branches should be arrays so the runtime
+// shape of the parent literal stays uniform. The lopsided form
+// `[1, ...(cond ? [x] : 2)]` mixes "spread an array" and "spread a
+// non-array" — only one branch yields the structural shape the reader
+// expects.
+//
+// AST-only: visit each `ArrayLiteralExpression`. For every element
+// that is a `SpreadElement` wrapping a `ConditionalExpression`, fire
+// when exactly one of the two branches is itself an array literal
+// (the other branch is anything else). The diagnostic anchors on the
+// spread so the editor highlights both the `...` and the ternary.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-empty-array-spread.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentEmptyArraySpread struct{}
+
+func (unicornConsistentEmptyArraySpread) Name() string {
+	return "unicorn/consistent-empty-array-spread"
+}
+func (unicornConsistentEmptyArraySpread) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindArrayLiteralExpression}
+}
+func (unicornConsistentEmptyArraySpread) Check(ctx *Context, node *shimast.Node) {
+	arr := node.AsArrayLiteralExpression()
+	if arr == nil || arr.Elements == nil {
+		return
+	}
+	for _, el := range arr.Elements.Nodes {
+		if el == nil || el.Kind != shimast.KindSpreadElement {
+			continue
+		}
+		spread := el.AsSpreadElement()
+		if spread == nil {
+			continue
+		}
+		inner := stripParens(spread.Expression)
+		if inner == nil || inner.Kind != shimast.KindConditionalExpression {
+			continue
+		}
+		cond := inner.AsConditionalExpression()
+		if cond == nil {
+			continue
+		}
+		whenTrue := stripParens(cond.WhenTrue)
+		whenFalse := stripParens(cond.WhenFalse)
+		if whenTrue == nil || whenFalse == nil {
+			continue
+		}
+		trueIsArr := whenTrue.Kind == shimast.KindArrayLiteralExpression
+		falseIsArr := whenFalse.Kind == shimast.KindArrayLiteralExpression
+		if trueIsArr != falseIsArr {
+			ctx.Report(el, "When spreading a ternary in an array literal, both branches should be arrays.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornConsistentEmptyArraySpread{})
+}