@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_ts_no_useless_constructor.go

@@ -0,0 +1,52 @@
+// typescript/no-useless-constructor: TS-aware extension of the core
+// `no-useless-constructor` rule. A class constructor with an empty body
+// and no parameter properties is noise — the engine generates the same
+// default constructor anyway.
+//
+// The TS variant differs from the core rule in one detail: a
+// parameter-property declaration (`constructor(public foo: number) {}`)
+// carries a semantic side effect — it implicitly declares the class
+// field and assigns the argument to it. Removing the constructor would
+// remove the field. So an otherwise-empty body is NOT useless when at
+// least one parameter is a parameter property.
+// typescript-eslint strict:
+// https://typescript-eslint.io/rules/no-useless-constructor/
+//
+// AST-only. The trigger is a `KindConstructor` whose body is an empty
+// block and whose parameter list contains no `public` / `private` /
+// `protected` / `readonly` / `override` parameter property.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type tsNoUselessConstructor struct{}
+
+func (tsNoUselessConstructor) Name() string { return "typescript/no-useless-constructor" }
+func (tsNoUselessConstructor) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindConstructor}
+}
+func (tsNoUselessConstructor) Check(ctx *Context, node *shimast.Node) {
+	ctor := node.AsConstructorDeclaration()
+	if ctor == nil || ctor.Body == nil {
+		return
+	}
+	body := ctor.Body.AsBlock()
+	if body == nil || body.Statements == nil || len(body.Statements.Nodes) != 0 {
+		return
+	}
+	// Any parameter property keeps the constructor meaningful: the
+	// shorthand IS the field declaration. Removing the constructor
+	// would silently delete the field, so this is not "useless".
+	for _, param := range node.Parameters() {
+		if isParameterProperty(param) {
+			return
+		}
+	}
+	ctx.Report(node, "Useless constructor with no parameter properties.")
+}
+
+func init() {
+	Register(tsNoUselessConstructor{})
+}

package/linthost/rules_ts_non_nullable_type_assertion_style.go

@@ -0,0 +1,108 @@
+// typescript/non-nullable-type-assertion-style: when `x as T` strips
+// exactly the `null`/`undefined` constituents from the static type of
+// `x`, the assertion is equivalent to the non-null assertion `x!`. The
+// `!` form is shorter and communicates "I am asserting non-null"
+// explicitly, while `as T` may be read as "I am narrowing to a
+// different type". typescript-eslint stylistic-type-checked:
+// https://typescript-eslint.io/rules/non-nullable-type-assertion-style/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// nonNullableTypeAssertionStyle reports `expr as T` where `T` equals the
+// non-nullable version of `expr`'s static type. Implementation notes:
+//
+//   - Type-aware: requires the Checker to compute the non-nullable form
+//     of the source expression and to compare it against the asserted
+//     type. The shim re-exports the unexported `GetNonNullableType` and
+//     `GetTypeFromTypeNode` methods directly.
+//   - Symmetric assignability is used instead of literal type identity
+//     because the Checker may widen literal types differently between
+//     the two sides (e.g. the source `string | undefined` becomes
+//     `string` after non-null stripping, and the asserted node `string`
+//     resolves to the same primitive — both directions of assignability
+//     hold and identity is unnecessary).
+//   - The rule only fires when the source type was actually nullable;
+//     `42 as number` is left alone because removing nothing from
+//     `number` still yields `number` and the assertion is not
+//     equivalent to `42!` (which would be a syntax error on a literal).
+type nonNullableTypeAssertionStyle struct{}
+
+func (nonNullableTypeAssertionStyle) Name() string {
+	return "typescript/non-nullable-type-assertion-style"
+}
+func (nonNullableTypeAssertionStyle) NeedsTypeChecker() bool {
+	return true
+}
+func (nonNullableTypeAssertionStyle) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindAsExpression}
+}
+func (nonNullableTypeAssertionStyle) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	as := node.AsAsExpression()
+	if as == nil || as.Expression == nil || as.Type == nil {
+		return
+	}
+	sourceType := ctx.Checker.GetTypeAtLocation(as.Expression)
+	if sourceType == nil {
+		return
+	}
+	// Only consider expressions whose static type actually carries
+	// `null` or `undefined`; otherwise `x!` is not the same as `x as T`.
+	if !nonNullableTypeAssertionStyleIsNullable(sourceType) {
+		return
+	}
+	nonNullable := ctx.Checker.GetNonNullableType(sourceType)
+	if nonNullable == nil {
+		return
+	}
+	assertedType := ctx.Checker.GetTypeFromTypeNode(as.Type)
+	if assertedType == nil {
+		return
+	}
+	// Bidirectional assignability stands in for type identity: the
+	// stripped source type must coincide with the asserted type up to
+	// structural equivalence. Both sides have to hold so that
+	// `x as SomeSupertype` or `x as SomeSubtype` does not get rewritten
+	// to `x!` and silently lose information.
+	if !ctx.Checker.IsTypeAssignableTo(nonNullable, assertedType) {
+		return
+	}
+	if !ctx.Checker.IsTypeAssignableTo(assertedType, nonNullable) {
+		return
+	}
+	ctx.Report(node, "Use a `!` assertion to more succinctly remove `null` and `undefined` from the type.")
+}
+
+// nonNullableTypeAssertionStyleIsNullable reports whether t carries
+// `null` or `undefined` either at the top level (for direct
+// `T | null` / `T | undefined` shapes) or inside a union constituent.
+func nonNullableTypeAssertionStyleIsNullable(t *shimchecker.Type) bool {
+	if t == nil {
+		return false
+	}
+	flags := t.Flags()
+	if flags&(shimchecker.TypeFlagsNull|shimchecker.TypeFlagsUndefined) != 0 {
+		return true
+	}
+	if flags&shimchecker.TypeFlagsUnion != 0 {
+		for _, part := range t.Types() {
+			if part == nil {
+				continue
+			}
+			if nonNullableTypeAssertionStyleIsNullable(part) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func init() {
+	Register(nonNullableTypeAssertionStyle{})
+}

package/linthost/rules_ts_parameter_properties.go

@@ -0,0 +1,38 @@
+// typescript/parameter-properties reports TypeScript parameter
+// properties — constructor parameters prefixed with `public`,
+// `private`, `protected`, `readonly`, or `override` that implicitly
+// declare a class field. The rule's default policy
+// (`prefer: "class-property"`) flags the shorthand so the class
+// member list stays the single source of truth for the class shape;
+// fields buried in the constructor signature are easy to miss.
+// https://typescript-eslint.io/rules/parameter-properties/
+//
+// AST-only — the trigger is a syntactic modifier on a `KindParameter`
+// whose parent is a `KindConstructor`. The shared `isParameterProperty`
+// helper (also used by `no-unnecessary-parameter-property-assignment`)
+// is the single decoding point for the modifier set.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type parameterProperties struct{}
+
+func (parameterProperties) Name() string { return "typescript/parameter-properties" }
+func (parameterProperties) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindParameter}
+}
+func (parameterProperties) Check(ctx *Context, node *shimast.Node) {
+	if node == nil || node.Parent == nil || node.Parent.Kind != shimast.KindConstructor {
+		return
+	}
+	if !isParameterProperty(node) {
+		return
+	}
+	ctx.Report(node, "Prefer a plain class field declaration over a constructor parameter property.")
+}
+
+func init() {
+	Register(parameterProperties{})
+}

package/linthost/rules_ts_prefer_find.go

@@ -0,0 +1,178 @@
+// typescript/prefer-find: prefer `arr.find(predicate)` over the
+// `arr.filter(predicate)[0]` and `arr.filter(predicate).at(0)` shapes.
+// `find` short-circuits on the first match instead of materializing the
+// whole filtered array, so for sufficiently large inputs it is strictly
+// faster — and at every input size it expresses the intent ("get me
+// the first match") more directly than reading the head of a filtered
+// list. typescript-eslint:
+// https://typescript-eslint.io/rules/prefer-find/
+//
+// Type-aware. Without a Checker the rule cannot prove the receiver of
+// `filter` is array-like, so Context.Checker == nil short-circuits each
+// Check to a no-op the way `no-for-in-array` and `prefer-includes` do.
+// The receiver type must be a provable array or tuple — generic, `any`,
+// `unknown`, and `never` pass through so generic helpers don't explode
+// with false positives on user-defined `filter` methods.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type preferFind struct{}
+
+func (preferFind) Name() string { return "typescript/prefer-find" }
+func (preferFind) NeedsTypeChecker() bool {
+	return true
+}
+func (preferFind) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindElementAccessExpression,
+		shimast.KindCallExpression,
+	}
+}
+func (preferFind) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	switch node.Kind {
+	case shimast.KindElementAccessExpression:
+		access := node.AsElementAccessExpression()
+		if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
+			return
+		}
+		// Index must be the literal `0`.
+		if !preferFindIsZeroLiteral(access.ArgumentExpression) {
+			return
+		}
+		if !preferFindIsArrayFilterCall(ctx, access.Expression) {
+			return
+		}
+		ctx.Report(node, preferFindMessage)
+	case shimast.KindCallExpression:
+		call := node.AsCallExpression()
+		if call == nil || call.Expression == nil {
+			return
+		}
+		// Match `<filter-call>.at(0)`.
+		receiver, method, ok := promisePropertyAccessParts(call.Expression)
+		if !ok || method != "at" {
+			return
+		}
+		if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+			return
+		}
+		if !preferFindIsZeroLiteral(call.Arguments.Nodes[0]) {
+			return
+		}
+		if !preferFindIsArrayFilterCall(ctx, receiver) {
+			return
+		}
+		ctx.Report(node, preferFindMessage)
+	}
+}
+
+const preferFindMessage = "Prefer `.find(predicate)` over `.filter(predicate)[0]` / `.filter(predicate).at(0)` — `find` short-circuits on the first match and avoids materializing the full filtered array."
+
+// preferFindIsZeroLiteral reports whether `node` (after stripping
+// parens) is the numeric literal `0` — the only index `find` can
+// replace. `+0` and `0` are both accepted; `-0` is rejected because it
+// is technically a separate value at the language level even though
+// `arr[-0]` resolves the same. Keeps the rule's noise floor narrow.
+func preferFindIsZeroLiteral(node *shimast.Node) bool {
+	node = stripParens(node)
+	if node == nil {
+		return false
+	}
+	if node.Kind == shimast.KindNumericLiteral {
+		return numericLiteralText(node) == "0"
+	}
+	if node.Kind == shimast.KindPrefixUnaryExpression {
+		prefix := node.AsPrefixUnaryExpression()
+		if prefix == nil || prefix.Operand == nil {
+			return false
+		}
+		if prefix.Operator != shimast.KindPlusToken {
+			return false
+		}
+		return prefix.Operand.Kind == shimast.KindNumericLiteral &&
+			numericLiteralText(prefix.Operand) == "0"
+	}
+	return false
+}
+
+// preferFindIsArrayFilterCall reports whether `node` (after stripping
+// parens) is a `<receiver>.filter(predicate)` CallExpression whose
+// receiver type is provably an array or tuple. Mirrors the shape used
+// by `prefer-includes` for `.indexOf(x)`: a user type with a custom
+// `filter` method should NOT trigger the rule.
+func preferFindIsArrayFilterCall(ctx *Context, node *shimast.Node) bool {
+	node = stripParens(node)
+	if node == nil || node.Kind != shimast.KindCallExpression {
+		return false
+	}
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return false
+	}
+	receiver, method, ok := promisePropertyAccessParts(call.Expression)
+	if !ok || method != "filter" {
+		return false
+	}
+	if receiver == nil {
+		return false
+	}
+	// `.filter` accepts an optional `thisArg`, so require at least one
+	// argument (the predicate) — a zero-arg call would not parse on the
+	// real lib.es5 declaration and is conservatively skipped.
+	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+		return false
+	}
+	t := ctx.Checker.GetTypeAtLocation(receiver)
+	if t == nil {
+		return false
+	}
+	return preferFindIsArrayLike(ctx.Checker, t)
+}
+
+// preferFindIsArrayLike reports whether t is provably an array or
+// tuple. The constituent-recursion shape mirrors
+// `preferIncludesIsArrayOrString`: a union like `T[] | T[]` is still
+// accepted because every constituent is rewritable. `any` / `unknown` /
+// `never` are intentionally NOT treated as matching — they leak from
+// generic helpers and would explode the false-positive volume on
+// user-defined `filter` methods. Strings are NOT included here even
+// though they expose a `.filter`-shaped method via lib polyfills,
+// because the upstream rule only fires on the genuine `Array#filter`.
+func preferFindIsArrayLike(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 !preferFindIsArrayLike(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(preferFind{})
+}

package/linthost/rules_ts_prefer_includes.go

@@ -0,0 +1,255 @@
+// typescript/prefer-includes: prefer `array.includes(x)` over the
+// `array.indexOf(x) !== -1` (and the related `=== -1`, `>= 0`, `< 0`,
+// `> -1`) idioms. The `includes` form states the intent directly —
+// "does the collection contain this value?" — and avoids the
+// sentinel-vs-position confusion that comes with comparing an
+// `indexOf` return value against `-1`. typescript-eslint:
+// https://typescript-eslint.io/rules/prefer-includes/
+//
+// Type-aware. Without a Checker the rule cannot prove the receiver of
+// `indexOf` is array-like or string-like, so Context.Checker == nil
+// short-circuits each Check to a no-op the way `no-for-in-array` and
+// `require-array-sort-compare` do. The receiver type must be a
+// provable array, tuple, or string — generic, `any`, `unknown`, and
+// `never` pass through so generic helpers don't explode with false
+// positives.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type preferIncludes struct{}
+
+func (preferIncludes) Name() string { return "typescript/prefer-includes" }
+func (preferIncludes) NeedsTypeChecker() bool {
+	return true
+}
+func (preferIncludes) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (preferIncludes) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	bin := node.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil {
+		return
+	}
+	// One side of the comparison must be a `.indexOf(...)` call; the
+	// other side must be a numeric sentinel (-1 or 0) and the operator
+	// chosen so the boolean meaning is "is the value present".
+	if !preferIncludesIsTargetedComparison(bin.OperatorToken.Kind) {
+		return
+	}
+	if preferIncludesCheckSide(ctx, bin.Left, bin.Right, bin.OperatorToken.Kind, false) {
+		ctx.Report(node, preferIncludesMessage)
+		return
+	}
+	if preferIncludesCheckSide(ctx, bin.Right, bin.Left, bin.OperatorToken.Kind, true) {
+		ctx.Report(node, preferIncludesMessage)
+	}
+}
+
+const preferIncludesMessage = "Prefer `.includes(x)` over `.indexOf(x)` compared against `-1` / `0` — `.includes` states the containment intent directly."
+
+// preferIncludesIsTargetedComparison reports whether the operator is
+// one of the equality / ordering tokens the rule cares about. The
+// rule fires on `===`, `!==`, `==`, `!=`, `<`, `<=`, `>`, `>=`; other
+// operators leave the binary alone.
+func preferIncludesIsTargetedComparison(kind shimast.Kind) bool {
+	switch kind {
+	case shimast.KindEqualsEqualsToken,
+		shimast.KindEqualsEqualsEqualsToken,
+		shimast.KindExclamationEqualsToken,
+		shimast.KindExclamationEqualsEqualsToken,
+		shimast.KindLessThanToken,
+		shimast.KindLessThanEqualsToken,
+		shimast.KindGreaterThanToken,
+		shimast.KindGreaterThanEqualsToken:
+		return true
+	}
+	return false
+}
+
+// preferIncludesCheckSide reports whether `call` is the
+// `<receiver>.indexOf(arg)` call and `sentinel` is the numeric
+// constant the comparison is paired with. `reversed` flips the
+// direction of ordering operators so `arr.indexOf(x) > -1` and
+// `-1 < arr.indexOf(x)` both match.
+func preferIncludesCheckSide(
+	ctx *Context,
+	call, sentinel *shimast.Node,
+	op shimast.Kind,
+	reversed bool,
+) bool {
+	call = stripParens(call)
+	sentinel = stripParens(sentinel)
+	if call == nil || sentinel == nil {
+		return false
+	}
+	if call.Kind != shimast.KindCallExpression {
+		return false
+	}
+	callExpr := call.AsCallExpression()
+	if callExpr == nil || callExpr.Expression == nil {
+		return false
+	}
+	receiver, method, ok := promisePropertyAccessParts(callExpr.Expression)
+	if !ok || method != "indexOf" {
+		return false
+	}
+	if callExpr.Arguments == nil || len(callExpr.Arguments.Nodes) != 1 {
+		return false
+	}
+	value, ok := preferIncludesSentinelValue(sentinel)
+	if !ok {
+		return false
+	}
+	effectiveOp := op
+	if reversed {
+		effectiveOp = preferIncludesFlipOperator(op)
+	}
+	if !preferIncludesIsPresenceComparison(effectiveOp, value) {
+		return false
+	}
+	if receiver == nil {
+		return false
+	}
+	t := ctx.Checker.GetTypeAtLocation(receiver)
+	if t == nil {
+		return false
+	}
+	return preferIncludesIsArrayOrString(ctx.Checker, t)
+}
+
+// preferIncludesSentinelValue returns the numeric sentinel encoded by
+// `node`, recognizing the literals `-1`, `0`, and `1` (the only
+// constants the rule's shapes reduce to). Returns ok=false for any
+// other expression.
+func preferIncludesSentinelValue(node *shimast.Node) (int, bool) {
+	if node == nil {
+		return 0, false
+	}
+	if node.Kind == shimast.KindNumericLiteral {
+		switch numericLiteralText(node) {
+		case "0":
+			return 0, true
+		case "1":
+			return 1, true
+		}
+		return 0, false
+	}
+	if node.Kind != shimast.KindPrefixUnaryExpression {
+		return 0, false
+	}
+	prefix := node.AsPrefixUnaryExpression()
+	if prefix == nil || prefix.Operand == nil {
+		return 0, false
+	}
+	if prefix.Operand.Kind != shimast.KindNumericLiteral {
+		return 0, false
+	}
+	text := numericLiteralText(prefix.Operand)
+	switch prefix.Operator {
+	case shimast.KindMinusToken:
+		if text == "1" {
+			return -1, true
+		}
+		if text == "0" {
+			return 0, true
+		}
+	case shimast.KindPlusToken:
+		if text == "0" {
+			return 0, true
+		}
+		if text == "1" {
+			return 1, true
+		}
+	}
+	return 0, false
+}
+
+// preferIncludesFlipOperator returns the operator that has the same
+// boolean meaning when the operands are swapped. `a < b` flipped is
+// `b > a`, `a >= b` flipped is `b <= a`, and equality operators are
+// symmetric so they are returned unchanged.
+func preferIncludesFlipOperator(kind shimast.Kind) shimast.Kind {
+	switch kind {
+	case shimast.KindLessThanToken:
+		return shimast.KindGreaterThanToken
+	case shimast.KindLessThanEqualsToken:
+		return shimast.KindGreaterThanEqualsToken
+	case shimast.KindGreaterThanToken:
+		return shimast.KindLessThanToken
+	case shimast.KindGreaterThanEqualsToken:
+		return shimast.KindLessThanEqualsToken
+	}
+	return kind
+}
+
+// preferIncludesIsPresenceComparison reports whether `op` paired with
+// `value` is one of the equivalences for "the element is present":
+// `!= -1`, `>= 0`, `> -1` mean "present"; `== -1`, `< 0`, `<= -1`
+// mean "absent". Either polarity is rewritable to `includes(x)` (the
+// "absent" cases negate the call), so both pass.
+func preferIncludesIsPresenceComparison(op shimast.Kind, value int) bool {
+	switch op {
+	case shimast.KindExclamationEqualsToken, shimast.KindExclamationEqualsEqualsToken:
+		return value == -1
+	case shimast.KindEqualsEqualsToken, shimast.KindEqualsEqualsEqualsToken:
+		return value == -1
+	case shimast.KindGreaterThanEqualsToken:
+		return value == 0
+	case shimast.KindGreaterThanToken:
+		return value == -1
+	case shimast.KindLessThanToken:
+		return value == 0
+	case shimast.KindLessThanEqualsToken:
+		return value == -1
+	}
+	return false
+}
+
+// preferIncludesIsArrayOrString reports whether t is provably an
+// array, tuple, or string. The constituent-recursion shape mirrors
+// `requireArraySortCompareIsArrayLike`: a union like `string[] |
+// string` is still accepted because every constituent is rewritable.
+// `any` / `unknown` / `never` are intentionally NOT treated as
+// matching — they leak from generic helpers and would explode the
+// false-positive volume on user-defined `indexOf` methods.
+func preferIncludesIsArrayOrString(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.TypeFlagsStringLike != 0 {
+		return true
+	}
+	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+		for _, part := range t.Types() {
+			if part == nil {
+				continue
+			}
+			if !preferIncludesIsArrayOrString(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(preferIncludes{})
+}