@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_ts_related_getter_setter_pairs.go

@@ -0,0 +1,113 @@
+// typescript/related-getter-setter-pairs reports a `get` accessor
+// whose declared return type does not match the parameter type of the
+// companion `set` accessor on the same class. The accessor pair
+// presents a single conceptual field at the call site — `obj.value =
+// X` followed by `Y = obj.value` should round-trip with compatible
+// types — but TypeScript otherwise lets the two accessors carry
+// independent annotations. The rule fires when the writer cannot
+// accept what the reader is about to surface.
+// https://typescript-eslint.io/rules/related-getter-setter-pairs/
+//
+// Type-aware. The comparison resolves both sides through
+// `GetTypeFromTypeNode` so type aliases, generic parameters, and union
+// constituents collapse to the same set of values before the
+// equality check. Without a Checker the rule short-circuits to a
+// no-op the way the other type-aware rules do.
+//
+// The rule visits each `KindGetAccessor`. For every getter that
+// carries a return-type annotation and lives inside a class
+// declaration / expression, it locates the matching `set` accessor by
+// name (using the same `classMembers` + `classMemberName` helpers as
+// `class-literal-property-style`) and compares the annotated types
+// bidirectionally — both sides must describe the same set of values
+// for the accessor pair to round-trip safely.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type relatedGetterSetterPairs struct{}
+
+func (relatedGetterSetterPairs) Name() string {
+	return "typescript/related-getter-setter-pairs"
+}
+func (relatedGetterSetterPairs) NeedsTypeChecker() bool { return true }
+func (relatedGetterSetterPairs) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindGetAccessor}
+}
+func (relatedGetterSetterPairs) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	parent := node.Parent
+	if parent == nil ||
+		(parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
+		return
+	}
+	getReturnType := node.Type()
+	if getReturnType == nil {
+		// No annotated return type — nothing to compare against.
+		return
+	}
+	name := classMemberName(node)
+	if name == "" {
+		return
+	}
+	setter := findClassSetterFor(parent, name)
+	if setter == nil {
+		return
+	}
+	setParamType := setterParameterType(setter)
+	if setParamType == nil {
+		return
+	}
+	getType := ctx.Checker.GetTypeFromTypeNode(getReturnType)
+	setType := ctx.Checker.GetTypeFromTypeNode(setParamType)
+	if getType == nil || setType == nil {
+		return
+	}
+	// Bidirectional assignability stands in for type identity — the
+	// same shape `no-unnecessary-type-assertion` uses. The accessor
+	// pair is safe only when reading and writing describe the same
+	// set of values.
+	if ctx.Checker.IsTypeAssignableTo(getType, setType) &&
+		ctx.Checker.IsTypeAssignableTo(setType, getType) {
+		return
+	}
+	ctx.Report(node, "Getter return type does not match the corresponding setter parameter type on `"+name+"`.")
+}
+
+// findClassSetterFor returns the `set` accessor declared on `class`
+// whose name matches `name`, or nil when no such setter exists.
+func findClassSetterFor(class *shimast.Node, name string) *shimast.Node {
+	for _, member := range classMembers(class) {
+		if member == nil || member.Kind != shimast.KindSetAccessor {
+			continue
+		}
+		if classMemberName(member) == name {
+			return member
+		}
+	}
+	return nil
+}
+
+// setterParameterType returns the type-annotation node of a `set`
+// accessor's single parameter. A setter without a parameter, or with a
+// parameter that carries no annotation, returns nil — the rule cannot
+// compare against an inferred type.
+func setterParameterType(setter *shimast.Node) *shimast.Node {
+	params := setter.Parameters()
+	if len(params) == 0 {
+		return nil
+	}
+	decl := params[0].AsParameterDeclaration()
+	if decl == nil {
+		return nil
+	}
+	return decl.Type
+}
+
+func init() {
+	Register(relatedGetterSetterPairs{})
+}

package/linthost/rules_ts_require_array_sort_compare.go

@@ -0,0 +1,96 @@
+// typescript/require-array-sort-compare: require an explicit comparator
+// for `arr.sort()` and `arr.toSorted()`. Without a comparator, both
+// methods coerce elements to strings before ordering them, so
+// `[10, 2, 1].sort()` evaluates to `[1, 10, 2]` — almost never what the
+// caller meant. The fix is to pass `(a, b) => a - b`-style comparator.
+// typescript-eslint:
+// https://typescript-eslint.io/rules/require-array-sort-compare/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// requireArraySortCompare reports `<arr>.sort()` and `<arr>.toSorted()`
+// when no comparator argument is supplied. Type-aware: the Checker
+// confirms the receiver is an array (or tuple) so user-defined methods
+// named `sort` / `toSorted` on non-array types do not trip the rule.
+type requireArraySortCompare struct{}
+
+func (requireArraySortCompare) Name() string {
+	return "typescript/require-array-sort-compare"
+}
+func (requireArraySortCompare) NeedsTypeChecker() bool {
+	return true
+}
+func (requireArraySortCompare) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (requireArraySortCompare) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return
+	}
+	// Only fire when the callee is a property access ending in `.sort`
+	// or `.toSorted` and the call passes zero arguments.
+	receiver, method, ok := promisePropertyAccessParts(call.Expression)
+	if !ok || (method != "sort" && method != "toSorted") {
+		return
+	}
+	if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+		return
+	}
+	if receiver == nil {
+		return
+	}
+	t := ctx.Checker.GetTypeAtLocation(receiver)
+	if t == nil {
+		return
+	}
+	if !requireArraySortCompareIsArrayLike(ctx.Checker, t) {
+		return
+	}
+	ctx.Report(node, "Require an explicit compareFunction for `."+method+"()` — without one, elements are coerced to strings before being ordered.")
+}
+
+// requireArraySortCompareIsArrayLike reports whether t is provably an
+// array or a tuple. The check follows the same recurse-into-constituents
+// pattern as `isAwaitable` so a union like `number[] | string[]` still
+// resolves to "array" via every constituent. `any` / `unknown` / `never`
+// are intentionally NOT treated as array-like — they propagate from
+// generic helpers and would explode the false-positive volume.
+func requireArraySortCompareIsArrayLike(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 !requireArraySortCompareIsArrayLike(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(requireArraySortCompare{})
+}

package/linthost/rules_ts_restrict_plus_operands.go

@@ -0,0 +1,127 @@
+// typescript/restrict-plus-operands: the `+` operator is overloaded in
+// JavaScript — it numerically adds two numbers, lexically concatenates
+// two strings, and silently coerces every other combination. `1 + "a"`
+// becomes `"1a"`, `null + 5` becomes `5`, `{} + 1` becomes `"[object
+// Object]1"`. Each of these is almost always a bug: the author meant
+// either numeric addition or explicit string concatenation, not the
+// runtime's lossy fallback. typescript-eslint:
+// https://typescript-eslint.io/rules/restrict-plus-operands/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// restrictPlusOperands fires on `<lhs> + <rhs>` when the operands are
+// not both number-like, both string-like, or both bigint-like. The
+// rule is type-aware: without a Checker it cannot prove the operand
+// kinds, so it bails out to avoid false positives on plain JS or on
+// files that opt out of typechecking. `any` / `unknown` / `never`
+// operands are treated as unrestricted to keep false positives off
+// generic helpers; the upstream rule does the same.
+type restrictPlusOperands struct{}
+
+func (restrictPlusOperands) Name() string { return "typescript/restrict-plus-operands" }
+func (restrictPlusOperands) NeedsTypeChecker() bool {
+	return true
+}
+func (restrictPlusOperands) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (restrictPlusOperands) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	expr := node.AsBinaryExpression()
+	if expr == nil || expr.OperatorToken == nil {
+		return
+	}
+	if expr.OperatorToken.Kind != shimast.KindPlusToken {
+		return
+	}
+	if expr.Left == nil || expr.Right == nil {
+		return
+	}
+	left := ctx.Checker.GetTypeAtLocation(expr.Left)
+	right := ctx.Checker.GetTypeAtLocation(expr.Right)
+	if left == nil || right == nil {
+		return
+	}
+	leftKind := restrictPlusOperandsKind(left)
+	rightKind := restrictPlusOperandsKind(right)
+	// Skip when either side is unconstrained (any / unknown / never /
+	// generic) — the rule would otherwise fire on every generic helper
+	// that accepts `T extends number | string`.
+	if leftKind == restrictPlusOperandsAny || rightKind == restrictPlusOperandsAny {
+		return
+	}
+	if leftKind == rightKind && leftKind != restrictPlusOperandsOther {
+		return
+	}
+	ctx.Report(node, "Operands of `+` must both be `number`, both `string`, or both `bigint`. Mixed or non-primitive operands are silently coerced by the runtime and almost always a bug.")
+}
+
+// restrictPlusOperandsKind classifies t as one of the four buckets the
+// rule cares about. A union is accepted only when every constituent
+// lands in the same primitive bucket — `string | number` is
+// deliberately rejected because each branch would coerce the other
+// side differently at runtime.
+type restrictPlusOperandsBucket int
+
+const (
+	restrictPlusOperandsOther restrictPlusOperandsBucket = iota
+	restrictPlusOperandsAny
+	restrictPlusOperandsNumber
+	restrictPlusOperandsString
+	restrictPlusOperandsBigInt
+)
+
+func restrictPlusOperandsKind(t *shimchecker.Type) restrictPlusOperandsBucket {
+	if t == nil {
+		return restrictPlusOperandsOther
+	}
+	flags := t.Flags()
+	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+		return restrictPlusOperandsAny
+	}
+	if flags&shimchecker.TypeFlagsStringLike != 0 {
+		return restrictPlusOperandsString
+	}
+	if flags&shimchecker.TypeFlagsNumberLike != 0 {
+		return restrictPlusOperandsNumber
+	}
+	if flags&shimchecker.TypeFlagsBigIntLike != 0 {
+		return restrictPlusOperandsBigInt
+	}
+	if flags&shimchecker.TypeFlagsUnion != 0 {
+		var seen restrictPlusOperandsBucket
+		for _, part := range t.Types() {
+			if part == nil {
+				continue
+			}
+			kind := restrictPlusOperandsKind(part)
+			if kind == restrictPlusOperandsAny {
+				return restrictPlusOperandsAny
+			}
+			if kind == restrictPlusOperandsOther {
+				return restrictPlusOperandsOther
+			}
+			if seen == 0 {
+				seen = kind
+				continue
+			}
+			if seen != kind {
+				return restrictPlusOperandsOther
+			}
+		}
+		if seen != 0 {
+			return seen
+		}
+	}
+	return restrictPlusOperandsOther
+}
+
+func init() {
+	Register(restrictPlusOperands{})
+}

package/linthost/rules_ts_restrict_template_expressions.go

@@ -0,0 +1,95 @@
+// typescript/restrict-template-expressions: every interpolation inside a
+// template literal coerces its value through `String()` at runtime, so
+// non-string-friendly types silently render as `"[object Object]"`,
+// `"null"`, or `"undefined"`. The rule requires each embedded expression
+// to be statically known as `string`, `number`, `bigint`, `boolean`, or
+// a union of those — anything else (object types, `null`, `undefined`,
+// `void`) must be converted explicitly at the call site.
+// typescript-eslint:
+// https://typescript-eslint.io/rules/restrict-template-expressions/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// restrictTemplateExpressions reports each `${expr}` span inside a
+// template literal whose expression has a non-stringy static type.
+// Type-aware: without a Checker the rule cannot tell `string | number`
+// apart from `string | null`, so it bails — the AST alone never has
+// enough information to decide this case.
+//
+// `any` / `unknown` / `never` pass through on purpose. They propagate
+// from generic helpers and a strict rejection would explode the
+// false-positive volume; the upstream rule makes the same choice
+// behind its `allowAny` / `allowNever` options, which default to true.
+type restrictTemplateExpressions struct{}
+
+func (restrictTemplateExpressions) Name() string {
+	return "typescript/restrict-template-expressions"
+}
+func (restrictTemplateExpressions) NeedsTypeChecker() bool {
+	return true
+}
+func (restrictTemplateExpressions) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindTemplateExpression}
+}
+func (restrictTemplateExpressions) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	expr := node.AsTemplateExpression()
+	if expr == nil || expr.TemplateSpans == nil {
+		return
+	}
+	for _, spanNode := range expr.TemplateSpans.Nodes {
+		span := spanNode.AsTemplateSpan()
+		if span == nil || span.Expression == nil {
+			continue
+		}
+		t := ctx.Checker.GetTypeAtLocation(span.Expression)
+		if t == nil {
+			continue
+		}
+		if restrictTemplateExpressionsIsStringy(ctx.Checker, t) {
+			continue
+		}
+		ctx.Report(span.Expression, "Template interpolations must be string-like (`string`, `number`, `bigint`, or `boolean`) — convert the value explicitly to avoid coercing to `\"[object Object]\"`, `\"null\"`, or `\"undefined\"`.")
+	}
+}
+
+// restrictTemplateExpressionsIsStringy reports whether t is safe to
+// drop into a template-literal slot — string / number / bigint /
+// boolean, or a union/intersection whose every constituent is.
+// `any` / `unknown` / `never` pass through (return true) so generic
+// helpers propagate without lighting up the rule everywhere.
+func restrictTemplateExpressionsIsStringy(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 true
+	}
+	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+		for _, part := range t.Types() {
+			if part == nil {
+				continue
+			}
+			if !restrictTemplateExpressionsIsStringy(checker, part) {
+				return false
+			}
+		}
+		return true
+	}
+	const stringyMask = shimchecker.TypeFlagsStringLike |
+		shimchecker.TypeFlagsNumberLike |
+		shimchecker.TypeFlagsBigIntLike |
+		shimchecker.TypeFlagsBooleanLike
+	return flags&stringyMask != 0
+}
+
+func init() {
+	Register(restrictTemplateExpressions{})
+}