@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_camelcase.go

@@ -0,0 +1,133 @@
+// camelcase reports declaration names that are neither camelCase nor
+// PascalCase. snake_case bindings are the canonical failure: the
+// underscore between two letters signals a non-JavaScript naming
+// convention and the rule pushes authors back to the language norm.
+// https://eslint.org/docs/latest/rules/camelcase
+//
+// Conservative baseline: only the four declaration kinds the ESLint
+// rule documents as in-scope are inspected — variable, function, class,
+// and parameter declarations. Each is checked through its `Name()`
+// accessor so destructuring patterns and computed property names are
+// skipped automatically (they return non-Identifier nodes). Leading
+// and trailing underscores plus a single all-uppercase form
+// (`MAX_VALUE`) are tolerated because ESLint exempts them too.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type camelcase struct{}
+
+func (camelcase) Name() string { return "camelcase" }
+func (camelcase) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindVariableDeclaration,
+		shimast.KindParameter,
+		shimast.KindFunctionDeclaration,
+		shimast.KindClassDeclaration,
+	}
+}
+func (camelcase) Check(ctx *Context, node *shimast.Node) {
+	var nameNode *shimast.Node
+	switch node.Kind {
+	case shimast.KindVariableDeclaration:
+		decl := node.AsVariableDeclaration()
+		if decl == nil {
+			return
+		}
+		nameNode = decl.Name()
+	case shimast.KindParameter:
+		decl := node.AsParameterDeclaration()
+		if decl == nil {
+			return
+		}
+		nameNode = decl.Name()
+	case shimast.KindFunctionDeclaration:
+		decl := node.AsFunctionDeclaration()
+		if decl == nil {
+			return
+		}
+		nameNode = decl.Name()
+	case shimast.KindClassDeclaration:
+		decl := node.AsClassDeclaration()
+		if decl == nil {
+			return
+		}
+		nameNode = decl.Name()
+	}
+	name := identifierText(nameNode)
+	if name == "" {
+		return
+	}
+	if isCamelOrPascalCaseName(name) {
+		return
+	}
+	ctx.Report(nameNode, "Identifier '"+name+"' is not in camelCase.")
+}
+
+// isCamelOrPascalCaseName reports whether `name` matches the convention
+// the rule accepts. The canonical violation is a snake_case binding —
+// an underscore wedged between two letters — so the predicate inspects
+// the trimmed interior of the name. Leading and trailing underscores
+// are stripped first (`_foo`, `foo__`) because ESLint deliberately
+// allows the private-prefix and trailing-underscore conventions. An
+// all-uppercase residue (`MAX_VALUE` → `MAX_VALUE`) is treated as a
+// SCREAMING_SNAKE constant and accepted; everything else with an
+// interior underscore is reported.
+func isCamelOrPascalCaseName(name string) bool {
+	if name == "" {
+		return true
+	}
+	trimmed := trimUnderscores(name)
+	if trimmed == "" {
+		return true
+	}
+	if !containsUnderscore(trimmed) {
+		return true
+	}
+	return isAllUpperOrUnderscore(trimmed)
+}
+
+func trimUnderscores(s string) string {
+	start, end := 0, len(s)
+	for start < end && s[start] == '_' {
+		start++
+	}
+	for end > start && s[end-1] == '_' {
+		end--
+	}
+	return s[start:end]
+}
+
+func containsUnderscore(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] == '_' {
+			return true
+		}
+	}
+	return false
+}
+
+// isAllUpperOrUnderscore returns true when every character is either an
+// uppercase ASCII letter, a digit, or an underscore. Lowercase letters
+// disqualify the string and force the rule to report.
+func isAllUpperOrUnderscore(s string) bool {
+	hasUpper := false
+	for i := 0; i < len(s); i++ {
+		ch := s[i]
+		switch {
+		case ch >= 'A' && ch <= 'Z':
+			hasUpper = true
+		case ch >= '0' && ch <= '9':
+		case ch == '_':
+		default:
+			return false
+		}
+	}
+	return hasUpper
+}
+
+func init() {
+	Register(camelcase{})
+}

package/linthost/rules_complexity.go

@@ -0,0 +1,94 @@
+// complexity: a function whose cyclomatic complexity exceeds the
+// configured limit is almost always doing more than one job — every
+// branching point doubles the number of paths a reader (and a test
+// suite) has to keep in mind. ESLint's default is `{ max: 20 }`, which
+// @ttsc/lint mirrors as the only built-in threshold (option-decoding is
+// deferred). The metric starts at 1 for the function entry path and
+// then adds 1 for each branching construct inside the body:
+//   - `if` (each `else if` parses as a nested IfStatement, so it is
+//     counted by the same arm),
+//   - `case` clauses inside `switch`,
+//   - `catch` clauses on `try`,
+//   - ternary (`?:`) expressions,
+//   - short-circuit operators `&&`, `||`, `??`.
+// Nested function-likes start their own complexity counter and are
+// visited independently, so an inner closure's branches do not
+// inflate the outer function's score.
+// https://eslint.org/docs/latest/rules/complexity
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// complexityLimit is the cyclomatic-complexity ceiling. Above this
+// value the rule fires. Mirrors the ESLint default of 20.
+const complexityLimit = 20
+
+type complexity struct{}
+
+func (complexity) Name() string { return "complexity" }
+func (complexity) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+		shimast.KindConstructor,
+	}
+}
+func (complexity) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	body := node.Body()
+	if body == nil || body.Kind != shimast.KindBlock {
+		return
+	}
+	score := 1
+	walkComplexityBody(body, node, &score)
+	if score > complexityLimit {
+		ctx.Report(node, fmt.Sprintf("Function has a complexity of %d. Maximum allowed is %d.", score, complexityLimit))
+	}
+}
+
+// walkComplexityBody descends through `root` adding 1 to `score` at
+// every branching construct without crossing nested function-like
+// scopes. Each nested function is left for its own visit.
+func walkComplexityBody(node *shimast.Node, fn *shimast.Node, score *int) {
+	if node == nil {
+		return
+	}
+	if node != fn && isFunctionLikeKind(node) {
+		return
+	}
+	switch node.Kind {
+	case shimast.KindIfStatement,
+		shimast.KindCaseClause,
+		shimast.KindCatchClause,
+		shimast.KindConditionalExpression:
+		*score++
+	case shimast.KindBinaryExpression:
+		bin := node.AsBinaryExpression()
+		if bin != nil && bin.OperatorToken != nil {
+			switch bin.OperatorToken.Kind {
+			case shimast.KindAmpersandAmpersandToken,
+				shimast.KindBarBarToken,
+				shimast.KindQuestionQuestionToken:
+				*score++
+			}
+		}
+	}
+	node.ForEachChild(func(child *shimast.Node) bool {
+		walkComplexityBody(child, fn, score)
+		return false
+	})
+}
+
+func init() {
+	Register(complexity{})
+}

package/linthost/rules_consistent_return.go

@@ -0,0 +1,130 @@
+// consistentReturn reports a function whose `return` statements
+// disagree on shape: at least one `return X;` carries a value and at
+// least one bare `return;` (or implicit fall-through from the body)
+// returns nothing. The resulting `T | undefined` return shape almost
+// always indicates a missed branch — readers expect every caller to
+// receive `T`, but a path leaks `undefined`.
+// https://eslint.org/docs/latest/rules/consistent-return
+//
+// Conservative baseline: the walk stops at nested function-like
+// boundaries so an inner closure's `return` does not get attributed
+// to the surrounding function. Constructors are excluded — the
+// language semantics of `return` inside `new`-invoked constructors
+// are governed by `no-constructor-return` instead. Arrow functions
+// with concise (expression-body) form are also excluded because they
+// implicitly return their expression and have no `return` statement
+// to disagree with.
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type consistentReturn struct{}
+
+func (consistentReturn) Name() string { return "consistent-return" }
+func (consistentReturn) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+	}
+}
+func (consistentReturn) Check(ctx *Context, node *shimast.Node) {
+	body := node.Body()
+	if body == nil || body.Kind != shimast.KindBlock {
+		return
+	}
+	withValue := false
+	withoutValue := false
+	walkConsistentReturnBody(body, func(ret *shimast.Node) {
+		stmt := ret.AsReturnStatement()
+		if stmt == nil {
+			return
+		}
+		if stmt.Expression != nil {
+			withValue = true
+		} else {
+			withoutValue = true
+		}
+	})
+	if withValue && withoutValue {
+		ctx.Report(node, "Function expected to either always or never specify a return value.")
+		return
+	}
+	// A function that returns a value on at least one path but can
+	// also fall through the end of its block leaks an implicit
+	// `undefined`. Flag it the same as the explicit mix above.
+	if withValue && !blockAlwaysExits(body) {
+		ctx.Report(node, "Function expected to either always or never specify a return value.")
+	}
+}
+
+// walkConsistentReturnBody visits every `return` statement inside
+// `root` without crossing nested function-like scopes. Nested
+// function-likes report their own returns through their own visit.
+func walkConsistentReturnBody(root *shimast.Node, visit func(*shimast.Node)) {
+	if root == nil {
+		return
+	}
+	var walk func(*shimast.Node)
+	walk = func(n *shimast.Node) {
+		if n == nil {
+			return
+		}
+		if n != root && isFunctionLikeKind(n) {
+			return
+		}
+		if n.Kind == shimast.KindReturnStatement {
+			visit(n)
+			return
+		}
+		n.ForEachChild(func(child *shimast.Node) bool {
+			walk(child)
+			return false
+		})
+	}
+	walk(root)
+}
+
+// blockAlwaysExits reports whether a function-body block can never
+// fall off its end — every reachable path terminates with `return`,
+// `throw`, or a nested block / `if` whose branches all terminate.
+// Mirrors the shallow approximation `getter-return` uses.
+func blockAlwaysExits(body *shimast.Node) bool {
+	if body == nil || body.Kind != shimast.KindBlock {
+		return false
+	}
+	stmts := body.Statements()
+	if len(stmts) == 0 {
+		return false
+	}
+	return statementAlwaysExits(stmts[len(stmts)-1])
+}
+
+// statementAlwaysExits reports whether `stmt` cannot fall through to
+// the next statement: a `return`, a `throw`, a block ending in either
+// of those, or an `if` whose branches both terminate.
+func statementAlwaysExits(stmt *shimast.Node) bool {
+	if stmt == nil {
+		return false
+	}
+	switch stmt.Kind {
+	case shimast.KindReturnStatement, shimast.KindThrowStatement:
+		return true
+	case shimast.KindBlock:
+		return blockAlwaysExits(stmt)
+	case shimast.KindIfStatement:
+		ifStmt := stmt.AsIfStatement()
+		if ifStmt == nil || ifStmt.ThenStatement == nil || ifStmt.ElseStatement == nil {
+			return false
+		}
+		return statementAlwaysExits(ifStmt.ThenStatement) && statementAlwaysExits(ifStmt.ElseStatement)
+	}
+	return false
+}
+
+func init() {
+	Register(consistentReturn{})
+}

package/linthost/rules_console.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-console: forbid `console.*` calls. This implementation models the
+// noConsole: forbid `console.*` calls. This implementation models the
 // default rule shape and flags every console method.
 // https://eslint.org/docs/latest/rules/no-console
 type noConsole struct{}