@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_logic.go

@@ -10,7 +10,7 @@ import (
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-// no-extra-boolean-cast: `if (!!x)`, `if (Boolean(x))`, `Boolean(!!x)` —
+// noExtraBooleanCast: `if (!!x)`, `if (Boolean(x))`, `Boolean(!!x)` —
 // the conversion is implicit in a boolean context.
 // https://eslint.org/docs/latest/rules/no-extra-boolean-cast
 type noExtraBooleanCast struct{}
@@ -148,7 +148,7 @@ func skipParents(node *shimast.Node) *shimast.Node {
   return node
 }
 
-// no-unsafe-negation: `!a in b` and `!a instanceof b` — the parser
+// noUnsafeNegation: `!a in b` and `!a instanceof b` — the parser
 // applies the negation to `a`, not to the whole comparison.
 // https://eslint.org/docs/latest/rules/no-unsafe-negation
 type noUnsafeNegation struct{}
@@ -247,13 +247,13 @@ func comparableLiteralKind(node *shimast.Node) string {
   return ""
 }
 
-// use-isnan: `x === NaN` is always false. Use `Number.isNaN(x)`.
+// useIsNaN: `x === NaN` is always false. Use `Number.isNaN(x)`.
 // https://eslint.org/docs/latest/rules/use-isnan
-type useIsnan struct{}
+type useIsNaN struct{}
 
-func (useIsnan) Name() string           { return "use-isnan" }
-func (useIsnan) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
-func (useIsnan) Check(ctx *Context, node *shimast.Node) {
+func (useIsNaN) Name() string           { return "use-isnan" }
+func (useIsNaN) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (useIsNaN) Check(ctx *Context, node *shimast.Node) {
   expr := node.AsBinaryExpression()
   if expr == nil || expr.OperatorToken == nil {
     return
@@ -266,7 +266,7 @@ func (useIsnan) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// valid-typeof: typeof expressions can only be compared to known type
+// validTypeof: typeof expressions can only be compared to known type
 // strings. Catches `typeof x === "stirng"`.
 // https://eslint.org/docs/latest/rules/valid-typeof
 type validTypeof struct{}
@@ -311,7 +311,7 @@ func isValidTypeofString(value string) bool {
   return false
 }
 
-// no-compare-neg-zero: `x === -0`. Comparison ignores the sign — use
+// noCompareNegZero: `x === -0`. Comparison ignores the sign — use
 // `Object.is(x, -0)` if you really mean it.
 // https://eslint.org/docs/latest/rules/no-compare-neg-zero
 type noCompareNegZero struct{}
@@ -342,7 +342,7 @@ func isNegZero(node *shimast.Node) bool {
   return numericLiteralText(prefix.Operand) == "0"
 }
 
-// no-cond-assign: `if (a = b)` is almost always a typo for `if (a == b)`.
+// noCondAssign: `if (a = b)` is almost always a typo for `if (a == b)`.
 // Default mode matches ESLint's `except-parens` — wrapping in `( )`
 // silences the rule.
 // https://eslint.org/docs/latest/rules/no-cond-assign
@@ -418,7 +418,7 @@ func isAssignmentOperator(kind shimast.Kind) bool {
   return false
 }
 
-// no-constant-condition: `if (true)`, `while (1)`, `if (literal)`. Often
+// noConstantCondition: `if (true)`, `while (1)`, `if (literal)`. Often
 // the result of leftover debug code or a typo.
 // https://eslint.org/docs/latest/rules/no-constant-condition
 type noConstantCondition struct{}
@@ -495,7 +495,7 @@ func init() {
   Register(noExtraBooleanCast{})
   Register(noUnsafeNegation{})
   Register(eqeqeq{})
-  Register(useIsnan{})
+  Register(useIsNaN{})
   Register(validTypeof{})
   Register(noCompareNegZero{})
   Register(noCondAssign{})

package/linthost/rules_loops.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// for-direction: `for (var i = 10; i < 20; i--)` will never terminate.
+// forDirection: `for (var i = 10; i < 20; i--)` will never terminate.
 // https://eslint.org/docs/latest/rules/for-direction
 type forDirection struct{}
 

package/linthost/rules_max_classes_per_file.go

@@ -0,0 +1,58 @@
+// maxClassesPerFile: a file that declares many classes is almost
+// always carrying several unrelated responsibilities. Splitting them
+// into their own modules keeps imports honest and reduces the surface
+// each reader has to scan. ESLint's default ceiling is one class per
+// file, which @ttsc/lint mirrors as the only built-in threshold
+// (option-decoding is deferred).
+// https://eslint.org/docs/latest/rules/max-classes-per-file
+//
+// The rule counts both ClassDeclaration and ClassExpression nodes
+// anywhere in the file so a helper class hidden inside an IIFE still
+// contributes to the total. The finding is anchored at the first
+// class that pushed the count past the limit — the second class
+// under the default — so the diagnostic header points at the
+// offending declaration rather than the file's opening line.
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// maxClassesPerFileLimit is the class-count ceiling. Above this value
+// the rule fires once for the file. Mirrors the ESLint default.
+const maxClassesPerFileLimit = 1
+
+type maxClassesPerFile struct{}
+
+func (maxClassesPerFile) Name() string { return "max-classes-per-file" }
+func (maxClassesPerFile) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSourceFile}
+}
+func (maxClassesPerFile) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	var classes []*shimast.Node
+	walkDescendants(node, func(n *shimast.Node) {
+		if n == nil {
+			return
+		}
+		switch n.Kind {
+		case shimast.KindClassDeclaration, shimast.KindClassExpression:
+			classes = append(classes, n)
+		}
+	})
+	if len(classes) <= maxClassesPerFileLimit {
+		return
+	}
+	// Report at the first class that pushed the count over the limit,
+	// so the diagnostic anchors on the offending declaration rather
+	// than the file's opening byte.
+	ctx.Report(classes[maxClassesPerFileLimit], fmt.Sprintf("File has too many classes (%d). Maximum allowed is %d.", len(classes), maxClassesPerFileLimit))
+}
+
+func init() {
+	Register(maxClassesPerFile{})
+}

package/linthost/rules_max_depth.go

@@ -0,0 +1,83 @@
+// maxDepth: deeply nested block statements are a readability tax — the
+// reader must hold every enclosing condition or loop in mind to reason
+// about the innermost statement. ESLint's default is `{ max: 4 }`, which
+// @ttsc/lint mirrors as the only built-in threshold (option-decoding is
+// deferred). Each function body re-starts the depth counter so nested
+// function-like declarations are measured independently.
+// https://eslint.org/docs/latest/rules/max-depth
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// maxDepthLimit is the block-nesting ceiling. Above this value the rule
+// fires. Mirrors the ESLint default and matches the threshold documented
+// in the README and website MDX.
+const maxDepthLimit = 4
+
+type maxDepth struct{}
+
+func (maxDepth) Name() string { return "max-depth" }
+func (maxDepth) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+	}
+}
+func (maxDepth) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	body := node.Body()
+	if body == nil || body.Kind != shimast.KindBlock {
+		return
+	}
+	walkMaxDepthBody(body, node, 0, ctx)
+}
+
+// walkMaxDepthBody descends through `root` counting nested block-bearing
+// statements without crossing nested function-like scopes. Each nested
+// function is left for its own visit. The depth counter increments on
+// statements whose bodies introduce a new block: `if`, `else`, `for`,
+// `for-in`, `for-of`, `while`, `do-while`, `switch`, and `try` (plus
+// each `catch` clause). When the depth exceeds the configured limit, a
+// single finding is reported at the offending statement and the
+// recursive walk continues so independent over-limit branches each get
+// their own diagnostic.
+func walkMaxDepthBody(node *shimast.Node, fn *shimast.Node, depth int, ctx *Context) {
+	if node == nil {
+		return
+	}
+	if node != fn && isFunctionLikeKind(node) {
+		return
+	}
+	switch node.Kind {
+	case shimast.KindIfStatement,
+		shimast.KindForStatement,
+		shimast.KindForInStatement,
+		shimast.KindForOfStatement,
+		shimast.KindWhileStatement,
+		shimast.KindDoStatement,
+		shimast.KindSwitchStatement,
+		shimast.KindTryStatement,
+		shimast.KindCatchClause,
+		shimast.KindWithStatement:
+		depth++
+		if depth > maxDepthLimit {
+			ctx.Report(node, fmt.Sprintf("Blocks are nested too deeply (%d). Maximum allowed is %d.", depth, maxDepthLimit))
+		}
+	}
+	node.ForEachChild(func(child *shimast.Node) bool {
+		walkMaxDepthBody(child, fn, depth, ctx)
+		return false
+	})
+}
+
+func init() {
+	Register(maxDepth{})
+}

package/linthost/rules_max_lines.go

@@ -0,0 +1,101 @@
+// maxLines: very long files are almost always doing more than one
+// thing — the reader cannot hold the whole responsibility in their
+// head, and follow-up changes tend to make the file longer rather than
+// split it. ESLint's default ceiling is 300 lines, which @ttsc/lint
+// mirrors as the only built-in threshold (option-decoding is deferred).
+// https://eslint.org/docs/latest/rules/max-lines
+//
+// The rule counts every line in the file's source text — code,
+// comments, and blank lines alike — because the goal is a hard cap on
+// how much one file can hold, not a heuristic over "real" code. A file
+// with N newline characters has N+1 lines unless the final character
+// itself is a newline; in either case the count corresponds to the
+// line on which the last byte appears. The finding is anchored at the
+// first line that exceeded the limit (line `max+1`), matching ESLint
+// so editor squiggles land on the offending row rather than the file's
+// opening line.
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// maxLinesLimit is the line-count ceiling. Above this value the rule
+// fires once for the file. Mirrors the ESLint default.
+const maxLinesLimit = 300
+
+type maxLines struct{}
+
+func (maxLines) Name() string { return "max-lines" }
+func (maxLines) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSourceFile}
+}
+func (maxLines) Check(ctx *Context, node *shimast.Node) {
+	if ctx.File == nil {
+		return
+	}
+	src := ctx.File.Text()
+	count := countSourceLines(src)
+	if count <= maxLinesLimit {
+		return
+	}
+	// Anchor at the start of line `max+1` — the first line that pushed
+	// the file past the limit. ESLint matches this anchor so editor
+	// squiggles land on the offending row.
+	pos := nthLineStart(src, maxLinesLimit)
+	if pos < 0 || pos >= len(src) {
+		pos = 0
+	}
+	end := pos + 1
+	if end > len(src) {
+		end = len(src)
+	}
+	if end <= pos {
+		end = pos + 1
+	}
+	ctx.ReportRange(pos, end, fmt.Sprintf("File has too many lines (%d). Maximum allowed is %d.", count, maxLinesLimit))
+}
+
+// nthLineStart returns the byte offset where the (`n`+1)-th line
+// begins (0-indexed: passing 0 returns 0, passing 1 returns the byte
+// after the first `\n`). Returns -1 when the file has fewer lines.
+func nthLineStart(src string, n int) int {
+	if n <= 0 {
+		return 0
+	}
+	seen := 0
+	for i := 0; i < len(src); i++ {
+		if src[i] == '\n' {
+			seen++
+			if seen == n {
+				return i + 1
+			}
+		}
+	}
+	return -1
+}
+
+// countSourceLines returns the number of lines in `src`. Every `\n`
+// terminates a line; a non-empty trailing fragment without a newline
+// counts as one additional line. An empty source has zero lines.
+func countSourceLines(src string) int {
+	if len(src) == 0 {
+		return 0
+	}
+	count := 0
+	for i := 0; i < len(src); i++ {
+		if src[i] == '\n' {
+			count++
+		}
+	}
+	if src[len(src)-1] != '\n' {
+		count++
+	}
+	return count
+}
+
+func init() {
+	Register(maxLines{})
+}

package/linthost/rules_max_lines_per_function.go

@@ -0,0 +1,57 @@
+// maxLinesPerFunction: a function whose body spans many lines is hard
+// to scan and almost always benefits from extraction. ESLint's default
+// is `{ max: 50 }`, which @ttsc/lint mirrors as the only built-in
+// threshold (option-decoding is deferred). The line-span is measured
+// between the opening and closing braces of the function's block body,
+// inclusive, so the count reflects the real footprint a reader sees in
+// the source — including blank lines and comments.
+// https://eslint.org/docs/latest/rules/max-lines-per-function
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// maxLinesPerFunctionLimit is the line-span ceiling. Above this value
+// the rule fires. Mirrors the ESLint default and matches the threshold
+// documented in the README and website MDX.
+const maxLinesPerFunctionLimit = 50
+
+type maxLinesPerFunction struct{}
+
+func (maxLinesPerFunction) Name() string { return "max-lines-per-function" }
+func (maxLinesPerFunction) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+	}
+}
+func (maxLinesPerFunction) Check(ctx *Context, node *shimast.Node) {
+	if node == nil || ctx == nil || ctx.File == nil {
+		return
+	}
+	body := node.Body()
+	if body == nil || body.Kind != shimast.KindBlock {
+		return
+	}
+	startPos := shimscanner.SkipTrivia(ctx.File.Text(), body.Pos())
+	endPos := body.End()
+	if endPos > startPos {
+		endPos--
+	}
+	startLine := shimscanner.GetECMALineOfPosition(ctx.File, startPos)
+	endLine := shimscanner.GetECMALineOfPosition(ctx.File, endPos)
+	lines := endLine - startLine + 1
+	if lines > maxLinesPerFunctionLimit {
+		ctx.Report(node, fmt.Sprintf("Function has too many lines (%d). Maximum allowed is %d.", lines, maxLinesPerFunctionLimit))
+	}
+}
+
+func init() {
+	Register(maxLinesPerFunction{})
+}

package/linthost/rules_max_nested_callbacks.go

@@ -0,0 +1,61 @@
+// maxNestedCallbacks: deeply nested anonymous functions are the
+// classic "callback hell" shape — every new layer pushes the actual
+// work further to the right and makes control-flow harder to follow.
+// ESLint's default ceiling is ten levels of nesting, which @ttsc/lint
+// mirrors as the only built-in threshold (option-decoding is deferred).
+// https://eslint.org/docs/latest/rules/max-nested-callbacks
+//
+// A "callback" here is any function-expression or arrow-function node;
+// named FunctionDeclarations are excluded from the count because the
+// rule targets the anonymous-function nesting shape that produces
+// callback hell, matching ESLint's behavior. Depth counts the current
+// node plus every callback ancestor up to the enclosing source file;
+// FunctionDeclaration boundaries are transparent because ESLint never
+// pushes or pops the stack on them.
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// maxNestedCallbacksLimit is the callback-nesting ceiling. Above this
+// value the rule fires on the innermost callback. Mirrors the ESLint
+// default of 10.
+const maxNestedCallbacksLimit = 10
+
+type maxNestedCallbacks struct{}
+
+func (maxNestedCallbacks) Name() string { return "max-nested-callbacks" }
+func (maxNestedCallbacks) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindArrowFunction,
+		shimast.KindFunctionExpression,
+	}
+}
+func (maxNestedCallbacks) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	// Count this callback plus every callback ancestor up to the
+	// SourceFile. Only ArrowFunction and FunctionExpression
+	// contribute; FunctionDeclaration, methods, and accessors are
+	// transparent because ESLint never pushes or pops its callback
+	// stack on those node kinds.
+	depth := 1
+	for cur := node.Parent; cur != nil; cur = cur.Parent {
+		switch cur.Kind {
+		case shimast.KindArrowFunction, shimast.KindFunctionExpression:
+			depth++
+		}
+	}
+	if depth <= maxNestedCallbacksLimit {
+		return
+	}
+	ctx.Report(node, fmt.Sprintf("Too many nested callbacks (%d). Maximum allowed is %d.", depth, maxNestedCallbacksLimit))
+}
+
+func init() {
+	Register(maxNestedCallbacks{})
+}

package/linthost/rules_max_params.go

@@ -0,0 +1,49 @@
+// maxParams: long parameter lists are almost always a code smell —
+// readers cannot tell at the call site which argument means what, and
+// the function usually wants to receive an options object instead.
+// ESLint's default is `{ max: 3 }`, which @ttsc/lint mirrors as the
+// only built-in threshold (option-decoding is deferred). Every
+// function-like declaration counts: function declarations, function
+// expressions, arrow functions, methods, accessors, and constructors.
+// https://eslint.org/docs/latest/rules/max-params
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// maxParamsLimit is the parameter-count ceiling. Above this value the
+// rule fires. Mirrors the ESLint default and matches the threshold
+// documented in the README and website MDX.
+const maxParamsLimit = 3
+
+type maxParams struct{}
+
+func (maxParams) Name() string { return "max-params" }
+func (maxParams) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+		shimast.KindConstructor,
+	}
+}
+func (maxParams) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	params := node.Parameters()
+	if len(params) <= maxParamsLimit {
+		return
+	}
+	ctx.Report(node, fmt.Sprintf("Function has too many parameters (%d). Maximum allowed is %d.", len(params), maxParamsLimit))
+}
+
+func init() {
+	Register(maxParams{})
+}

package/linthost/rules_max_statements.go

@@ -0,0 +1,59 @@
+// maxStatements: a function whose body contains too many statements is
+// almost always doing more than one job. Splitting it into smaller
+// helpers usually improves both readability and testability. ESLint's
+// default is `{ max: 10 }`, which @ttsc/lint mirrors as the only
+// built-in threshold (option-decoding is deferred). Only the function's
+// own block-body statement list is counted — nested function-like
+// declarations contribute exactly one statement (themselves) regardless
+// of how many statements they internally contain.
+// https://eslint.org/docs/latest/rules/max-statements
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// maxStatementsLimit is the statement-count ceiling. Above this value
+// the rule fires. Mirrors the ESLint default and matches the threshold
+// documented in the README and website MDX.
+const maxStatementsLimit = 10
+
+type maxStatements struct{}
+
+func (maxStatements) Name() string { return "max-statements" }
+func (maxStatements) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+	}
+}
+func (maxStatements) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	body := node.Body()
+	if body == nil || body.Kind != shimast.KindBlock {
+		return
+	}
+	block := body.AsBlock()
+	if block == nil || block.Statements == nil {
+		return
+	}
+	count := 0
+	for _, stmt := range block.Statements.Nodes {
+		if stmt != nil {
+			count++
+		}
+	}
+	if count > maxStatementsLimit {
+		ctx.Report(node, fmt.Sprintf("Function has too many statements (%d). Maximum allowed is %d.", count, maxStatementsLimit))
+	}
+}
+
+func init() {
+	Register(maxStatements{})
+}

package/linthost/rules_misc.go

@@ -47,7 +47,7 @@ func (radix) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-new-wrappers: `new String("")`, `new Number(0)`, `new Boolean(false)`
+// noNewWrappers: `new String("")`, `new Number(0)`, `new Boolean(false)`
 // build wrapper objects rarely intended.
 // https://eslint.org/docs/latest/rules/no-new-wrappers
 type noNewWrappers struct{}