@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_ts_simple.go

@@ -0,0 +1,387 @@
+// Additional AST-only `typescript/*` rules from
+// typescript-eslint. Each rule is a small pattern match — no Checker,
+// no scope analysis — and corresponds 1:1 with the upstream rule of
+// the same name.
+//
+// Implemented here:
+//   - typescript/no-array-for-each
+//   - typescript/no-extraneous-class
+//   - typescript/no-invalid-void-type
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// noArrayForEach reports `arr.forEach(...)` calls and suggests
+// `for ... of` instead. The for-of form supports early termination
+// (`break`/`return`) and `await`, while `forEach` swallows both. The
+// rule does not confirm that the receiver is actually an array — the
+// syntactic shape is the signal, matching the upstream rule's behavior.
+// https://typescript-eslint.io/rules/no-array-for-each/
+type noArrayForEach struct{}
+
+func (noArrayForEach) Name() string { return "typescript/no-array-for-each" }
+func (noArrayForEach) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (noArrayForEach) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return
+	}
+	_, method, ok := promisePropertyAccessParts(call.Expression)
+	if !ok || method != "forEach" {
+		return
+	}
+	ctx.Report(node, "Prefer `for ... of` over `Array.forEach()` — `forEach` does not support `await` or `break`.")
+}
+
+// noExtraneousClass reports class declarations that exist purely as a
+// namespace for static members or are entirely empty. A namespace
+// import or a plain function is almost always clearer than `class Util
+// { static foo() { … } }`, and the class adds a layer of indirection
+// without providing any instance behavior.
+// https://typescript-eslint.io/rules/no-extraneous-class/
+//
+// Trigger:
+//   - the class has no `extends` heritage,
+//   - no constructor with a non-empty body, and
+//   - every member is `static` (or the class has no members at all).
+type noExtraneousClass struct{}
+
+func (noExtraneousClass) Name() string { return "typescript/no-extraneous-class" }
+func (noExtraneousClass) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
+}
+func (noExtraneousClass) Check(ctx *Context, node *shimast.Node) {
+	if classExtendsAnother(node) {
+		return
+	}
+	if classImplementsAnInterface(node) {
+		return
+	}
+	members := classMembers(node)
+	if len(members) == 0 {
+		ctx.Report(node, "Empty class — prefer a plain function or namespace.")
+		return
+	}
+	hasInstanceMember := false
+	hasNonTrivialConstructor := false
+	for _, member := range members {
+		if member == nil {
+			continue
+		}
+		if member.Kind == shimast.KindConstructor {
+			ctor := member.AsConstructorDeclaration()
+			if ctor != nil && ctor.Body != nil && len(ctor.Body.Statements()) > 0 {
+				hasNonTrivialConstructor = true
+			}
+			continue
+		}
+		if !hasModifier(member, shimast.KindStaticKeyword) {
+			hasInstanceMember = true
+			break
+		}
+	}
+	if !hasInstanceMember && !hasNonTrivialConstructor {
+		ctx.Report(node, "Class only declares static members — prefer a namespace or top-level functions.")
+	}
+}
+
+// classImplementsAnInterface reports whether the class has an
+// `implements …` heritage clause. Classes that implement an interface
+// are intentionally polymorphic at runtime, so noExtraneousClass
+// should not fire on them.
+func classImplementsAnInterface(class *shimast.Node) bool {
+	var clauses []*shimast.Node
+	switch class.Kind {
+	case shimast.KindClassDeclaration:
+		decl := class.AsClassDeclaration()
+		if decl == nil || decl.HeritageClauses == nil {
+			return false
+		}
+		clauses = decl.HeritageClauses.Nodes
+	case shimast.KindClassExpression:
+		expr := class.AsClassExpression()
+		if expr == nil || expr.HeritageClauses == nil {
+			return false
+		}
+		clauses = expr.HeritageClauses.Nodes
+	default:
+		return false
+	}
+	for _, clause := range clauses {
+		if clause == nil {
+			continue
+		}
+		hc := clause.AsHeritageClause()
+		if hc == nil || hc.Token != shimast.KindImplementsKeyword {
+			continue
+		}
+		if hc.Types != nil && len(hc.Types.Nodes) > 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// noInvalidVoidType reports a `void` type used as a union constituent
+// or as a generic-type argument. `void` is meaningful only as the sole
+// return type of a function — `void | string` and `Promise<void>` are
+// fine, but `string | void` is almost always a confusion with
+// `undefined`.
+// https://typescript-eslint.io/rules/no-invalid-void-type/
+//
+// Allowed positions:
+//   - the return type annotation of a function-like (Function/Method/
+//     Arrow/Constructor/CallSignature/MethodSignature/FunctionType);
+//   - inside `Promise<void>`, `Generator<void, …, …>`, etc. — these
+//     are the established generic exceptions in typescript-eslint.
+type noInvalidVoidType struct{}
+
+func (noInvalidVoidType) Name() string { return "typescript/no-invalid-void-type" }
+func (noInvalidVoidType) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindVoidKeyword}
+}
+func (noInvalidVoidType) Check(ctx *Context, node *shimast.Node) {
+	// The `void` keyword shows up both as a type node and as the unary
+	// `void X` expression operator. Filter by parent kind — the
+	// expression operator's parent is VoidExpression, not a type position.
+	parent := node.Parent
+	if parent == nil || parent.Kind == shimast.KindVoidExpression {
+		return
+	}
+	if isValidVoidPosition(node) {
+		return
+	}
+	ctx.Report(node, "`void` is only valid as the return type annotation of a function or as a known generic argument.")
+}
+
+// isValidVoidPosition reports whether a `void` type node sits in one
+// of the approved positions: a function return type or an
+// allow-listed generic type argument (Promise/Generator/AsyncGenerator/
+// Iterator/AsyncIterator/IterableIterator).
+func isValidVoidPosition(node *shimast.Node) bool {
+	parent := node.Parent
+	if parent == nil {
+		return false
+	}
+	switch parent.Kind {
+	case shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+		shimast.KindMethodSignature,
+		shimast.KindConstructor,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+		shimast.KindCallSignature,
+		shimast.KindConstructSignature,
+		shimast.KindFunctionType,
+		shimast.KindConstructorType,
+		shimast.KindIndexSignature:
+		return parent.Type() == node
+	case shimast.KindTypeReference:
+		// `void` as a generic argument — allowed inside the typescript-
+		// eslint approved set.
+		grand := parent.Parent
+		if grand == nil {
+			return false
+		}
+		if grand.Kind == shimast.KindTypeReference {
+			ref := grand.AsTypeReferenceNode()
+			if ref == nil {
+				return false
+			}
+			name := identifierText(ref.TypeName)
+			switch name {
+			case "Promise", "Generator", "AsyncGenerator", "Iterator", "AsyncIterator", "IterableIterator", "AsyncIterableIterator":
+				return true
+			}
+		}
+	}
+	// Walk up: if the parent chain leads directly to an allow-listed
+	// generic type reference's typeArguments list, accept.
+	for cur := parent; cur != nil; cur = cur.Parent {
+		if cur.Kind == shimast.KindTypeReference {
+			ref := cur.AsTypeReferenceNode()
+			if ref == nil {
+				return false
+			}
+			name := identifierText(ref.TypeName)
+			switch name {
+			case "Promise", "Generator", "AsyncGenerator", "Iterator", "AsyncIterator", "IterableIterator", "AsyncIterableIterator":
+				return true
+			}
+			return false
+		}
+		// Stop walking past statement boundaries — `void` in
+		// `let x: string | void;` should still fire.
+		switch cur.Kind {
+		case shimast.KindVariableDeclaration,
+			shimast.KindParameter,
+			shimast.KindPropertyDeclaration,
+			shimast.KindPropertySignature:
+			return false
+		}
+	}
+	return false
+}
+
+// explicitMemberAccessibility requires every class member declaration
+// to carry a `public` / `private` / `protected` modifier. Implicit
+// public is permitted by TypeScript but obscures intent — explicit
+// keywords make the encapsulation contract self-documenting and
+// catch the common bug of "I forgot to make this private."
+// https://typescript-eslint.io/rules/explicit-member-accessibility/
+//
+// Class fields whose name starts with `#` are exempt — the private
+// hash already carries the same meaning. The constructor is exempt;
+// upstream allows omitting accessibility on the constructor itself.
+type explicitMemberAccessibility struct{}
+
+func (explicitMemberAccessibility) Name() string {
+	return "typescript/explicit-member-accessibility"
+}
+func (explicitMemberAccessibility) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindMethodDeclaration,
+		shimast.KindPropertyDeclaration,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+	}
+}
+func (explicitMemberAccessibility) Check(ctx *Context, node *shimast.Node) {
+	// Skip non-class-scoped members.
+	parent := node.Parent
+	if parent == nil ||
+		(parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
+		return
+	}
+	// Skip private hash identifiers.
+	if name := node.Name(); name != nil && name.Kind == shimast.KindPrivateIdentifier {
+		return
+	}
+	if classMemberHasAccessibility(node) {
+		return
+	}
+	ctx.Report(node, "Class member is missing an explicit accessibility modifier (`public`, `private`, or `protected`).")
+}
+
+// classMemberHasAccessibility reports whether the member carries an
+// explicit `public` / `private` / `protected` modifier.
+func classMemberHasAccessibility(node *shimast.Node) bool {
+	if node == nil {
+		return false
+	}
+	mods := node.Modifiers()
+	if mods == nil {
+		return false
+	}
+	for _, m := range mods.Nodes {
+		if m == nil {
+			continue
+		}
+		switch m.Kind {
+		case shimast.KindPublicKeyword,
+			shimast.KindPrivateKeyword,
+			shimast.KindProtectedKeyword:
+			return true
+		}
+	}
+	return false
+}
+
+// consistentGenericConstructors reports the redundant pattern where a
+// variable is annotated with a generic type AND the same generic
+// arguments are repeated on the constructor call:
+//
+//	const m: Map<string, number> = new Map<string, number>();
+//
+// One of the two type-argument lists is enough. The upstream default
+// prefers the constructor form; the annotation form is also valid but
+// stating both is noise.
+// https://typescript-eslint.io/rules/consistent-generic-constructors/
+type consistentGenericConstructors struct{}
+
+func (consistentGenericConstructors) Name() string {
+	return "typescript/consistent-generic-constructors"
+}
+func (consistentGenericConstructors) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindVariableDeclaration}
+}
+func (consistentGenericConstructors) Check(ctx *Context, node *shimast.Node) {
+	decl := node.AsVariableDeclaration()
+	if decl == nil || decl.Type == nil || decl.Initializer == nil {
+		return
+	}
+	if decl.Type.Kind != shimast.KindTypeReference {
+		return
+	}
+	typeRef := decl.Type.AsTypeReferenceNode()
+	if typeRef == nil || typeRef.TypeArguments == nil {
+		return
+	}
+	initializer := stripParens(decl.Initializer)
+	if initializer == nil || initializer.Kind != shimast.KindNewExpression {
+		return
+	}
+	ne := initializer.AsNewExpression()
+	if ne == nil || ne.TypeArguments == nil {
+		return
+	}
+	ctx.Report(initializer, "Redundant generic arguments — the annotation already pins the type parameters; drop them from the constructor or vice versa.")
+}
+
+// preferNumericLiterals reports `parseInt(literal, radix)` calls that
+// could be written as an ES2015+ numeric literal (binary `0b…`, octal
+// `0o…`, hex `0x…`). The literal form is shorter, type-safe, and not
+// subject to runtime radix mismatches.
+// https://eslint.org/docs/latest/rules/prefer-numeric-literals
+type preferNumericLiterals struct{}
+
+func (preferNumericLiterals) Name() string { return "prefer-numeric-literals" }
+func (preferNumericLiterals) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (preferNumericLiterals) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Arguments == nil {
+		return
+	}
+	calleeName := identifierText(call.Expression)
+	if calleeName != "parseInt" && calleeName != "Number" {
+		return
+	}
+	args := call.Arguments.Nodes
+	if calleeName == "parseInt" && len(args) != 2 {
+		return
+	}
+	if calleeName == "Number" && len(args) != 1 {
+		return
+	}
+	first := stripParens(args[0])
+	if first == nil || first.Kind != shimast.KindStringLiteral {
+		return
+	}
+	if calleeName == "parseInt" {
+		radix := stripParens(args[1])
+		if radix == nil || radix.Kind != shimast.KindNumericLiteral {
+			return
+		}
+		switch numericLiteralText(radix) {
+		case "2", "8", "16":
+			ctx.Report(node, "Use a numeric literal (`0b…` / `0o…` / `0x…`) instead of `parseInt(\""+stringLiteralText(first)+"\", "+numericLiteralText(radix)+")`.")
+		}
+	}
+}
+
+func init() {
+	Register(noArrayForEach{})
+	Register(noExtraneousClass{})
+	Register(noInvalidVoidType{})
+	Register(explicitMemberAccessibility{})
+	Register(consistentGenericConstructors{})
+	Register(preferNumericLiterals{})
+}

package/linthost/rules_ts_sort_type_constituents.go

@@ -0,0 +1,144 @@
+// typescript/sort-type-constituents: union and intersection type
+// constituents render the same set of values regardless of the order
+// the author chose, so two authors writing the same type can disagree
+// on the spelling. The rule pins one canonical ordering — primitives
+// alphabetized first, then named / object types alphabetized, then
+// `null` / `undefined` last — so reviewers don't have to argue about
+// which spelling to land. typescript-eslint:
+// https://typescript-eslint.io/rules/sort-type-constituents/
+package linthost
+
+import (
+	"sort"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// sortTypeConstituents fires on `UnionType` and `IntersectionType` when
+// the constituent order does not match the canonical ordering. The
+// check is AST-only: ordering is decided by syntactic group (keyword
+// primitive vs. named reference vs. nullish) and a within-group source
+// sort, none of which need the Checker.
+//
+// The diagnostic anchors to the union / intersection node so the
+// rendered location names the whole type, not just one constituent.
+// One report per misordered type is enough — the autofixer would
+// rewrite the entire list together anyway.
+type sortTypeConstituents struct{}
+
+func (sortTypeConstituents) Name() string {
+	return "typescript/sort-type-constituents"
+}
+func (sortTypeConstituents) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindUnionType,
+		shimast.KindIntersectionType,
+	}
+}
+func (sortTypeConstituents) Check(ctx *Context, node *shimast.Node) {
+	types := unionOrIntersectionTypes(node)
+	if len(types) < 2 {
+		return
+	}
+	// Skip nested unions/intersections — the outermost shape is the one
+	// the user wrote, and reporting on every nesting level would
+	// double-fire on `(A | B) | C` shapes.
+	if node.Parent != nil &&
+		(node.Parent.Kind == shimast.KindUnionType || node.Parent.Kind == shimast.KindIntersectionType) {
+		return
+	}
+	entries := make([]sortTypeConstituentsEntry, len(types))
+	for i, t := range types {
+		entries[i] = sortTypeConstituentsEntry{
+			index: i,
+			group: sortTypeConstituentsClassify(t),
+			text:  strings.TrimSpace(nodeText(ctx.File, t)),
+		}
+	}
+	sorted := make([]sortTypeConstituentsEntry, len(entries))
+	copy(sorted, entries)
+	sort.SliceStable(sorted, func(i, j int) bool {
+		if sorted[i].group != sorted[j].group {
+			return sorted[i].group < sorted[j].group
+		}
+		return sorted[i].text < sorted[j].text
+	})
+	for i := range entries {
+		if entries[i].index != sorted[i].index {
+			label := "union"
+			if node.Kind == shimast.KindIntersectionType {
+				label = "intersection"
+			}
+			ctx.Report(node, "Constituents of the "+label+" are not in the canonical order — primitives alphabetized first, named types alphabetized next, `null` / `undefined` last.")
+			return
+		}
+	}
+}
+
+// sortTypeConstituentsEntry is one constituent's sort key. `index`
+// records the original position so the reorder check can compare the
+// before/after sequences without losing identity.
+type sortTypeConstituentsEntry struct {
+	index int
+	group int
+	text  string
+}
+
+// sortTypeConstituentsClassify buckets a constituent into one of the
+// canonical groups. Smaller numbers come first in the canonical order.
+func sortTypeConstituentsClassify(node *shimast.Node) int {
+	if node == nil {
+		return sortTypeConstituentsGroupNamed
+	}
+	switch node.Kind {
+	case shimast.KindStringKeyword,
+		shimast.KindNumberKeyword,
+		shimast.KindBooleanKeyword,
+		shimast.KindBigIntKeyword,
+		shimast.KindSymbolKeyword,
+		shimast.KindAnyKeyword,
+		shimast.KindUnknownKeyword,
+		shimast.KindVoidKeyword,
+		shimast.KindNeverKeyword,
+		shimast.KindObjectKeyword:
+		return sortTypeConstituentsGroupPrimitive
+	case shimast.KindLiteralType:
+		// `null` and `undefined` parse as LiteralType / undefined
+		// keyword inside type position — surface them as the nullish
+		// group so the canonical order keeps them at the end.
+		if sortTypeConstituentsIsNullish(node) {
+			return sortTypeConstituentsGroupNullish
+		}
+		return sortTypeConstituentsGroupLiteral
+	case shimast.KindUndefinedKeyword, shimast.KindNullKeyword:
+		return sortTypeConstituentsGroupNullish
+	}
+	return sortTypeConstituentsGroupNamed
+}
+
+const (
+	sortTypeConstituentsGroupPrimitive = iota
+	sortTypeConstituentsGroupLiteral
+	sortTypeConstituentsGroupNamed
+	sortTypeConstituentsGroupNullish
+)
+
+// sortTypeConstituentsIsNullish reports whether a LiteralType node
+// wraps the `null` keyword token. The `undefined` keyword in type
+// position is a regular Identifier-shaped reference and is handled by
+// the named group, not by this helper.
+func sortTypeConstituentsIsNullish(node *shimast.Node) bool {
+	if node == nil || node.Kind != shimast.KindLiteralType {
+		return false
+	}
+	lit := node.AsLiteralTypeNode()
+	if lit == nil || lit.Literal == nil {
+		return false
+	}
+	return lit.Literal.Kind == shimast.KindNullKeyword
+}
+
+func init() {
+	Register(sortTypeConstituents{})
+}

package/linthost/rules_ts_strict_boolean_expressions.go

@@ -0,0 +1,157 @@
+// strictBooleanExpressions fires when a non-boolean value is used in
+// a boolean context — the test of an `if` / `while` / `do` / `for` /
+// ternary, the operand of `!`, or either side of `&&` / `||`.
+// JavaScript coerces every truthy / falsy shape silently:
+//
+//   - numbers: `0`, `-0`, and `NaN` are falsy; every other number is
+//     truthy. `if (count)` therefore skips a legitimate zero.
+//   - strings: `""` is falsy; every other string is truthy.
+//     `if (name)` therefore skips a legitimate empty string.
+//   - nullable objects: `null` / `undefined` are falsy, the object is
+//     truthy. `if (obj)` collapses the present-vs-absent and
+//     present-but-empty cases together.
+//
+// The fix is always an explicit comparison naming the intent —
+// `count !== 0`, `str.length > 0`, `obj != null`. typescript-eslint:
+// https://typescript-eslint.io/rules/strict-boolean-expressions/
+//
+// Type-aware. Without a Checker the rule cannot tell a `boolean` apart
+// from a `string`, so Context.Checker == nil short-circuits each Check
+// to a no-op the way `no-for-in-array` and `no-misused-promises` do.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type strictBooleanExpressions struct{}
+
+func (strictBooleanExpressions) Name() string { return "typescript/strict-boolean-expressions" }
+func (strictBooleanExpressions) NeedsTypeChecker() bool {
+	return true
+}
+func (strictBooleanExpressions) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindIfStatement,
+		shimast.KindWhileStatement,
+		shimast.KindDoStatement,
+		shimast.KindForStatement,
+		shimast.KindConditionalExpression,
+		shimast.KindPrefixUnaryExpression,
+		shimast.KindBinaryExpression,
+	}
+}
+func (strictBooleanExpressions) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	switch node.Kind {
+	case shimast.KindIfStatement:
+		if stmt := node.AsIfStatement(); stmt != nil {
+			strictBooleanExpressionsReport(ctx, stmt.Expression)
+		}
+	case shimast.KindWhileStatement:
+		if stmt := node.AsWhileStatement(); stmt != nil {
+			strictBooleanExpressionsReport(ctx, stmt.Expression)
+		}
+	case shimast.KindDoStatement:
+		if stmt := node.AsDoStatement(); stmt != nil {
+			strictBooleanExpressionsReport(ctx, stmt.Expression)
+		}
+	case shimast.KindForStatement:
+		if stmt := node.AsForStatement(); stmt != nil {
+			strictBooleanExpressionsReport(ctx, stmt.Condition)
+		}
+	case shimast.KindConditionalExpression:
+		if expr := node.AsConditionalExpression(); expr != nil {
+			strictBooleanExpressionsReport(ctx, expr.Condition)
+		}
+	case shimast.KindPrefixUnaryExpression:
+		expr := node.AsPrefixUnaryExpression()
+		if expr != nil && expr.Operator == shimast.KindExclamationToken {
+			strictBooleanExpressionsReport(ctx, expr.Operand)
+		}
+	case shimast.KindBinaryExpression:
+		bin := node.AsBinaryExpression()
+		if bin == nil || bin.OperatorToken == nil {
+			return
+		}
+		// Only `&&` / `||` test their left operand for truthiness.
+		// `??` short-circuits on nullish, not on falsy, so a non-boolean
+		// left operand is exactly the point of `??` and is not flagged.
+		switch bin.OperatorToken.Kind {
+		case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
+			strictBooleanExpressionsReport(ctx, bin.Left)
+		}
+	}
+}
+
+// strictBooleanExpressionsReport flags `expr` when its static type is
+// not pure boolean-like. The recursion arm peels through `&&` / `||`
+// chains so `if (a && b)` reports both `a` and `b`, mirroring the
+// upstream rule. Parenthesized wrappers are skipped via stripParens
+// so `if ((x))` resolves to `x`.
+func strictBooleanExpressionsReport(ctx *Context, expr *shimast.Node) {
+	if expr == nil {
+		return
+	}
+	expr = stripParens(expr)
+	if expr == nil {
+		return
+	}
+	// Descend through `&&` / `||` — each conjunct/disjunct sits in
+	// boolean position too. The outer BinaryExpression visit only
+	// checks Left; the descent here finds Right as well.
+	if expr.Kind == shimast.KindBinaryExpression {
+		bin := expr.AsBinaryExpression()
+		if bin != nil && bin.OperatorToken != nil {
+			switch bin.OperatorToken.Kind {
+			case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
+				strictBooleanExpressionsReport(ctx, bin.Left)
+				strictBooleanExpressionsReport(ctx, bin.Right)
+				return
+			}
+		}
+	}
+	t := ctx.Checker.GetTypeAtLocation(expr)
+	if t == nil {
+		return
+	}
+	if strictBooleanExpressionsIsBoolean(t) {
+		return
+	}
+	ctx.Report(expr, "Unexpected non-boolean value in a boolean conditional position. Use an explicit comparison (`!== 0`, `.length > 0`, `!= null`) to name the intent.")
+}
+
+// strictBooleanExpressionsIsBoolean reports whether t is pure
+// boolean-like. `any` / `unknown` / `never` are intentionally NOT
+// considered boolean — they leak through generic helpers and would
+// suppress the rule everywhere a value of unknown origin lands in a
+// conditional. Union and intersection types must have every
+// constituent boolean for the whole type to count.
+func strictBooleanExpressionsIsBoolean(t *shimchecker.Type) bool {
+	if 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 !strictBooleanExpressionsIsBoolean(part) {
+				return false
+			}
+		}
+		return true
+	}
+	return flags&shimchecker.TypeFlagsBooleanLike != 0
+}
+
+func init() {
+	Register(strictBooleanExpressions{})
+}