@ttsc/lint 0.18.4 → 0.19.0

package/linthost/rules_gap.go

@@ -9,7 +9,11 @@
 package linthost
 
 import (
+  "path/filepath"
+  "strings"
+
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimcore "github.com/microsoft/typescript-go/shim/core"
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
@@ -27,8 +31,11 @@ func (noEmptyStaticBlock) Check(ctx *Context, node *shimast.Node) {
     return
   }
   body := block.Body.AsBlock()
-  if body == nil || body.Statements == nil || len(body.Statements.Nodes) == 0 {
-    ctx.Report(node, "Unexpected empty static block.")
+  if body == nil || body.Statements != nil && len(body.Statements.Nodes) != 0 {
+    return
+  }
+  if !emptyBracedBodyHasComment(ctx.File, block.Body) {
+    ctx.Report(block.Body, "Unexpected empty static block.")
   }
 }
 
@@ -177,13 +184,48 @@ func (noUnnecessaryTypeConstraint) Check(ctx *Context, node *shimast.Node) {
     ctx.Report(param.Constraint, message)
     return
   }
+  replacement := ""
+  if requiresGenericArrowDisambiguation(ctx, node, param) {
+    replacement = ","
+  }
   ctx.ReportFix(
     param.Constraint,
     message,
-    TextEdit{Pos: name.End(), End: param.Constraint.End(), Text: ""},
+    TextEdit{Pos: name.End(), End: param.Constraint.End(), Text: replacement},
   )
 }
 
+// requiresGenericArrowDisambiguation reports whether deleting a redundant
+// constraint would leave a single generic arrow looking like JSX or another
+// reserved generic declaration. TypeScript-ESLint uses this same extension
+// boundary for TSX and the explicit Node module source modes.
+func requiresGenericArrowDisambiguation(
+  ctx *Context,
+  node *shimast.Node,
+  param *shimast.TypeParameterDeclaration,
+) bool {
+  if ctx == nil || ctx.File == nil || node == nil || param == nil ||
+    node.Parent == nil || node.Parent.Kind != shimast.KindArrowFunction {
+    return false
+  }
+  requiresDisambiguation := ctx.File.ScriptKind == shimcore.ScriptKindTSX
+  if !requiresDisambiguation {
+    switch strings.ToLower(filepath.Ext(ctx.File.FileName())) {
+    case ".mts", ".cts":
+      requiresDisambiguation = true
+    }
+  }
+  if !requiresDisambiguation {
+    return false
+  }
+  typeParameters := node.Parent.TypeParameterList()
+  return typeParameters != nil &&
+    len(typeParameters.Nodes) == 1 &&
+    typeParameters.Nodes[0] == node &&
+    !typeParameters.HasTrailingComma() &&
+    param.DefaultType == nil
+}
+
 // noUnsafeFunctionType: `Function` accepts any callable shape.
 // typescript-eslint recommended: https://typescript-eslint.io/rules/no-unsafe-function-type/
 type noUnsafeFunctionType struct{}
@@ -518,11 +560,28 @@ func (dotNotation) Check(ctx *Context, node *shimast.Node) {
   } else {
     replaceFrom = access.Expression.End()
     replacement = "." + key
+    // A bare decimal-integer receiver lexes an immediately following `.` as
+    // the number's own decimal point, so `5["toString"]` → `5.toString` is a
+    // syntax error (TS1351). Emit a separating space (`5 .toString`) exactly
+    // where ESLint's dot-notation does. Parenthesized `(5)`, hex/octal/binary,
+    // float, exponent, and bigint receivers all take `.` as member access
+    // cleanly, so they keep the dot tight.
+    if access.Expression.Kind == shimast.KindNumericLiteral &&
+      isDecimalIntegerLiteralText(nodeText(ctx.File, access.Expression)) {
+      replacement = " " + replacement
+    }
   }
   if replaceFrom < 0 || replaceFrom >= node.End() {
     ctx.Report(node, message)
     return
   }
+  // A comment inside the replaced `[…]` tail (`p1 /* keep */ ["foo"]`) would be
+  // silently deleted by the splice. Decline to a report-only diagnostic,
+  // matching ESLint dot-notation's `commentsExistBetween` guard.
+  if hasCommentBetween(src, replaceFrom, node.End()) {
+    ctx.Report(node, message)
+    return
+  }
   ctx.ReportFix(
     node,
     message,
@@ -530,6 +589,24 @@ func (dotNotation) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
+// isDecimalIntegerLiteralText reports whether raw is a numeric literal written
+// as a plain decimal integer — ASCII digits with optional `_` separators and
+// no radix prefix, decimal point, exponent, or bigint `n` suffix. A `.`
+// spliced directly after such a receiver is lexed as the number's own decimal
+// point (`5["x"]` → `5.x` is a SyntaxError), so dot-notation inserts a
+// separating space. Mirrors ESLint astUtils.isDecimalInteger.
+func isDecimalIntegerLiteralText(raw string) bool {
+  if raw == "" {
+    return false
+  }
+  for i := 0; i < len(raw); i++ {
+    if c := raw[i]; (c < '0' || c > '9') && c != '_' {
+      return false
+    }
+  }
+  return true
+}
+
 // isReservedWord reports whether `value` is an ECMAScript reserved word. The
 // `dot-notation` autofix uses this to skip the rewrite even though modern
 // parsers accept reserved-word member names: leaving bracket access matches

package/linthost/rules_grouped_accessor_pairs.go

@@ -1,31 +1,42 @@
 // groupedAccessorPairs: a `get` and `set` accessor that share the same
-// property name should be declared next to each other in the class
-// body. When the pair is split apart by unrelated members, a reader
-// scanning the class has to chase the read and write halves separately
-// — and patches to one half are easy to make without noticing the
-// other.
+// property name should be declared next to each other, whether they sit
+// in a class body or an object literal. When the pair is split apart by
+// unrelated members, a reader scanning the declaration has to chase the
+// read and write halves separately — and patches to one half are easy to
+// make without noticing the other.
 //
-// AST-only: walk every class declaration/expression, group members by
-// (name, static-ness), and for any group that contains both a getter
-// and a setter check that their member indices are adjacent. The
-// second-encountered half is the one reported, because the first half
-// reads correctly until the reader hits the second declaration.
+// AST-only: walk every class declaration/expression and object literal,
+// group members by (name, static-ness), and for any group that contains
+// both a getter and a setter check that their member indices are
+// adjacent. The second-encountered half is the one reported, because the
+// first half reads correctly until the reader hits the second
+// declaration.
+//
+// The optional order option (`anyOrder` (the default), `getBeforeSet`, or
+// `setBeforeGet`) additionally pins the relative order of an already
+// adjacent pair, mirroring upstream's `invalidOrder` diagnostic.
 // https://eslint.org/docs/latest/rules/grouped-accessor-pairs
 package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-type groupedAccessorPairs struct{}
+type groupedAccessorPairs struct{ optionsRule }
 
 func (groupedAccessorPairs) Name() string { return "grouped-accessor-pairs" }
 func (groupedAccessorPairs) Visits() []shimast.Kind {
-  return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
+  return []shimast.Kind{
+    shimast.KindClassDeclaration,
+    shimast.KindClassExpression,
+    shimast.KindObjectLiteralExpression,
+  }
 }
 func (groupedAccessorPairs) Check(ctx *Context, node *shimast.Node) {
-  members := classMembers(node)
+  members := groupedAccessorMembers(node)
   if len(members) < 2 {
     return
   }
+  order := groupedAccessorOrder(ctx)
+
   type slot struct {
     name   string
     static bool
@@ -35,7 +46,10 @@ func (groupedAccessorPairs) Check(ctx *Context, node *shimast.Node) {
     kind  shimast.Kind
     node  *shimast.Node
   }
-  groups := map[slot][]entry{}
+  // Track first-seen group order so multiple pairs report deterministically;
+  // a Go map's iteration order is randomized.
+  groups := map[slot]*[]entry{}
+  var groupOrder []slot
   for i, member := range members {
     if member == nil {
       continue
@@ -48,9 +62,14 @@ func (groupedAccessorPairs) Check(ctx *Context, node *shimast.Node) {
       continue
     }
     key := slot{name: name, static: hasModifier(member, shimast.KindStaticKeyword)}
-    groups[key] = append(groups[key], entry{index: i, kind: member.Kind, node: member})
+    if groups[key] == nil {
+      groups[key] = &[]entry{}
+      groupOrder = append(groupOrder, key)
+    }
+    *groups[key] = append(*groups[key], entry{index: i, kind: member.Kind, node: member})
   }
-  for _, entries := range groups {
+  for _, key := range groupOrder {
+    entries := *groups[key]
     if len(entries) < 2 {
       continue
     }
@@ -67,21 +86,61 @@ func (groupedAccessorPairs) Check(ctx *Context, node *shimast.Node) {
     if get == nil || set == nil {
       continue
     }
-    // Adjacent indices in the members list satisfy the rule.
-    diff := get.index - set.index
-    if diff == 1 || diff == -1 {
+    former, later := get, set
+    if set.index < get.index {
+      former, later = set, get
+    }
+    // Non-adjacent indices in the members list break the rule.
+    if later.index-former.index > 1 {
+      // Report on whichever half appears later — the earlier one
+      // reads fine in isolation; the later one is the surprise.
+      ctx.Report(later.node, "Accessor pair should be grouped.")
       continue
     }
-    // Report on whichever half appears later — the earlier one
-    // reads fine in isolation; the later one is the surprise.
-    later := get
-    if set.index > get.index {
-      later = set
+    // The pair is adjacent; enforce the requested order, if any.
+    if (order == "getBeforeSet" && former.kind == shimast.KindSetAccessor) ||
+      (order == "setBeforeGet" && former.kind == shimast.KindGetAccessor) {
+      ctx.Report(later.node, "Expected "+accessorRole(later.kind)+" to be before "+accessorRole(former.kind)+".")
     }
-    ctx.Report(later.node, "Accessor pair should be grouped.")
   }
 }
 
+// groupedAccessorMembers returns the ordered member list the rule scans for
+// a class body (its members) or an object literal (its properties). Any
+// other node kind yields nil so the multi-visit rule can bail cheaply.
+func groupedAccessorMembers(node *shimast.Node) []*shimast.Node {
+  if node != nil && node.Kind == shimast.KindObjectLiteralExpression {
+    if obj := node.AsObjectLiteralExpression(); obj != nil && obj.Properties != nil {
+      return obj.Properties.Nodes
+    }
+    return nil
+  }
+  return classMembers(node)
+}
+
+// groupedAccessorOrder resolves the positional order option. A single
+// positional slot is transported as a bare JSON string (see
+// RuleOptionsMap); any unknown or absent value falls back to `anyOrder`,
+// which disables the ordering check.
+func groupedAccessorOrder(ctx *Context) string {
+  var order string
+  _ = ctx.DecodeOptions(&order)
+  switch order {
+  case "getBeforeSet", "setBeforeGet":
+    return order
+  default:
+    return "anyOrder"
+  }
+}
+
+// accessorRole names an accessor half for the `invalidOrder` message.
+func accessorRole(kind shimast.Kind) string {
+  if kind == shimast.KindSetAccessor {
+    return "setter"
+  }
+  return "getter"
+}
+
 func init() {
   Register(groupedAccessorPairs{})
 }

package/linthost/rules_guard_for_in.go

@@ -1,18 +1,24 @@
 // guardForIn: `for (key in obj)` walks the prototype chain and yields
 // every enumerable name, inherited or own. Most authors only ever care
 // about own keys, so an unguarded body silently leaks work onto
-// prototype-chain entries someone else attached. The canonical guard is
-// `if (Object.hasOwn(obj, key))` or the older
-// `Object.prototype.hasOwnProperty.call(obj, key)`; an inverted-guard
-// `continue` (`if (!Object.hasOwn(...)) continue;`) is the equivalent
-// early-skip shape.
+// prototype-chain entries someone else attached.
 //
-// Conservative baseline: the rule only inspects the FIRST executable
-// statement of the loop body. The body either opens with a guard
-// covering everything that follows, or it does not — anything more
-// nuanced is the developer's responsibility. The guard expression must
-// reference the loop's own key binding; a hard-coded call on an
-// unrelated identifier is not a real guard.
+// Ported from ESLint's `guard-for-in`, the check is purely STRUCTURAL:
+// it never inspects what the guard `if` tests, only the SHAPE of the
+// loop body. The body is accepted when it is one of five shapes,
+// mirroring upstream's ordered early-returns exactly:
+//
+//  1. an empty statement (`for (k in o);`);
+//  2. a bare `if` statement (`for (k in o) if (...) ...;`);
+//  3. an empty block (`{}`);
+//  4. a block whose sole statement is an `if`;
+//  5. a block whose leading statement is an `if` whose consequent is a
+//     `continue` (bare, or a block containing only `continue`).
+//
+// Anything else is reported. Because the condition is never examined,
+// `if (obj.hasOwnProperty(key))`, `if (Object.hasOwn(obj, key))`,
+// `if (cond)`, and `if (key.startsWith("_")) continue;` are all
+// accepted, matching ESLint.
 // https://eslint.org/docs/latest/rules/guard-for-in
 package linthost
 
@@ -29,168 +35,79 @@ func (guardForIn) Check(ctx *Context, node *shimast.Node) {
   if stmt == nil || stmt.Statement == nil {
     return
   }
-  first := firstBodyStatement(stmt.Statement)
-  if first == nil {
-    return
-  }
-  key := forInKeyName(stmt.Initializer)
-  if isHasOwnGuard(first, key) {
+  if isGuardedForInBody(stmt.Statement) {
     return
   }
-  ctx.Report(node, "The body of a `for...in` should be wrapped in an `if (Object.hasOwn(...))` statement to filter unwanted properties from the prototype.")
+  ctx.Report(node, "The body of a `for...in` should be wrapped in an `if` statement to filter unwanted properties from the prototype.")
 }
 
-// firstBodyStatement returns the first executable statement inside a
-// loop body. A block body unwraps to its first statement; a bare
-// non-block body is itself the only statement. Returns nil for an
-// empty block — an empty body cannot leak inherited keys.
-func firstBodyStatement(body *shimast.Node) *shimast.Node {
-  if body == nil {
-    return nil
-  }
-  if body.Kind != shimast.KindBlock {
-    return body
+// isGuardedForInBody reports whether a `for...in` loop body has one of
+// the five structural shapes ESLint's guard-for-in accepts. It mirrors
+// upstream's ordered early-returns and deliberately never inspects the
+// guard condition.
+func isGuardedForInBody(body *shimast.Node) bool {
+  switch body.Kind {
+  case shimast.KindEmptyStatement:
+    // `for (k in o);` — an empty body cannot leak inherited keys.
+    return true
+  case shimast.KindIfStatement:
+    // `for (k in o) if (...) ...;` — a bare `if` body is itself the
+    // guard, whatever it tests.
+    return true
+  case shimast.KindBlock:
+    // Fall through to the block-shape analysis below.
+  default:
+    return false
   }
+
   block := body.AsBlock()
   if block == nil || block.Statements == nil {
-    return nil
-  }
-  for _, s := range block.Statements.Nodes {
-    if s != nil {
-      return s
-    }
-  }
-  return nil
-}
-
-// forInKeyName extracts the identifier text of the loop key from a
-// `for (… in obj)` initializer. The initializer is either a
-// VariableDeclarationList with one declaration (`for (const key in …)`)
-// or a bare Identifier (`for (key in …)`). Destructuring patterns and
-// other shapes return "" so the rule skips its key-identity check.
-func forInKeyName(init *shimast.Node) string {
-  if init == nil {
-    return ""
-  }
-  if name := identifierText(init); name != "" {
-    return name
-  }
-  if init.Kind != shimast.KindVariableDeclarationList {
-    return ""
-  }
-  list := init.AsVariableDeclarationList()
-  if list == nil || list.Declarations == nil || len(list.Declarations.Nodes) != 1 {
-    return ""
-  }
-  decl := list.Declarations.Nodes[0]
-  if decl == nil {
-    return ""
-  }
-  v := decl.AsVariableDeclaration()
-  if v == nil {
-    return ""
-  }
-  return identifierText(v.Name())
-}
-
-// isHasOwnGuard reports whether `stmt` is the canonical own-key guard
-// that should open a `for...in` body. Two shapes count:
-//
-//  1. `if (<has-own>(obj, key)) { … }` — positive guard wrapping the
-//     real body. The else branch (if any) is allowed because the
-//     developer has explicitly handled the inherited-key case.
-//  2. `if (!<has-own>(obj, key)) continue;` — inverted-guard early
-//     skip. The then branch must be a single `continue` (with or
-//     without a block wrapper) so the rest of the loop body only runs
-//     for own keys.
-//
-// `<has-own>` is either `Object.hasOwn(obj, key)` or
-// `Object.prototype.hasOwnProperty.call(obj, key)`. The second
-// argument must match `key` when one was extracted from the
-// initializer; otherwise any second argument is accepted (the rule
-// has no reliable handle on the key name).
-func isHasOwnGuard(stmt *shimast.Node, key string) bool {
-  if stmt == nil || stmt.Kind != shimast.KindIfStatement {
-    return false
-  }
-  ifStmt := stmt.AsIfStatement()
-  if ifStmt == nil || ifStmt.Expression == nil {
-    return false
-  }
-  cond := stripParens(ifStmt.Expression)
-  if cond == nil {
-    return false
-  }
-  if isHasOwnCall(cond, key) {
+    // A block with no statement list behaves like an empty block.
     return true
   }
-  if cond.Kind != shimast.KindPrefixUnaryExpression {
-    return false
-  }
-  pre := cond.AsPrefixUnaryExpression()
-  if pre == nil || pre.Operator != shimast.KindExclamationToken {
-    return false
-  }
-  if !isHasOwnCall(stripParens(pre.Operand), key) {
-    return false
-  }
-  // Negated guard: require the then branch to be a single `continue`
-  // so the rest of the loop runs only for own keys.
-  return isLoneContinue(ifStmt.ThenStatement)
-}
-
-// isHasOwnCall reports whether `node` is `Object.hasOwn(obj, key)` or
-// `Object.prototype.hasOwnProperty.call(obj, key)`. The second
-// argument must match `key` when one is supplied.
-func isHasOwnCall(node *shimast.Node, key string) bool {
-  if node == nil || node.Kind != shimast.KindCallExpression {
-    return false
+  stmts := block.Statements.Nodes
+  // Empty block.
+  if len(stmts) == 0 {
+    return true
   }
-  call := node.AsCallExpression()
-  if call == nil || call.Expression == nil || call.Arguments == nil {
+  // Every remaining accepted shape opens with an `if`.
+  lead := stmts[0]
+  if lead == nil || lead.Kind != shimast.KindIfStatement {
     return false
   }
-  args := call.Arguments.Nodes
-  if len(args) < 2 {
-    return false
+  // Block whose sole statement is an `if`.
+  if len(stmts) == 1 {
+    return true
   }
-  callee := stripParens(call.Expression)
-  switch {
-  case isMatchingPropertyAccess(callee, "Object", "hasOwn"):
-    // `Object.hasOwn(obj, key)` — both arguments belong to the
-    // caller; the key check is the second argument.
-  case isMatchingPropertyAccess(callee, "Object", "prototype", "hasOwnProperty", "call"):
-    // `Object.prototype.hasOwnProperty.call(obj, key)` — same
-    // argument layout because `.call(obj, key)` passes the
-    // receiver explicitly.
-  default:
+  // Block that opens with an `if` whose consequent is a `continue`, so
+  // the statements after it run only for retained keys.
+  ifStmt := lead.AsIfStatement()
+  if ifStmt == nil {
     return false
   }
-  if key == "" {
-    return true
-  }
-  return identifierText(stripParens(args[1])) == key
+  return isContinueConsequent(ifStmt.ThenStatement)
 }
 
-// isLoneContinue reports whether `stmt` is a bare `continue;` (or a
-// block containing exactly one `continue;`). Used to validate the
-// then-branch of the negated-guard shape.
-func isLoneContinue(stmt *shimast.Node) bool {
-  if stmt == nil {
+// isContinueConsequent reports whether an `if` consequent is a
+// `continue` statement, either bare (`continue;`) or a block whose sole
+// statement is `continue;`. Mirrors ESLint's check on the leading
+// guard's consequent.
+func isContinueConsequent(consequent *shimast.Node) bool {
+  if consequent == nil {
     return false
   }
-  if stmt.Kind == shimast.KindContinueStatement {
+  if consequent.Kind == shimast.KindContinueStatement {
     return true
   }
-  if stmt.Kind != shimast.KindBlock {
+  if consequent.Kind != shimast.KindBlock {
     return false
   }
-  block := stmt.AsBlock()
+  block := consequent.AsBlock()
   if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
     return false
   }
-  return block.Statements.Nodes[0] != nil &&
-    block.Statements.Nodes[0].Kind == shimast.KindContinueStatement
+  only := block.Statements.Nodes[0]
+  return only != nil && only.Kind == shimast.KindContinueStatement
 }
 
 func init() {