@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

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{})
+}

package/linthost/rules_ts_switch_exhaustiveness_check.go

@@ -0,0 +1,147 @@
+// switchExhaustivenessCheck reports `switch (e)` statements where the
+// discriminant is a union of literal types or an enum and at least one
+// constituent has no matching `case` clause AND the switch carries no
+// `default` clause. Either covering every member explicitly or adding a
+// `default` arm makes the intent visible and forces the compiler to
+// flag any future addition to the union/enum at every switch site.
+// typescript-eslint strict-type-checked:
+// https://typescript-eslint.io/rules/switch-exhaustiveness-check/
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// switchExhaustivenessCheck is type-aware: the discriminant is resolved
+// via the Checker, and uncovered members are computed by removing every
+// case-clause expression's type from the union's constituent set. The
+// rule only fires when the discriminant resolves to a union — plain
+// `string` or `number` discriminants are open-ended and outside the
+// rule's scope, matching typescript-eslint's behavior.
+//
+// Identity is established by `*Type` pointer comparison rather than
+// literal value comparison: TypeScript canonicalizes string and number
+// literal types (`stringLiteralTypes` / `numberLiteralTypes` maps inside
+// the checker), so two references to `"a"` resolve to the same `*Type`
+// instance. Enum literal types are likewise canonicalized per enum
+// member, so `case E.A:` and the `E.A` constituent of the discriminant's
+// union share their `*Type` pointer.
+type switchExhaustivenessCheck struct{}
+
+func (switchExhaustivenessCheck) Name() string { return "typescript/switch-exhaustiveness-check" }
+func (switchExhaustivenessCheck) NeedsTypeChecker() bool {
+  return true
+}
+func (switchExhaustivenessCheck) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSwitchStatement}
+}
+func (switchExhaustivenessCheck) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  sw := node.AsSwitchStatement()
+  if sw == nil || sw.Expression == nil || sw.CaseBlock == nil {
+    return
+  }
+  block := sw.CaseBlock.AsCaseBlock()
+  if block == nil || block.Clauses == nil {
+    return
+  }
+  // A `default` clause covers anything not enumerated above, so the
+  // rule has nothing to add. typescript-eslint also exits early in
+  // this case.
+  for _, clause := range block.Clauses.Nodes {
+    if clause != nil && clause.Kind == shimast.KindDefaultClause {
+      return
+    }
+  }
+  discriminantType := ctx.Checker.GetTypeAtLocation(sw.Expression)
+  if discriminantType == nil {
+    return
+  }
+  // Only consider discriminants whose static type is a finite union of
+  // literal-like constituents. Plain `string` / `number` / `unknown`
+  // are open-ended and never exhaustively coverable.
+  members := switchExhaustivenessCheckCollectMembers(discriminantType)
+  if len(members) == 0 {
+    return
+  }
+  covered := make(map[*shimchecker.Type]bool, len(members))
+  for _, clause := range block.Clauses.Nodes {
+    if clause == nil || clause.Kind != shimast.KindCaseClause {
+      continue
+    }
+    caseClause := clause.AsCaseOrDefaultClause()
+    if caseClause == nil || caseClause.Expression == nil {
+      continue
+    }
+    caseType := ctx.Checker.GetTypeAtLocation(caseClause.Expression)
+    if caseType == nil {
+      continue
+    }
+    covered[caseType] = true
+  }
+  missing := 0
+  for _, member := range members {
+    if !covered[member] {
+      missing++
+    }
+  }
+  if missing == 0 {
+    return
+  }
+  ctx.Report(node, "Switch is not exhaustive. Cases not matched: add a `case` for every union/enum member, or include a `default` clause.")
+}
+
+// switchExhaustivenessCheckCollectMembers returns the finite literal /
+// enum-literal constituents of t when t is a discriminable union, and
+// nil when t is open-ended (plain `string`, `number`, `any`, `unknown`,
+// etc.). A union whose constituents are all literals or enum literals
+// is treated as exhaustively coverable; any non-literal constituent
+// (e.g. `string` mixed into `"a" | "b" | string`) widens the union and
+// disqualifies the whole discriminant.
+func switchExhaustivenessCheckCollectMembers(t *shimchecker.Type) []*shimchecker.Type {
+  if t == nil {
+    return nil
+  }
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsUnion == 0 {
+    return nil
+  }
+  parts := t.Types()
+  if len(parts) == 0 {
+    return nil
+  }
+  members := make([]*shimchecker.Type, 0, len(parts))
+  for _, part := range parts {
+    if part == nil {
+      return nil
+    }
+    if !switchExhaustivenessCheckIsLiteralLike(part) {
+      return nil
+    }
+    members = append(members, part)
+  }
+  return members
+}
+
+// switchExhaustivenessCheckIsLiteralLike reports whether t is a
+// constituent that participates in finite enumeration: a unit type
+// (string/number/bigint/boolean literal), an enum literal, or one of
+// the nullish singletons. The matching set mirrors typescript-eslint's
+// `lib.isTypeFlagSet(constituent, TypeFlags.Literal | ...)` filter.
+func switchExhaustivenessCheckIsLiteralLike(t *shimchecker.Type) bool {
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsLiteral != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsUndefined|shimchecker.TypeFlagsNull|shimchecker.TypeFlagsVoid) != 0 {
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(switchExhaustivenessCheck{})
+}

package/linthost/rules_ts_unbound_method.go

@@ -0,0 +1,126 @@
+// unboundMethod reports a property access that names a class instance
+// method but is used as a value instead of being immediately invoked.
+// JavaScript methods are not bound to their receiver — `obj.method`,
+// once extracted, loses the `this` binding the body relies on, so
+// passing it as a callback (`setTimeout(obj.method, 0)`) or aliasing
+// it (`const f = obj.method`) silently breaks at the first `this.x`
+// dereference. typescript-eslint:
+// https://typescript-eslint.io/rules/unbound-method/
+//
+// Type-aware. The Checker resolves the property's symbol; the rule
+// fires when any of the symbol's declarations is a class
+// MethodDeclaration. The conservative baseline skips:
+//
+//   - the callee position of a call (`obj.method()` is fine);
+//   - the left-hand side of an assignment (`obj.method = fn`);
+//   - the operand of `typeof`, `delete`, `instanceof`, and `in`;
+//   - tagged-template tag positions;
+//   - static methods (the constructor that owns them is stably bound);
+//   - methods declared only as MethodSignature on an interface or
+//     type literal (those are structural — the runtime value may be a
+//     plain function property, and flagging them at every consumer
+//     produces too many false positives).
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unboundMethod struct{}
+
+func (unboundMethod) Name() string { return "typescript/unbound-method" }
+func (unboundMethod) NeedsTypeChecker() bool {
+  return true
+}
+func (unboundMethod) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unboundMethod) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  access := node.AsPropertyAccessExpression()
+  if access == nil || access.Name() == nil {
+    return
+  }
+  if unboundMethodSafePosition(node) {
+    return
+  }
+  symbol := ctx.Checker.GetSymbolAtLocation(access.Name())
+  if symbol == nil {
+    return
+  }
+  if !unboundMethodSymbolIsClassMethod(symbol) {
+    return
+  }
+  ctx.Report(node, "Avoid referencing an unbound method which may cause unintentional scoping of `this`.")
+}
+
+// unboundMethodSafePosition reports whether the property access sits in
+// a syntactic position that already discharges the unbound-method risk.
+// The list mirrors typescript-eslint's safe-position whitelist: an
+// immediately-invoked call, an assignment target, a typeof / delete
+// operand, an instanceof / in operand, and a tagged-template tag are
+// all positions where the method reference is consumed in place rather
+// than carried away as a free function value.
+func unboundMethodSafePosition(node *shimast.Node) bool {
+  parent := node.Parent
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindCallExpression:
+    call := parent.AsCallExpression()
+    if call != nil && call.Expression == node {
+      return true
+    }
+  case shimast.KindTaggedTemplateExpression:
+    return true
+  case shimast.KindBinaryExpression:
+    bin := parent.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return false
+    }
+    switch bin.OperatorToken.Kind {
+    case shimast.KindEqualsToken,
+      shimast.KindInstanceOfKeyword,
+      shimast.KindInKeyword:
+      return true
+    }
+  case shimast.KindTypeOfExpression, shimast.KindDeleteExpression:
+    return true
+  }
+  return false
+}
+
+// unboundMethodSymbolIsClassMethod reports whether symbol denotes a
+// non-static class instance method. The rule ignores plain method
+// signatures on interfaces and type literals because those are
+// structural — the runtime value may be a regular function rather
+// than a bound class member, and flagging them at every consumer
+// would produce a high false-positive volume. Static methods slip
+// past this check because they are accessed through the class
+// constructor itself, which is bound for the lifetime of the
+// program.
+func unboundMethodSymbolIsClassMethod(symbol *shimast.Symbol) bool {
+  if symbol == nil {
+    return false
+  }
+  for _, decl := range symbol.Declarations {
+    if decl == nil {
+      continue
+    }
+    if decl.Kind != shimast.KindMethodDeclaration {
+      continue
+    }
+    if hasModifier(decl, shimast.KindStaticKeyword) {
+      continue
+    }
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(unboundMethod{})
+}