@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_complexity.go

@@ -0,0 +1,95 @@
+// 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{}