@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_ts_prefer_nullish_coalescing.go

@@ -0,0 +1,104 @@
+// AST-only baseline of typescript-eslint's `prefer-nullish-coalescing`.
+//
+// The rule discourages `x || y`, `x ||= y`, and the ternary `x ? x : y`
+// pattern when the intent is to substitute a default for `null` /
+// `undefined`. `||` short-circuits on every falsy value (0, "", false,
+// NaN), so what reads as "default this if missing" silently coerces
+// legitimate zeros and empty strings. The ES2020 `??` operator
+// short-circuits only on nullish values and is almost always what the
+// author meant.
+//
+// Without the Checker the rule cannot prove `x` actually admits
+// `null | undefined`, so the conservative AST-only baseline skips
+// operands that the surrounding context already coerces to boolean —
+// `if (a || b)`, `!(a || b)`, `cond ? a || b : …`, etc. — and fires on
+// the remaining value-producing positions. This mirrors the upstream
+// rule's behavior on plain JS where strictNullChecks is off and the
+// rule still flags the same shapes.
+// https://typescript-eslint.io/rules/prefer-nullish-coalescing/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type preferNullishCoalescing struct{}
+
+func (preferNullishCoalescing) Name() string { return "typescript/prefer-nullish-coalescing" }
+func (preferNullishCoalescing) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindBinaryExpression,
+		shimast.KindConditionalExpression,
+	}
+}
+func (preferNullishCoalescing) Check(ctx *Context, node *shimast.Node) {
+	switch node.Kind {
+	case shimast.KindBinaryExpression:
+		expr := node.AsBinaryExpression()
+		if expr == nil || expr.OperatorToken == nil {
+			return
+		}
+		switch expr.OperatorToken.Kind {
+		case shimast.KindBarBarToken:
+			if isInBooleanContext(node) {
+				return
+			}
+			reportPreferNullishCoalescing(ctx, expr.OperatorToken, "Prefer `??` over `||` when the intent is to default `null` / `undefined` — `||` also short-circuits on falsy values like 0, \"\", and false.")
+		case shimast.KindBarBarEqualsToken:
+			reportPreferNullishCoalescing(ctx, expr.OperatorToken, "Prefer `??=` over `||=` when the intent is to default `null` / `undefined` — `||=` also assigns on falsy values like 0, \"\", and false.")
+		}
+	case shimast.KindConditionalExpression:
+		cond := node.AsConditionalExpression()
+		if cond == nil || cond.Condition == nil || cond.WhenTrue == nil {
+			return
+		}
+		// `x ? x : y` — the `whenTrue` branch is the same expression as
+		// the test. Compare canonical text after stripping parentheses
+		// from both sides so `(x) ? x : y` still matches.
+		if !ternarySelfTest(ctx, cond) {
+			return
+		}
+		ctx.Report(node, "Prefer `??` over `x ? x : y` when the intent is to default `null` / `undefined` — the ternary form also falls through on falsy values like 0, \"\", and false.")
+	}
+}
+
+// reportPreferNullishCoalescing pins the diagnostic range to the
+// operator token (`||` / `||=`) rather than the whole binary expression
+// so the squiggle highlights the offending operator and editor "go to
+// fix" actions hover over the token the rule is about.
+func reportPreferNullishCoalescing(ctx *Context, operator *shimast.Node, message string) {
+	pos, end := tokenRange(ctx.File, operator)
+	if pos < 0 {
+		ctx.Report(operator, message)
+		return
+	}
+	ctx.ReportRange(pos, end, message)
+}
+
+// ternarySelfTest reports whether `cond ? whenTrue : whenFalse` has the
+// shape `x ? x : y` — i.e. the truthy branch repeats the condition. The
+// comparison uses `nodeText` so parenthesized variants (`(x) ? x : y`)
+// and member-access chains (`a.b ? a.b : c`) both match. Side-effecting
+// expressions are intentionally not excluded here: the upstream rule
+// fires on `f() ? f() : g()` too and lets the author decide whether the
+// transform is safe.
+func ternarySelfTest(ctx *Context, cond *shimast.ConditionalExpression) bool {
+	if ctx == nil || ctx.File == nil || cond == nil {
+		return false
+	}
+	test := stripParens(cond.Condition)
+	whenTrue := stripParens(cond.WhenTrue)
+	if test == nil || whenTrue == nil {
+		return false
+	}
+	testText := nodeText(ctx.File, test)
+	whenTrueText := nodeText(ctx.File, whenTrue)
+	if testText == "" || whenTrueText == "" {
+		return false
+	}
+	return testText == whenTrueText
+}
+
+func init() {
+	Register(preferNullishCoalescing{})
+}

package/linthost/rules_ts_prefer_optional_chain.go

@@ -0,0 +1,228 @@
+// preferOptionalChain reports `a && a.b` / `a && a.b && a.b.c` and
+// `a != null && a.b` chained boolean patterns and suggests `a?.b?.c`.
+// The optional-chain form is shorter and short-circuits to `undefined`
+// instead of the leftmost falsy value, which is almost always what the
+// author wanted when guarding a property access against a nullish base.
+//
+// This is the AST-only baseline: the rule fires when the receiver of
+// the right-hand member access textually starts with the left-hand
+// guard expression. Cases where the chain crosses through a call
+// expression with arguments are skipped — those have observable side
+// effects, so the `?.` form is not equivalent.
+// https://typescript-eslint.io/rules/prefer-optional-chain/
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type preferOptionalChain struct{}
+
+func (preferOptionalChain) Name() string { return "typescript/prefer-optional-chain" }
+func (preferOptionalChain) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (preferOptionalChain) Check(ctx *Context, node *shimast.Node) {
+	expr := node.AsBinaryExpression()
+	if expr == nil || expr.OperatorToken == nil {
+		return
+	}
+	if expr.OperatorToken.Kind != shimast.KindAmpersandAmpersandToken {
+		return
+	}
+	// Skip when the binary expression is itself the left side of an
+	// outer `&&` — the outer node will be visited and report the full
+	// chain. Reporting at every inner conjunct would flood `a && a.b
+	// && a.b.c` with two diagnostics on the same chain.
+	if parent := node.Parent; parent != nil && parent.Kind == shimast.KindBinaryExpression {
+		pe := parent.AsBinaryExpression()
+		if pe != nil && pe.OperatorToken != nil &&
+			pe.OperatorToken.Kind == shimast.KindAmpersandAmpersandToken &&
+			pe.Left == node {
+			return
+		}
+	}
+	guardText, ok := preferOptionalChainGuardText(ctx, expr.Left)
+	if !ok {
+		return
+	}
+	right := stripParens(expr.Right)
+	if !preferOptionalChainRightMatches(ctx, right, guardText) {
+		return
+	}
+	ctx.Report(node, "Prefer an optional chain (`a?.b`) over `a && a.b` — shorter and short-circuits to `undefined` instead of the leftmost falsy value.")
+}
+
+// preferOptionalChainRightmostConjunct returns the rightmost operand
+// of a left-associative `&&` chain. For `(a && a.b) && a.b.c` the
+// rightmost conjunct of the left is `a.b`, which is the immediate
+// guard the outer `&&` was extending.
+func preferOptionalChainRightmostConjunct(node *shimast.Node) *shimast.Node {
+	node = stripParens(node)
+	for node != nil && node.Kind == shimast.KindBinaryExpression {
+		inner := node.AsBinaryExpression()
+		if inner == nil || inner.OperatorToken == nil ||
+			inner.OperatorToken.Kind != shimast.KindAmpersandAmpersandToken ||
+			inner.Right == nil {
+			return node
+		}
+		node = stripParens(inner.Right)
+	}
+	return node
+}
+
+// preferOptionalChainGuardText returns the textual identity of the
+// guard expression on the left of `&&`. The guard may be an identifier
+// (`a && a.b`), a property access (`a.b && a.b.c`), or a `!= null` /
+// `!== null` / `!== undefined` comparison (`a != null && a.b`). For the
+// comparison form, the returned text is the non-null side, which is
+// what the right-hand access must start with.
+func preferOptionalChainGuardText(ctx *Context, left *shimast.Node) (string, bool) {
+	left = stripParens(left)
+	if left == nil {
+		return "", false
+	}
+	switch left.Kind {
+	case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
+		text := nodeText(ctx.File, left)
+		return text, text != ""
+	case shimast.KindBinaryExpression:
+		inner := left.AsBinaryExpression()
+		if inner == nil || inner.OperatorToken == nil {
+			return "", false
+		}
+		// Chain extension: `(x && a.b) && a.b.c` — peel down to the
+		// rightmost conjunct (`a.b`) and use it as the guard against
+		// the outer right side.
+		if inner.OperatorToken.Kind == shimast.KindAmpersandAmpersandToken {
+			conjunct := preferOptionalChainRightmostConjunct(left)
+			if conjunct == nil {
+				return "", false
+			}
+			switch conjunct.Kind {
+			case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
+				text := nodeText(ctx.File, conjunct)
+				return text, text != ""
+			}
+			return "", false
+		}
+		if inner.OperatorToken.Kind != shimast.KindExclamationEqualsToken &&
+			inner.OperatorToken.Kind != shimast.KindExclamationEqualsEqualsToken {
+			return "", false
+		}
+		lhs := stripParens(inner.Left)
+		rhs := stripParens(inner.Right)
+		if subject, ok := preferOptionalChainNullishCompareSubject(ctx, lhs, rhs); ok {
+			return subject, true
+		}
+		if subject, ok := preferOptionalChainNullishCompareSubject(ctx, rhs, lhs); ok {
+			return subject, true
+		}
+	}
+	return "", false
+}
+
+// preferOptionalChainNullishCompareSubject returns the textual identity
+// of `subject` when `nullish` is `null` or `undefined` and `subject` is
+// an identifier or property access. Returns the empty text otherwise.
+func preferOptionalChainNullishCompareSubject(
+	ctx *Context,
+	subject, nullish *shimast.Node,
+) (string, bool) {
+	if subject == nil || nullish == nil {
+		return "", false
+	}
+	if !preferOptionalChainIsNullOrUndefined(nullish) {
+		return "", false
+	}
+	switch subject.Kind {
+	case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
+		text := nodeText(ctx.File, subject)
+		return text, text != ""
+	}
+	return "", false
+}
+
+// preferOptionalChainIsNullOrUndefined reports whether node is the
+// `null` keyword or the `undefined` identifier.
+func preferOptionalChainIsNullOrUndefined(node *shimast.Node) bool {
+	if node == nil {
+		return false
+	}
+	if node.Kind == shimast.KindNullKeyword {
+		return true
+	}
+	if node.Kind == shimast.KindIdentifier {
+		return identifierText(node) == "undefined"
+	}
+	return false
+}
+
+// preferOptionalChainRightMatches reports whether `right` is a
+// property access or call expression whose receiver textually starts
+// with `guardText` followed by `.` or `[`. Calls with arguments are
+// rejected — the `?.` rewrite would not preserve side-effect ordering
+// when the arguments themselves can have side effects.
+func preferOptionalChainRightMatches(
+	ctx *Context,
+	right *shimast.Node,
+	guardText string,
+) bool {
+	if right == nil || guardText == "" {
+		return false
+	}
+	switch right.Kind {
+	case shimast.KindPropertyAccessExpression:
+		access := right.AsPropertyAccessExpression()
+		if access == nil || access.Expression == nil {
+			return false
+		}
+		return preferOptionalChainHasPrefix(ctx, right, guardText)
+	case shimast.KindCallExpression:
+		call := right.AsCallExpression()
+		if call == nil || call.Expression == nil {
+			return false
+		}
+		// Skip calls with arguments — their evaluation cannot be
+		// observed identically through `?.()`.
+		if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+			return false
+		}
+		// The callee receiver must itself be a property access; a
+		// bare identifier call (`a()`) has no chain to fold.
+		callee := stripParens(call.Expression)
+		if callee == nil || callee.Kind != shimast.KindPropertyAccessExpression {
+			return false
+		}
+		return preferOptionalChainHasPrefix(ctx, right, guardText)
+	}
+	return false
+}
+
+// preferOptionalChainHasPrefix returns whether the textual form of
+// `node` begins with `guard` followed by a `.` or `[` — the only
+// continuations that mean "a property of the guarded value".
+func preferOptionalChainHasPrefix(
+	ctx *Context,
+	node *shimast.Node,
+	guard string,
+) bool {
+	text := nodeText(ctx.File, node)
+	if !strings.HasPrefix(text, guard) {
+		return false
+	}
+	if len(text) == len(guard) {
+		return false
+	}
+	switch text[len(guard)] {
+	case '.', '[', '(':
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(preferOptionalChain{})
+}

package/linthost/rules_ts_prefer_promise_reject_errors.go

@@ -0,0 +1,176 @@
+// TypeScript-aware analog of typescript/only-throw-error for Promise
+// rejection sites: `Promise.reject(value)` should hand callers an Error
+// instance, not a primitive or other non-Error value. A non-Error
+// rejection loses the structured stack trace and breaks downstream
+// `instanceof Error` checks in `.catch(...)` / `try { await … } catch
+// (err)` handlers. typescript-eslint:
+// https://typescript-eslint.io/rules/prefer-promise-reject-errors/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// preferPromiseRejectErrors reports `Promise.reject(arg)`, `p.reject(arg)`
+// on a Promise-typed receiver, and `reject(arg)` calls to the second
+// parameter of a `new Promise((_, reject) => …)` executor when `arg`'s
+// static type is a primitive (string / number / boolean / bigint / void
+// / undefined / null). Mirrors `onlyThrowError` for `throw` statements.
+//
+// Type-aware. `any` / `unknown` / `never` pass through — they propagate
+// from generic helpers and a strict rejection would explode at every
+// re-reject of a caught `unknown`. Object types (including plain object
+// literals) are conservatively allowed by this baseline; the practical
+// effect is that `Promise.reject("boom")` and `Promise.reject(42)` are
+// caught but `Promise.reject({ code: 1 })` slips through.
+type preferPromiseRejectErrors struct{}
+
+func (preferPromiseRejectErrors) Name() string {
+	return "typescript/prefer-promise-reject-errors"
+}
+func (preferPromiseRejectErrors) NeedsTypeChecker() bool {
+	return true
+}
+func (preferPromiseRejectErrors) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (preferPromiseRejectErrors) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return
+	}
+	if !preferPromiseRejectErrorsIsRejectCall(ctx, call, node) {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+		return
+	}
+	arg := stripParens(call.Arguments.Nodes[0])
+	if arg == nil {
+		return
+	}
+	t := ctx.Checker.GetTypeAtLocation(arg)
+	if t == nil {
+		return
+	}
+	if preferPromiseRejectErrorsIsNonError(ctx.Checker, t) {
+		ctx.Report(node, "Reject promises with an Error object instead of a non-Error value.")
+	}
+}
+
+// preferPromiseRejectErrorsIsRejectCall returns true when `call` is one of
+//   - `Promise.reject(arg)`
+//   - `<promise-typed-receiver>.reject(arg)`
+//   - a bare `reject(arg)` call to the second parameter name of an
+//     enclosing `new Promise((_, reject) => …)` executor.
+//
+// `node` is the AST node form of `call`, used for the parent walk.
+func preferPromiseRejectErrorsIsRejectCall(ctx *Context, call *shimast.CallExpression, node *shimast.Node) bool {
+	receiver, method, ok := promisePropertyAccessParts(call.Expression)
+	if ok && method == "reject" {
+		if identifierText(receiver) == "Promise" {
+			return true
+		}
+		if ctx.Checker != nil && receiver != nil {
+			if t := ctx.Checker.GetTypeAtLocation(receiver); t != nil &&
+				isPromiseTypedExpression(ctx.Checker, t) {
+				return true
+			}
+		}
+		return false
+	}
+	// Bare identifier call — check Promise executor binding.
+	name := callCalleeName(call)
+	if name == "" {
+		return false
+	}
+	return preferPromiseRejectErrorsIsExecutorReject(node, name)
+}
+
+// preferPromiseRejectErrorsIsExecutorReject walks parent function-like
+// scopes from `node` and reports true when one of those scopes is the
+// executor parameter of `new Promise(...)` and the executor's second
+// parameter is named `name`. Mirrors the param walking used by
+// `promiseNoMultipleResolved`.
+func preferPromiseRejectErrorsIsExecutorReject(node *shimast.Node, name string) bool {
+	for fn := nearestFunctionLike(node); fn != nil; fn = nearestFunctionLike(fn) {
+		if !preferPromiseRejectErrorsIsPromiseExecutorFn(fn) {
+			continue
+		}
+		params := fn.Parameters()
+		if len(params) < 2 {
+			continue
+		}
+		if parameterIdentifierName(params[1]) == name {
+			return true
+		}
+	}
+	return false
+}
+
+// preferPromiseRejectErrorsIsPromiseExecutorFn reports whether `fn` is
+// the first argument of an enclosing `new Promise(...)` expression. The
+// walk strips parentheses the same way `isPromiseCallbackFunctionFor`
+// does in rules_promise.go so `new Promise(((_, reject) => …))` still
+// matches.
+func preferPromiseRejectErrorsIsPromiseExecutorFn(fn *shimast.Node) bool {
+	if fn == nil || !isFunctionLikeKind(fn) {
+		return false
+	}
+	cur := fn
+	for parent := cur.Parent; parent != nil && parent.Kind == shimast.KindParenthesizedExpression; parent = parent.Parent {
+		cur = parent
+	}
+	newExpr := cur.Parent
+	if newExpr == nil || newExpr.Kind != shimast.KindNewExpression {
+		return false
+	}
+	ne := newExpr.AsNewExpression()
+	if ne == nil || identifierText(ne.Expression) != "Promise" || ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
+		return false
+	}
+	return stripParens(ne.Arguments.Nodes[0]) == fn
+}
+
+// preferPromiseRejectErrorsIsNonError mirrors `onlyThrowErrorIsPrimitive`
+// in rules_ts_async.go. `any` / `unknown` / `never` are intentionally
+// NOT flagged because they propagate from generic helpers; an Error
+// instance fed through such a helper would otherwise produce noise.
+// Union and intersection types recurse: a constituent that is primitive
+// is enough to fire, matching the throw-side baseline.
+func preferPromiseRejectErrorsIsNonError(checker *shimchecker.Checker, t *shimchecker.Type) bool {
+	if checker == nil || t == nil {
+		return false
+	}
+	flags := t.Flags()
+	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+		return false
+	}
+	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+		for _, part := range t.Types() {
+			if part == nil {
+				continue
+			}
+			if preferPromiseRejectErrorsIsNonError(checker, part) {
+				return true
+			}
+		}
+		return false
+	}
+	const primitiveMask = shimchecker.TypeFlagsStringLike |
+		shimchecker.TypeFlagsNumberLike |
+		shimchecker.TypeFlagsBigIntLike |
+		shimchecker.TypeFlagsBooleanLike |
+		shimchecker.TypeFlagsVoid |
+		shimchecker.TypeFlagsUndefined |
+		shimchecker.TypeFlagsNull
+	return flags&primitiveMask != 0
+}
+
+func init() {
+	Register(preferPromiseRejectErrors{})
+}

package/linthost/rules_ts_prefer_readonly.go

@@ -0,0 +1,73 @@
+// preferReadonly reports private class fields that are initialized at
+// the declaration site (so the constructor has nothing left to assign)
+// and could safely carry the `readonly` modifier. Locking the field as
+// readonly catches accidental reassignments and signals the field's
+// intent to readers without changing runtime behavior.
+//
+// AST-only baseline. Without a full body walk the rule cannot prove that
+// no other method writes to the field, so the conservative trigger is:
+//
+//   - the member is a PropertyDeclaration sitting in a class body,
+//   - it carries `private` or uses the `#name` private-hash form,
+//   - it does not already carry `readonly`,
+//   - it has a value initializer at declaration time.
+//
+// A property initialized at declaration time gets its value before the
+// constructor runs, and a field that is also reassigned elsewhere
+// usually does not bother to initialize at the declaration site. The
+// pattern is the noisy upstream subset of the rule that is safe to
+// flag without scope analysis.
+// https://typescript-eslint.io/rules/prefer-readonly/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type preferReadonly struct{}
+
+func (preferReadonly) Name() string { return "typescript/prefer-readonly" }
+func (preferReadonly) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindPropertyDeclaration}
+}
+func (preferReadonly) Check(ctx *Context, node *shimast.Node) {
+	// Skip non-class-scoped properties; PropertyDeclaration also appears
+	// inside object literals in some grammars, but the readonly modifier
+	// is a class-only concern.
+	parent := node.Parent
+	if parent == nil ||
+		(parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
+		return
+	}
+	if hasModifier(node, shimast.KindReadonlyKeyword) {
+		return
+	}
+	if !preferReadonlyIsPrivate(node) {
+		return
+	}
+	decl := node.AsPropertyDeclaration()
+	if decl == nil || decl.Initializer == nil {
+		return
+	}
+	// Static fields are still candidates — `private static readonly` is
+	// the canonical form for class-scoped constants.
+	ctx.Report(node, "Private field is only initialized at declaration time — mark it `readonly`.")
+}
+
+// preferReadonlyIsPrivate reports whether the property is private either
+// through the `private` modifier or through the `#name` private-hash
+// identifier form. Both make the field inaccessible from outside the
+// class, so `readonly` is a safe local refinement.
+func preferReadonlyIsPrivate(node *shimast.Node) bool {
+	if hasModifier(node, shimast.KindPrivateKeyword) {
+		return true
+	}
+	if name := node.Name(); name != nil && name.Kind == shimast.KindPrivateIdentifier {
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(preferReadonly{})
+}

package/linthost/rules_ts_prefer_reduce_type_parameter.go

@@ -0,0 +1,116 @@
+// typescript/prefer-reduce-type-parameter: when `arr.reduce(cb, init)`
+// is called with an `as`-asserted initial value, fix the accumulator
+// type at the call site via `arr.reduce<T>(cb, init)` instead. The
+// type-parameter form binds the accumulator before the callback infers
+// its parameter types from the seed, so the callback sees the intended
+// type instead of the seed's widened literal shape. typescript-eslint:
+// https://typescript-eslint.io/rules/prefer-reduce-type-parameter/
+//
+// Type-aware. Without a Checker the rule cannot prove the receiver of
+// `.reduce` is an array or tuple — user types named `reduce` are
+// common (`Map#reduce`, custom accumulators, etc.) and assertion-on-
+// initial-value is occasionally idiomatic there. The receiver must be
+// a provable array or tuple; generics, `any`, `unknown`, and `never`
+// pass through to keep generic helpers quiet.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type preferReduceTypeParameter struct{}
+
+func (preferReduceTypeParameter) Name() string {
+	return "typescript/prefer-reduce-type-parameter"
+}
+func (preferReduceTypeParameter) NeedsTypeChecker() bool {
+	return true
+}
+func (preferReduceTypeParameter) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (preferReduceTypeParameter) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return
+	}
+	// `arr.reduce<T>(...)` already pins the accumulator at the call
+	// site — the rule has nothing left to suggest.
+	if call.TypeArguments != nil && len(call.TypeArguments.Nodes) > 0 {
+		return
+	}
+	// The call must be `<receiver>.reduce(callback, initial)` — the
+	// two-argument form whose seed is the accumulator. The single-
+	// argument `arr.reduce(cb)` shape has no seed to assert against.
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+		return
+	}
+	receiver, method, ok := promisePropertyAccessParts(call.Expression)
+	if !ok || method != "reduce" {
+		return
+	}
+	initial := stripParens(call.Arguments.Nodes[1])
+	if initial == nil {
+		return
+	}
+	// The initial value must carry an explicit type assertion that the
+	// rule can hoist into the call's type parameter list. Both the
+	// canonical `init as T` form and the legacy `<T>init` form qualify.
+	if initial.Kind != shimast.KindAsExpression && initial.Kind != shimast.KindTypeAssertionExpression {
+		return
+	}
+	if receiver == nil {
+		return
+	}
+	t := ctx.Checker.GetTypeAtLocation(receiver)
+	if t == nil {
+		return
+	}
+	if !preferReduceIsArrayOrTuple(ctx.Checker, t) {
+		return
+	}
+	ctx.Report(initial, preferReduceMessage)
+}
+
+const preferReduceMessage = "Pass the accumulator type to `reduce` as a type parameter — `arr.reduce<T>(cb, init)` — instead of asserting on the initial value."
+
+// preferReduceIsArrayOrTuple reports whether t is provably an array or
+// tuple. Mirrors `preferIncludesIsArrayOrString` but excludes strings
+// (which have no `.reduce`). Generics, `any`, `unknown`, and `never`
+// intentionally fail closed so the rule does not blow up on generic
+// helpers whose receiver type leaks downward.
+func preferReduceIsArrayOrTuple(checker *shimchecker.Checker, t *shimchecker.Type) bool {
+	if checker == nil || t == nil {
+		return false
+	}
+	flags := t.Flags()
+	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+		return false
+	}
+	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+		for _, part := range t.Types() {
+			if part == nil {
+				continue
+			}
+			if !preferReduceIsArrayOrTuple(checker, part) {
+				return false
+			}
+		}
+		return true
+	}
+	if shimchecker.Checker_isArrayType(checker, t) {
+		return true
+	}
+	if shimchecker.IsTupleType(t) {
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(preferReduceTypeParameter{})
+}