@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_ts_prefer_reduce_type_parameter.go

@@ -0,0 +1,116 @@
+// typescript/prefer-reduce-type-parameter: when `arr.reduce(cb, init)`
+// is called with an `as`-asserted initial value, fix the accumulator
+// type at the call site via `arr.reduce<T>(cb, init)` instead. The
+// type-parameter form binds the accumulator before the callback infers
+// its parameter types from the seed, so the callback sees the intended
+// type instead of the seed's widened literal shape. typescript-eslint:
+// https://typescript-eslint.io/rules/prefer-reduce-type-parameter/
+//
+// Type-aware. Without a Checker the rule cannot prove the receiver of
+// `.reduce` is an array or tuple — user types named `reduce` are
+// common (`Map#reduce`, custom accumulators, etc.) and assertion-on-
+// initial-value is occasionally idiomatic there. The receiver must be
+// a provable array or tuple; generics, `any`, `unknown`, and `never`
+// pass through to keep generic helpers quiet.
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type preferReduceTypeParameter struct{}
+
+func (preferReduceTypeParameter) Name() string {
+  return "typescript/prefer-reduce-type-parameter"
+}
+func (preferReduceTypeParameter) NeedsTypeChecker() bool {
+  return true
+}
+func (preferReduceTypeParameter) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (preferReduceTypeParameter) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  // `arr.reduce<T>(...)` already pins the accumulator at the call
+  // site — the rule has nothing left to suggest.
+  if call.TypeArguments != nil && len(call.TypeArguments.Nodes) > 0 {
+    return
+  }
+  // The call must be `<receiver>.reduce(callback, initial)` — the
+  // two-argument form whose seed is the accumulator. The single-
+  // argument `arr.reduce(cb)` shape has no seed to assert against.
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+    return
+  }
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if !ok || method != "reduce" {
+    return
+  }
+  initial := stripParens(call.Arguments.Nodes[1])
+  if initial == nil {
+    return
+  }
+  // The initial value must carry an explicit type assertion that the
+  // rule can hoist into the call's type parameter list. Both the
+  // canonical `init as T` form and the legacy `<T>init` form qualify.
+  if initial.Kind != shimast.KindAsExpression && initial.Kind != shimast.KindTypeAssertionExpression {
+    return
+  }
+  if receiver == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(receiver)
+  if t == nil {
+    return
+  }
+  if !preferReduceIsArrayOrTuple(ctx.Checker, t) {
+    return
+  }
+  ctx.Report(initial, preferReduceMessage)
+}
+
+const preferReduceMessage = "Pass the accumulator type to `reduce` as a type parameter — `arr.reduce<T>(cb, init)` — instead of asserting on the initial value."
+
+// preferReduceIsArrayOrTuple reports whether t is provably an array or
+// tuple. Mirrors `preferIncludesIsArrayOrString` but excludes strings
+// (which have no `.reduce`). Generics, `any`, `unknown`, and `never`
+// intentionally fail closed so the rule does not blow up on generic
+// helpers whose receiver type leaks downward.
+func preferReduceIsArrayOrTuple(checker *shimchecker.Checker, t *shimchecker.Type) bool {
+  if checker == nil || 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 !preferReduceIsArrayOrTuple(checker, part) {
+        return false
+      }
+    }
+    return true
+  }
+  if shimchecker.Checker_isArrayType(checker, t) {
+    return true
+  }
+  if shimchecker.IsTupleType(t) {
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(preferReduceTypeParameter{})
+}

package/linthost/rules_ts_prefer_regexp_exec.go

@@ -0,0 +1,122 @@
+// typescript/prefer-regexp-exec: prefer `re.exec(str)` over
+// `str.match(re)` when the regex has no `g` flag. Both shapes return
+// the same `RegExpExecArray | null` for first-match queries, but
+// `String#match` silently switches to "every match" the moment the
+// regex gains the `g` flag — a typo at the regex literal can change
+// the call's return shape from `[fullMatch, ...captures]` to a flat
+// `string[]` of matches. `RegExp#exec` is the stable form.
+// typescript-eslint:
+// https://typescript-eslint.io/rules/prefer-regexp-exec/
+//
+// Type-aware. Without a Checker the rule cannot prove the receiver of
+// `match` is string-like, so Context.Checker == nil short-circuits each
+// Check to a no-op the way `prefer-includes` and
+// `prefer-string-starts-ends-with` do. The argument must be a regex
+// literal — the AST-only baseline reads the flag suffix directly off
+// the token text; non-literal regex arguments (a `new RegExp(...)`,
+// a `const re = /.../` aliased through a variable) are conservatively
+// skipped because static flag tracking would explode in scope.
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type preferRegexpExec struct{}
+
+func (preferRegexpExec) Name() string { return "typescript/prefer-regexp-exec" }
+func (preferRegexpExec) NeedsTypeChecker() bool {
+  return true
+}
+func (preferRegexpExec) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (preferRegexpExec) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if !ok || method != "match" {
+    return
+  }
+  if receiver == nil {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindRegularExpressionLiteral {
+    return
+  }
+  // Skip when the regex literal carries the `g` flag — `String#match`
+  // returns every match in that mode, which `RegExp#exec` cannot
+  // replicate in a single call.
+  if preferRegexpExecHasGlobalFlag(ctx.File, arg) {
+    return
+  }
+  if !preferRegexpExecIsString(ctx.Checker.GetTypeAtLocation(receiver)) {
+    return
+  }
+  ctx.Report(node, preferRegexpExecMessage)
+}
+
+const preferRegexpExecMessage = "Prefer `RegExp#exec(str)` over `String#match(re)` when the regex has no `g` flag — `exec` returns the same first-match shape and avoids the `g`-flag fallthrough that silently changes the return type of `match`."
+
+// preferRegexpExecHasGlobalFlag reports whether the regex literal at
+// `node` carries the `g` flag. The flag string follows the closing `/`
+// of the literal (e.g. `/foo/gi` has flags `"gi"`); the scanner has
+// already validated the token, so a textual scan of the trailing
+// suffix is sufficient.
+func preferRegexpExecHasGlobalFlag(file *shimast.SourceFile, node *shimast.Node) bool {
+  raw := nodeText(file, node)
+  if len(raw) < 2 || raw[0] != '/' {
+    return false
+  }
+  closing := strings.LastIndexByte(raw, '/')
+  if closing <= 0 {
+    return false
+  }
+  flags := raw[closing+1:]
+  return strings.Contains(flags, "g")
+}
+
+// preferRegexpExecIsString reports whether t is provably string-like.
+// Mirrors `preferStringStartsEndsWithIsString`: `any` / `unknown` /
+// `never` are rejected so generic helpers don't fire. Union and
+// intersection types must have every constituent string-like.
+func preferRegexpExecIsString(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.TypeFlagsStringLike != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if !preferRegexpExecIsString(part) {
+        return false
+      }
+    }
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(preferRegexpExec{})
+}

package/linthost/rules_ts_prefer_return_this_type.go

@@ -0,0 +1,135 @@
+// typescript/prefer-return-this-type: when an instance method always
+// `return this`, declare its return type as `this` instead of the
+// enclosing class name. The `this` polymorphic-receiver type keeps the
+// narrower subclass type at the call site so chained calls stay
+// polymorphic: `subclass.fluent().subclassOnly()` only type-checks if
+// `fluent()` is declared `: this` rather than `: Base`.
+// typescript-eslint:
+// https://typescript-eslint.io/rules/prefer-return-this-type/
+//
+// Type-aware. Without a Checker the rule cannot read the method's
+// declared return type or distinguish the class symbol, so
+// Context.Checker == nil short-circuits each Check to a no-op the way
+// other type-aware rules do.
+//
+// Skipped:
+//   - methods whose return type is already `this`;
+//   - methods without an explicit declared return type (the upstream
+//     rule only proposes a narrower annotation when one is already
+//     present — adding a brand-new annotation is the job of
+//     `explicit-function-return-type`);
+//   - constructors, accessors, generators, and `async` methods (each
+//     has return-shape semantics the `this` rewrite does not preserve);
+//   - methods with no body (overload signatures, abstract members);
+//   - methods that have at least one `return X;` where `X` is not the
+//     `this` keyword.
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type preferReturnThisType struct{}
+
+func (preferReturnThisType) Name() string { return "typescript/prefer-return-this-type" }
+func (preferReturnThisType) NeedsTypeChecker() bool {
+  return true
+}
+func (preferReturnThisType) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindMethodDeclaration}
+}
+func (preferReturnThisType) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  decl := node.AsMethodDeclaration()
+  if decl == nil || decl.Body == nil {
+    return
+  }
+  // Skip async / generator methods — their return shape is wrapped
+  // (`Promise<...>` / `Generator<...>`) and not directly `this`.
+  if hasAsyncModifier(node) {
+    return
+  }
+  if decl.AsteriskToken != nil {
+    return
+  }
+  // Skip static methods — the upstream rule targets instance-method
+  // chains where the receiver type is the subclass; static dispatch
+  // uses the class itself and `this` rewriting changes nothing.
+  if hasModifier(node, shimast.KindStaticKeyword) {
+    return
+  }
+  // The method must have an explicit return-type annotation that is
+  // NOT already `this`. The rewrite-target is the existing annotation;
+  // without one, adding `this` would force a new annotation that the
+  // upstream rule does not propose.
+  if decl.Type == nil {
+    return
+  }
+  if decl.Type.Kind == shimast.KindThisType {
+    return
+  }
+  // The enclosing class must exist — the rule applies to instance
+  // methods of class declarations / expressions only.
+  parent := node.Parent
+  if parent == nil {
+    return
+  }
+  if parent.Kind != shimast.KindClassDeclaration &&
+    parent.Kind != shimast.KindClassExpression {
+    return
+  }
+  // Walk the method body. Every value-returning `return` must
+  // return exactly `this`; we also require at least one return
+  // statement so we don't fire on methods that fall off the end.
+  hasValueReturn, allAreThis := preferReturnThisTypeAnalyzeBody(decl.Body)
+  if !hasValueReturn || !allAreThis {
+    return
+  }
+  ctx.Report(decl.Type, preferReturnThisTypeMessage)
+}
+
+const preferReturnThisTypeMessage = "Method always returns `this` — declare the return type as `this` so subclass call sites keep the narrower receiver type."
+
+// preferReturnThisTypeAnalyzeBody walks the method body (without
+// descending into nested function-like scopes) and reports:
+//   - hasValueReturn: at least one `return <expression>;` exists.
+//   - allAreThis: every value-returning `return` returns the bare
+//     `this` keyword (after stripping parens).
+//
+// A bare `return;` is ignored — it returns `undefined`, which the rule
+// cannot rewrite to `this` regardless. The conservative interpretation
+// matches the upstream rule's behavior.
+func preferReturnThisTypeAnalyzeBody(body *shimast.Node) (hasValueReturn, allAreThis bool) {
+  allAreThis = true
+  var walk func(*shimast.Node)
+  walk = func(n *shimast.Node) {
+    if n == nil {
+      return
+    }
+    if n != body && isFunctionLikeKind(n) {
+      return
+    }
+    if n.Kind == shimast.KindReturnStatement {
+      ret := n.AsReturnStatement()
+      if ret != nil && ret.Expression != nil {
+        hasValueReturn = true
+        inner := stripParens(ret.Expression)
+        if inner == nil || inner.Kind != shimast.KindThisKeyword {
+          allAreThis = false
+        }
+      }
+    }
+    n.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(body)
+  return hasValueReturn, allAreThis
+}
+
+func init() {
+  Register(preferReturnThisType{})
+}