@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_unicorn_no_useless_switch_case.go

@@ -0,0 +1,55 @@
+// unicorn/no-useless-switch-case: a `case` clause with no statements
+// that sits immediately above the `default` clause falls through to
+// `default` for free — the value it matches would have hit `default`
+// regardless. Keeping the empty case adds noise without changing the
+// switch's behavior, so the rule reports it.
+//
+// AST-only: visit each `SwitchStatement`, walk its case-block clauses,
+// and report any non-default `CaseClause` whose statements list is
+// empty and whose immediate next sibling is the `DefaultClause`. The
+// empty-body check distinguishes intentional grouped cases that share a
+// non-trivial body from the redundant fall-into-default shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-switch-case.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessSwitchCase struct{}
+
+func (unicornNoUselessSwitchCase) Name() string { return "unicorn/no-useless-switch-case" }
+func (unicornNoUselessSwitchCase) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSwitchStatement}
+}
+func (unicornNoUselessSwitchCase) Check(ctx *Context, node *shimast.Node) {
+	sw := node.AsSwitchStatement()
+	if sw == nil || sw.CaseBlock == nil {
+		return
+	}
+	block := sw.CaseBlock.AsCaseBlock()
+	if block == nil || block.Clauses == nil {
+		return
+	}
+	clauses := block.Clauses.Nodes
+	for i := 0; i < len(clauses)-1; i++ {
+		clause := clauses[i]
+		if clause == nil || clause.Kind != shimast.KindCaseClause {
+			continue
+		}
+		next := clauses[i+1]
+		if next == nil || next.Kind != shimast.KindDefaultClause {
+			continue
+		}
+		cd := clause.AsCaseOrDefaultClause()
+		if cd == nil {
+			continue
+		}
+		if cd.Statements != nil && len(cd.Statements.Nodes) != 0 {
+			continue
+		}
+		ctx.Report(clause, "Useless `case` clause — it falls through to the `default` which would handle this value anyway.")
+	}
+}
+
+func init() {
+	Register(unicornNoUselessSwitchCase{})
+}

package/linthost/rules_unicorn_no_useless_undefined.go

@@ -0,0 +1,55 @@
+// unicorn/no-useless-undefined: `return undefined;` produces the same
+// value as the bare `return;` form, and `void 0` is the canonical
+// roundabout spelling of the same constant. Writing the keyword
+// explicitly adds noise without changing behavior.
+//
+// Minimum-viable port: only the `return` statement shape fires. The
+// call-argument case is intentionally skipped because matching it
+// safely requires knowing which callees accept omission, and the
+// parameter-default case (`function f(x = undefined)`) is deferred.
+//
+// AST-only: visit each `ReturnStatement` whose expression after
+// `stripParens` is either the `undefined` keyword/identifier or the
+// `void 0` shape (a `VoidExpression` whose operand is the numeric
+// literal `0`). Reports on the return statement itself so the
+// diagnostic anchors on the keyword rather than the operand.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-undefined.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessUndefined struct{}
+
+func (unicornNoUselessUndefined) Name() string { return "unicorn/no-useless-undefined" }
+func (unicornNoUselessUndefined) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindReturnStatement}
+}
+func (unicornNoUselessUndefined) Check(ctx *Context, node *shimast.Node) {
+	ret := node.AsReturnStatement()
+	if ret == nil || ret.Expression == nil {
+		return
+	}
+	expr := stripParens(ret.Expression)
+	if expr == nil {
+		return
+	}
+	if expr.Kind == shimast.KindUndefinedKeyword || identifierText(expr) == "undefined" {
+		ctx.Report(node, "Don't `return undefined;` — `return undefined;` and bare `return;` have the same effect.")
+		return
+	}
+	if expr.Kind == shimast.KindVoidExpression {
+		void := expr.AsVoidExpression()
+		if void == nil || void.Expression == nil {
+			return
+		}
+		operand := stripParens(void.Expression)
+		if operand != nil && operand.Kind == shimast.KindNumericLiteral &&
+			numericLiteralText(operand) == "0" {
+			ctx.Report(node, "Don't `return undefined;` — `return undefined;` and bare `return;` have the same effect.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornNoUselessUndefined{})
+}

package/linthost/rules_unicorn_no_zero_fractions.go

@@ -0,0 +1,52 @@
+// unicorn/no-zero-fractions: numeric literals such as `1.0`, `1.`, and
+// `.0` carry a redundant fractional component or a trailing dot whose
+// only visual effect is to mislead the reader into thinking the value
+// needs floating-point semantics. The rule rewrites the source pattern
+// out by reporting on the literal node.
+//
+// AST-only: visit `KindNumericLiteral`, read the raw source text via
+// `nodeText` so the parser-normalized `.Text` (which drops the trailing
+// dot and zero-pad) doesn't mask the smell, and match three regular
+// expressions covering the canonical shapes:
+//
+//   - `1.0`, `1.00`, `-1.0e5` — fractional part is all zeros.
+//   - `1.` — trailing dot with no fractional digits.
+//   - `.0`, `-.0e3` — leading dot with an all-zero fractional part.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-zero-fractions.md
+package linthost
+
+import (
+	"regexp"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+var (
+	unicornNoZeroFractionsTrailingZero = regexp.MustCompile(`^-?\d+\.0+([eE][+-]?\d+)?$`)
+	unicornNoZeroFractionsTrailingDot  = regexp.MustCompile(`^-?\d+\.$`)
+	unicornNoZeroFractionsLeadingDot   = regexp.MustCompile(`^-?\.0+([eE][+-]?\d+)?$`)
+)
+
+type unicornNoZeroFractions struct{}
+
+func (unicornNoZeroFractions) Name() string { return "unicorn/no-zero-fractions" }
+func (unicornNoZeroFractions) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNumericLiteral}
+}
+func (unicornNoZeroFractions) Check(ctx *Context, node *shimast.Node) {
+	source := strings.TrimSpace(nodeText(ctx.File, node))
+	if source == "" {
+		return
+	}
+	if unicornNoZeroFractionsTrailingZero.MatchString(source) ||
+		unicornNoZeroFractionsTrailingDot.MatchString(source) ||
+		unicornNoZeroFractionsLeadingDot.MatchString(source) {
+		ctx.Report(node, "Don't use a redundant `.0` fraction or trailing dot on a number literal.")
+	}
+}
+
+func init() {
+	Register(unicornNoZeroFractions{})
+}

package/linthost/rules_unicorn_number_literal_case.go

@@ -0,0 +1,69 @@
+// unicorn/number-literal-case: hex / binary / octal numeric literals
+// have a conventional canonical form — the radix prefix is lowercase
+// (`0x`, `0b`, `0o`) while hex digits are uppercase (`0xFF`). Mixed-case
+// alternatives (`0Xff`, `0xff`, `0xFf`, `0XFF`) read inconsistently and
+// the rule normalizes the codebase by reporting every literal that
+// isn't already canonical.
+//
+// AST-only: visit `KindNumericLiteral` and `KindBigIntLiteral`, read
+// the raw source text via `nodeText` so the prefix and digit casing
+// survive the parser's normalization, and report when the prefix letter
+// is uppercase OR any hex digit is lowercase. Decimal literals lack a
+// prefix and never fire.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/number-literal-case.md
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornNumberLiteralCase struct{}
+
+func (unicornNumberLiteralCase) Name() string { return "unicorn/number-literal-case" }
+func (unicornNumberLiteralCase) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNumericLiteral, shimast.KindBigIntLiteral}
+}
+func (unicornNumberLiteralCase) Check(ctx *Context, node *shimast.Node) {
+	source := strings.TrimSpace(nodeText(ctx.File, node))
+	if len(source) < 2 || source[0] != '0' {
+		return
+	}
+	prefix := source[1]
+	switch prefix {
+	case 'x', 'X':
+		if unicornNumberLiteralCaseHexNeedsFix(source, prefix) {
+			ctx.Report(node, "Number literals should use a lowercase prefix and uppercase digits — e.g. `0xFF` instead of `0xff`.")
+		}
+	case 'b', 'B', 'o', 'O':
+		// Binary / octal digits are 0-1 / 0-7; only the prefix letter
+		// can be in the wrong case.
+		if prefix == 'B' || prefix == 'O' {
+			ctx.Report(node, "Number literals should use a lowercase prefix and uppercase digits — e.g. `0xFF` instead of `0xff`.")
+		}
+	}
+}
+
+// unicornNumberLiteralCaseHexNeedsFix reports whether the hex literal's
+// raw source text deviates from `0x` + uppercase digits. The trailing
+// `n` of a hex bigint literal (`0xFFn`) is allowed.
+func unicornNumberLiteralCaseHexNeedsFix(source string, prefix byte) bool {
+	if prefix != 'x' {
+		return true
+	}
+	digits := source[2:]
+	digits = strings.TrimSuffix(digits, "n")
+	for i := 0; i < len(digits); i++ {
+		ch := digits[i]
+		if ch >= 'a' && ch <= 'f' {
+			return true
+		}
+	}
+	return false
+}
+
+func init() {
+	Register(unicornNumberLiteralCase{})
+}

package/linthost/rules_unicorn_numeric_separators_style.go

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

package/linthost/rules_unicorn_prefer_add_event_listener.go

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

package/linthost/rules_unicorn_prefer_array_find.go

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

package/linthost/rules_unicorn_prefer_array_flat.go

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

package/linthost/rules_unicorn_prefer_array_flat_map.go

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