@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_no_shadow.go

@@ -0,0 +1,147 @@
+// noShadow reports a binding declaration whose name matches a binding
+// already in scope at an outer level. The inner declaration silently
+// obscures the outer reference — readers expect `outer` inside the body
+// to mean the outer binding, but it now resolves to the inner one. The
+// pattern is almost always an accidental rebind during refactoring.
+// https://eslint.org/docs/latest/rules/no-shadow
+//
+// Conservative scope tracking: walk the file once with an explicit
+// stack of scope frames. A frame is pushed on every function-like
+// node (which contributes its parameter names) and on every Block /
+// CatchClause (which contributes its block-scoped `let`, `const`,
+// `class`, and `function` declarations). `var` bindings are recorded
+// on the nearest enclosing function frame instead — they hoist past
+// inner block boundaries.
+//
+// Only plain identifier bindings are tracked. Destructuring patterns
+// (`const { a } = …`, `function f({ x }) {}`) are skipped because the
+// rule cannot reason about pattern equality without a real binder, and
+// the AST-only baseline prefers false negatives to false positives.
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type noShadow struct{}
+
+func (noShadow) Name() string           { return "no-shadow" }
+func (noShadow) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (noShadow) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	// Each frame records the names declared at that lexical level.
+	// `isFunction` marks frames that absorb hoisted `var` bindings.
+	type frame struct {
+		names      map[string]bool
+		isFunction bool
+	}
+	stack := []*frame{{names: map[string]bool{}, isFunction: true}}
+
+	outerHas := func(name string) bool {
+		for i := len(stack) - 2; i >= 0; i-- {
+			if stack[i].names[name] {
+				return true
+			}
+		}
+		return false
+	}
+
+	declare := func(name string, declNode *shimast.Node, hoist bool) {
+		if name == "" {
+			return
+		}
+		target := stack[len(stack)-1]
+		if hoist {
+			for i := len(stack) - 1; i >= 0; i-- {
+				if stack[i].isFunction {
+					target = stack[i]
+					break
+				}
+			}
+		}
+		if outerHas(name) {
+			ctx.Report(declNode, "'"+name+"' is already declared in the upper scope.")
+		}
+		target.names[name] = true
+	}
+
+	var walk func(n *shimast.Node)
+	walk = func(n *shimast.Node) {
+		if n == nil {
+			return
+		}
+		// Bind a function declaration's name in the enclosing scope
+		// before descending into its body. `var`-style hoisting takes
+		// the name to the nearest function frame.
+		if n.Kind == shimast.KindFunctionDeclaration {
+			if decl := n.AsFunctionDeclaration(); decl != nil && decl.Body != nil {
+				if name := identifierText(decl.Name()); name != "" {
+					declare(name, n, true)
+				}
+			}
+		}
+		// Push a frame for every scope-introducing node. Function-like
+		// frames also receive their parameter names before descending.
+		if isFunctionLikeKind(n) {
+			stack = append(stack, &frame{names: map[string]bool{}, isFunction: true})
+			for _, name := range parameterBindingNames(n) {
+				declare(name, n, false)
+			}
+			n.ForEachChild(func(child *shimast.Node) bool {
+				walk(child)
+				return false
+			})
+			stack = stack[:len(stack)-1]
+			return
+		}
+		switch n.Kind {
+		case shimast.KindBlock, shimast.KindCatchClause:
+			// Function bodies are blocks too, but the function frame
+			// pushed above already represents that scope — skip the
+			// extra frame so a parameter and a body-level `let` of the
+			// same name still register as a redeclare, not a shadow.
+			if n.Kind == shimast.KindBlock && n.Parent != nil && isFunctionLikeKind(n.Parent) {
+				n.ForEachChild(func(child *shimast.Node) bool {
+					walk(child)
+					return false
+				})
+				return
+			}
+			stack = append(stack, &frame{names: map[string]bool{}})
+			if catch := n.AsCatchClause(); catch != nil && catch.VariableDeclaration != nil {
+				if name := identifierText(catch.VariableDeclaration.Name()); name != "" {
+					declare(name, catch.VariableDeclaration, false)
+				}
+			}
+			n.ForEachChild(func(child *shimast.Node) bool {
+				walk(child)
+				return false
+			})
+			stack = stack[:len(stack)-1]
+			return
+		case shimast.KindVariableStatement:
+			vs := n.AsVariableStatement()
+			if vs != nil && vs.DeclarationList != nil {
+				hoist := shimast.IsVar(vs.DeclarationList)
+				for _, name := range variableStatementBindingNames(n) {
+					declare(name, n, hoist)
+				}
+			}
+		case shimast.KindClassDeclaration:
+			if decl := n.AsClassDeclaration(); decl != nil {
+				if name := identifierText(decl.Name()); name != "" {
+					declare(name, n, false)
+				}
+			}
+		}
+		n.ForEachChild(func(child *shimast.Node) bool {
+			walk(child)
+			return false
+		})
+	}
+	walk(node)
+}
+
+func init() {
+	Register(noShadow{})
+}

package/linthost/rules_no_unreachable.go

@@ -0,0 +1,77 @@
+// noUnreachable reports statements that follow an unconditional control-
+// flow terminator inside the same statement list. After `return`, `throw`,
+// `break`, or `continue` the surrounding block exits, so any later
+// statement in the list is dead code — almost always a leftover from
+// refactoring.
+//
+// Conservative baseline: only the immediate statement list of a Block,
+// SourceFile, or ModuleBlock is inspected; nested conditionals and loops
+// are left to a real control-flow pass. Hoistable function declarations
+// following the terminator are exempt because they are hoisted above the
+// unreachable point and remain callable from earlier statements.
+// https://eslint.org/docs/latest/rules/no-unreachable
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noUnreachable struct{}
+
+func (noUnreachable) Name() string { return "no-unreachable" }
+func (noUnreachable) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindBlock,
+		shimast.KindSourceFile,
+		shimast.KindModuleBlock,
+	}
+}
+func (noUnreachable) Check(ctx *Context, node *shimast.Node) {
+	stmts := node.Statements()
+	if len(stmts) < 2 {
+		return
+	}
+	terminated := false
+	for _, stmt := range stmts {
+		if stmt == nil {
+			continue
+		}
+		if terminated && !isHoistableDeclaration(stmt) {
+			ctx.Report(stmt, "Unreachable code.")
+			continue
+		}
+		if isControlFlowTerminator(stmt) {
+			terminated = true
+		}
+	}
+}
+
+// isControlFlowTerminator reports whether `stmt` is one of the four
+// statement kinds that unconditionally leave the surrounding block:
+// `return`, `throw`, `break`, `continue`.
+func isControlFlowTerminator(stmt *shimast.Node) bool {
+	if stmt == nil {
+		return false
+	}
+	switch stmt.Kind {
+	case shimast.KindReturnStatement,
+		shimast.KindThrowStatement,
+		shimast.KindBreakStatement,
+		shimast.KindContinueStatement:
+		return true
+	}
+	return false
+}
+
+// isHoistableDeclaration reports whether `stmt` is a declaration whose
+// binding survives even when it textually follows a terminator. Function
+// declarations hoist to the top of their containing scope, so a
+// `function f() {…}` after a `return` is still callable from earlier
+// statements and is not dead code in the ESLint sense.
+func isHoistableDeclaration(stmt *shimast.Node) bool {
+	return stmt != nil && stmt.Kind == shimast.KindFunctionDeclaration
+}
+
+func init() {
+	Register(noUnreachable{})
+}

package/linthost/rules_no_useless_assignment.go

@@ -0,0 +1,120 @@
+// noUselessAssignment reports an assignment whose value is immediately
+// overwritten by the very next statement without an intervening read of
+// the same identifier. `x = 1; x = 2;` writes the first value just to
+// discard it — almost always a leftover from refactoring.
+// https://eslint.org/docs/latest/rules/no-useless-assignment
+//
+// Conservative baseline: only the syntactically adjacent
+// ExpressionStatement / ExpressionStatement pair is inspected, and only
+// when both left-hand sides are bare identifiers with the same name. A
+// real dead-store analysis would track reads across branches and inside
+// the right-hand expression; the simpler textual match catches the
+// common copy-paste case without needing full control-flow.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noUselessAssignment struct{}
+
+func (noUselessAssignment) Name() string { return "no-useless-assignment" }
+func (noUselessAssignment) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBlock}
+}
+func (noUselessAssignment) Check(ctx *Context, node *shimast.Node) {
+	block := node.AsBlock()
+	if block == nil || block.Statements == nil {
+		return
+	}
+	stmts := block.Statements.Nodes
+	if len(stmts) < 2 {
+		return
+	}
+	for i := 0; i+1 < len(stmts); i++ {
+		firstName, firstAssign := plainAssignmentTarget(stmts[i])
+		if firstName == "" {
+			continue
+		}
+		secondName, _ := plainAssignmentTarget(stmts[i+1])
+		if secondName != firstName {
+			continue
+		}
+		// If the second statement's RHS reads the first target, the
+		// first write is load-bearing — skip.
+		if assignmentRhsReadsIdent(stmts[i+1], firstName) {
+			continue
+		}
+		ctx.Report(firstAssign, "Assignment to `"+firstName+"` is immediately overwritten without being read.")
+	}
+}
+
+// plainAssignmentTarget returns the identifier name on the left-hand
+// side of `stmt` when it is an `ExpressionStatement` wrapping a plain
+// `<ident> = <expr>` assignment. Anything else (compound assignment,
+// destructuring target, property access, non-statement) returns "".
+func plainAssignmentTarget(stmt *shimast.Node) (string, *shimast.Node) {
+	if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+		return "", nil
+	}
+	expr := stmt.AsExpressionStatement()
+	if expr == nil || expr.Expression == nil {
+		return "", nil
+	}
+	inner := stripParens(expr.Expression)
+	if inner == nil || inner.Kind != shimast.KindBinaryExpression {
+		return "", nil
+	}
+	bin := inner.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil || bin.OperatorToken.Kind != shimast.KindEqualsToken {
+		return "", nil
+	}
+	name := identifierText(stripParens(bin.Left))
+	if name == "" {
+		return "", nil
+	}
+	return name, stmt
+}
+
+// assignmentRhsReadsIdent reports whether the second statement's
+// assignment right-hand side references the same identifier name. A
+// `x = x + 1` style update reads the previous value, so the prior
+// assignment is not actually dead.
+func assignmentRhsReadsIdent(stmt *shimast.Node, name string) bool {
+	if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+		return false
+	}
+	expr := stmt.AsExpressionStatement()
+	if expr == nil || expr.Expression == nil {
+		return false
+	}
+	inner := stripParens(expr.Expression)
+	if inner == nil || inner.Kind != shimast.KindBinaryExpression {
+		return false
+	}
+	bin := inner.AsBinaryExpression()
+	if bin == nil || bin.Right == nil {
+		return false
+	}
+	found := false
+	var walk func(n *shimast.Node)
+	walk = func(n *shimast.Node) {
+		if found || n == nil {
+			return
+		}
+		if n.Kind == shimast.KindIdentifier && identifierText(n) == name {
+			found = true
+			return
+		}
+		n.ForEachChild(func(child *shimast.Node) bool {
+			walk(child)
+			return false
+		})
+	}
+	walk(bin.Right)
+	return found
+}
+
+func init() {
+	Register(noUselessAssignment{})
+}

package/linthost/rules_no_useless_constructor.go

@@ -0,0 +1,245 @@
+// noUselessConstructor: report class constructors that contribute
+// nothing beyond what the engine would synthesize on its own. Two
+// shapes fire:
+//
+//   - Empty body, no parameters, no accessibility/decorator modifiers.
+//     The engine generates an identical implicit constructor when the
+//     class declares none, so the explicit declaration is pure noise.
+//
+//   - Derived constructor that does nothing but forward to `super(...args)`
+//     unchanged. The default constructor of a subclass already forwards
+//     every argument to `super`, so an explicit `constructor(...args) {
+//     super(...args); }` is redundant. The forwarded parameter list and
+//     the `super` call's argument list must be identical rest-spreads of
+//     the same name — modifying, reordering, or filtering the arguments
+//     means the constructor still has a purpose and is left alone.
+//
+// Constructors that carry parameter properties (`constructor(private x:
+// number)`) or accessibility / decorator modifiers are skipped: removing
+// them would change the class shape or its observable metadata, so they
+// are never "useless" by this rule's standard.
+// https://typescript-eslint.io/rules/no-useless-constructor/
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type noUselessConstructor struct{}
+
+func (noUselessConstructor) Name() string           { return "no-useless-constructor" }
+func (noUselessConstructor) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindConstructor} }
+func (noUselessConstructor) Check(ctx *Context, node *shimast.Node) {
+	ctor := node.AsConstructorDeclaration()
+	if ctor == nil || ctor.Body == nil {
+		return
+	}
+	// Accessibility modifiers (`private`/`protected`) on the constructor
+	// itself are load-bearing: they restrict who can `new` the class.
+	// Removing the constructor would silently widen visibility.
+	if node.ModifierFlags()&(shimast.ModifierFlagsPrivate|shimast.ModifierFlagsProtected) != 0 {
+		return
+	}
+	if hasParameterProperty(node) {
+		return
+	}
+	body := ctor.Body.AsBlock()
+	if body == nil || body.Statements == nil {
+		return
+	}
+	params := node.Parameters()
+
+	// Shape 1: empty body, no parameters. The implicit constructor that
+	// the engine generates when no constructor is written is identical,
+	// so the explicit declaration is noise.
+	if len(params) == 0 && len(body.Statements.Nodes) == 0 {
+		ctx.Report(node, "Useless empty constructor.")
+		return
+	}
+
+	// Shape 2: derived class constructor that only forwards arguments to
+	// `super(...args)` without modification. The synthetic default
+	// constructor of a subclass behaves identically, so the explicit
+	// declaration is noise. Only fires when the class extends another.
+	parent := node.Parent
+	if parent == nil || !classExtendsAnother(parent) {
+		return
+	}
+	if len(body.Statements.Nodes) != 1 {
+		return
+	}
+	if !isPlainSuperForwarder(params, body.Statements.Nodes[0]) {
+		return
+	}
+	ctx.Report(node, "Useless constructor: forwards arguments to `super` unchanged.")
+}
+
+// hasParameterProperty reports whether any constructor parameter carries
+// a TypeScript parameter-property modifier (`public`, `private`,
+// `protected`, or `readonly`). Such a parameter declares an instance
+// field, so the constructor is doing real work even if its body is
+// empty — removing it would drop the field.
+func hasParameterProperty(node *shimast.Node) bool {
+	for _, p := range node.Parameters() {
+		if p == nil {
+			continue
+		}
+		if p.ModifierFlags()&(shimast.ModifierFlagsPrivate|shimast.ModifierFlagsProtected|shimast.ModifierFlagsReadonly) != 0 {
+			return true
+		}
+		// `public` is not represented by any of the above flags but does
+		// still create a parameter property. Inspect the raw modifier
+		// list for a PublicKeyword.
+		decl := p.AsParameterDeclaration()
+		if decl == nil {
+			continue
+		}
+		if hasPublicModifier(decl.Modifiers()) {
+			return true
+		}
+	}
+	return false
+}
+
+// hasPublicModifier reports whether `mods` includes a `public` keyword.
+// `public` is a parameter-property qualifier that does not set any of
+// the Private/Protected/Readonly modifier flags, so we walk the raw
+// modifier list to detect it.
+func hasPublicModifier(mods *shimast.ModifierList) bool {
+	if mods == nil {
+		return false
+	}
+	for _, m := range mods.Nodes {
+		if m != nil && m.Kind == shimast.KindPublicKeyword {
+			return true
+		}
+	}
+	return false
+}
+
+// isPlainSuperForwarder reports whether `stmt` is exactly
+// `super(...name);` (an expression statement wrapping a CallExpression
+// whose callee is the `super` keyword and whose only argument is a
+// SpreadElement over an identifier) AND the constructor parameter list
+// is exactly `(...name)` over the same identifier. Type annotations on
+// the rest parameter are allowed — `(...args: unknown[])` still
+// forwards unchanged.
+func isPlainSuperForwarder(params []*shimast.Node, stmt *shimast.Node) bool {
+	if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+		return false
+	}
+	exprStmt := stmt.AsExpressionStatement()
+	if exprStmt == nil || exprStmt.Expression == nil {
+		return false
+	}
+	expr := stripParens(exprStmt.Expression)
+	if expr == nil || expr.Kind != shimast.KindCallExpression {
+		return false
+	}
+	call := expr.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindSuperKeyword {
+		return false
+	}
+	if call.Arguments == nil {
+		return false
+	}
+	args := call.Arguments.Nodes
+	// `super()` — zero arguments — only matches when the constructor
+	// also declares zero parameters. ESLint flags this shape too: the
+	// synthetic default constructor of a derived class would call
+	// `super(...args)`, which for a zero-arg case is the same thing.
+	if len(args) == 0 {
+		return len(params) == 0
+	}
+	if len(args) != len(params) {
+		return false
+	}
+	// All arguments must be `...name` spreading the identically named
+	// rest parameter. ESLint also accepts the positional `super(a, b)`
+	// over `(a, b)` shape — match that too: every parameter must be a
+	// plain identifier (or rest), and the argument must spread/use the
+	// same identifier in the same position.
+	for i, arg := range args {
+		paramName, paramRest, ok := plainParamIdentifier(params[i])
+		if !ok {
+			return false
+		}
+		argName, argSpread, ok := plainArgIdentifier(arg)
+		if !ok {
+			return false
+		}
+		if paramName != argName {
+			return false
+		}
+		if paramRest != argSpread {
+			return false
+		}
+	}
+	return true
+}
+
+// plainParamIdentifier extracts the identifier name of a parameter that
+// is a plain `name` or `...name`. Returns `(name, isRest, true)` on
+// match, or zero values + false when the parameter is a destructuring
+// pattern, has a default value, has an accessibility modifier, has a
+// `?` token (optional), or otherwise carries observable behavior.
+// Type annotations are intentionally ignored — they do not change the
+// runtime forwarding behavior.
+func plainParamIdentifier(param *shimast.Node) (string, bool, bool) {
+	if param == nil {
+		return "", false, false
+	}
+	decl := param.AsParameterDeclaration()
+	if decl == nil {
+		return "", false, false
+	}
+	if decl.Initializer != nil || decl.QuestionToken != nil {
+		return "", false, false
+	}
+	// Accessibility modifier on the parameter would already have been
+	// caught by hasParameterProperty above, but guard locally too.
+	if param.ModifierFlags()&(shimast.ModifierFlagsPrivate|shimast.ModifierFlagsProtected|shimast.ModifierFlagsReadonly) != 0 {
+		return "", false, false
+	}
+	if hasPublicModifier(decl.Modifiers()) {
+		return "", false, false
+	}
+	name := identifierText(decl.Name())
+	if name == "" {
+		return "", false, false
+	}
+	return name, decl.DotDotDotToken != nil, true
+}
+
+// plainArgIdentifier extracts the identifier name of a call argument
+// that is a plain `name` or `...name`. Returns `(name, isSpread, true)`
+// on match. Anything else — a literal, property access, expression —
+// is treated as observable work and disqualifies the forwarder.
+func plainArgIdentifier(arg *shimast.Node) (string, bool, bool) {
+	if arg == nil {
+		return "", false, false
+	}
+	stripped := stripParens(arg)
+	if stripped == nil {
+		return "", false, false
+	}
+	if stripped.Kind == shimast.KindSpreadElement {
+		spread := stripped.AsSpreadElement()
+		if spread == nil {
+			return "", false, false
+		}
+		inner := stripParens(spread.Expression)
+		name := identifierText(inner)
+		if name == "" {
+			return "", false, false
+		}
+		return name, true, true
+	}
+	name := identifierText(stripped)
+	if name == "" {
+		return "", false, false
+	}
+	return name, false, true
+}
+
+func init() {
+	Register(noUselessConstructor{})
+}

package/linthost/rules_no_useless_return.go

@@ -0,0 +1,51 @@
+// noUselessReturn reports a bare `return;` whose only effect is to end a
+// function body that would have returned anyway. `function f() { … ;
+// return; }` is identical to `function f() { … ; }`: the trailing
+// statement adds no behavior, only noise. The conservative baseline only
+// fires at the very last statement of a block that is itself the
+// immediate body of a function-like — any earlier `return;` inside a
+// loop, branch, or inner block may still be load-bearing.
+// https://eslint.org/docs/latest/rules/no-useless-return
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noUselessReturn struct{}
+
+func (noUselessReturn) Name() string { return "no-useless-return" }
+func (noUselessReturn) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindReturnStatement}
+}
+func (noUselessReturn) Check(ctx *Context, node *shimast.Node) {
+	ret := node.AsReturnStatement()
+	if ret == nil || ret.Expression != nil {
+		// `return X;` is never useless: it carries a value.
+		return
+	}
+	parent := node.Parent
+	if parent == nil || parent.Kind != shimast.KindBlock {
+		return
+	}
+	block := parent.AsBlock()
+	if block == nil || block.Statements == nil {
+		return
+	}
+	stmts := block.Statements.Nodes
+	if len(stmts) == 0 || stmts[len(stmts)-1] != node {
+		// Only the last statement of the block is provably useless;
+		// any earlier `return;` may guard the statements that follow.
+		return
+	}
+	if !isFunctionLikeKind(parent.Parent) {
+		// The block must be the immediate body of a function-like so
+		// the function's natural completion is what would run next.
+		return
+	}
+	ctx.Report(node, "Unnecessary return statement.")
+}
+
+func init() {
+	Register(noUselessReturn{})
+}

package/linthost/rules_params.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// default-param-last: forbid parameters with default initializers that
+// defaultParamLast: forbid parameters with default initializers that
 // precede non-default parameters. The combination forces every caller
 // to spell out `undefined` for the defaulted parameter — which defeats
 // the purpose of the default. ESLint canonical: