@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_ts_prefer_string_starts_ends_with.go

@@ -0,0 +1,360 @@
+// typescript/prefer-string-starts-ends-with: prefer
+// `str.startsWith(prefix)` / `str.endsWith(suffix)` over the older
+// `indexOf` / `lastIndexOf` / anchored-regex shapes:
+//
+//   - `str.indexOf(p) === 0`                              → startsWith
+//   - `str.indexOf(p, str.length - p.length) !== -1`      → endsWith
+//   - `str.lastIndexOf(p) === str.length - p.length`      → endsWith
+//   - `/^prefix/.test(str)` (a static-prefix regex)       → startsWith
+//   - `/suffix$/.test(str)` (a static-suffix regex)       → endsWith
+//
+// The dedicated methods state the intent directly and avoid the
+// off-by-one arithmetic and regex-anchor pitfalls of the older shapes.
+// typescript-eslint:
+// https://typescript-eslint.io/rules/prefer-string-starts-ends-with/
+//
+// Type-aware. Without a Checker the rule cannot prove the receiver of
+// `indexOf` / `lastIndexOf` (or the argument of `.test(str)`) is a
+// `string`, so Context.Checker == nil short-circuits each Check to a
+// no-op the way `no-base-to-string` and `prefer-includes` do. `any` /
+// `unknown` / `never` are intentionally NOT treated as matching — they
+// leak from generic helpers and would explode the false-positive
+// volume on user-defined `indexOf` / `test` methods.
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type preferStringStartsEndsWith struct{}
+
+func (preferStringStartsEndsWith) Name() string {
+  return "typescript/prefer-string-starts-ends-with"
+}
+func (preferStringStartsEndsWith) NeedsTypeChecker() bool {
+  return true
+}
+func (preferStringStartsEndsWith) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindBinaryExpression,
+    shimast.KindCallExpression,
+  }
+}
+func (preferStringStartsEndsWith) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return
+    }
+    if !preferStringStartsEndsWithIsEqualityOp(bin.OperatorToken.Kind) {
+      return
+    }
+    if preferStringStartsEndsWithBinary(ctx, bin.Left, bin.Right) {
+      ctx.Report(node, preferStringStartsEndsWithMessage)
+      return
+    }
+    if preferStringStartsEndsWithBinary(ctx, bin.Right, bin.Left) {
+      ctx.Report(node, preferStringStartsEndsWithMessage)
+    }
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil {
+      return
+    }
+    if preferStringStartsEndsWithRegexTest(ctx, call) {
+      ctx.Report(node, preferStringStartsEndsWithMessage)
+    }
+  }
+}
+
+const preferStringStartsEndsWithMessage = "Prefer `String#startsWith` / `String#endsWith` over the equivalent `indexOf` / `lastIndexOf` / anchored-regex idioms — clearer and avoids the off-by-one arithmetic."
+
+// preferStringStartsEndsWithIsEqualityOp reports whether `kind` is one
+// of the equality tokens the rule cares about. Only `==`, `===`,
+// `!=`, `!==` matter: every recognized shape compares two integers
+// for equality (or inequality with a sentinel) rather than ordering.
+func preferStringStartsEndsWithIsEqualityOp(kind shimast.Kind) bool {
+  switch kind {
+  case shimast.KindEqualsEqualsToken,
+    shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken:
+    return true
+  }
+  return false
+}
+
+// preferStringStartsEndsWithBinary inspects `call op other` for the
+// `indexOf` / `lastIndexOf` shapes. Returns true when the receiver of
+// the call is provably string-typed AND the right-hand side matches
+// the sentinel of one of the recognized rewrites:
+//
+//  str.indexOf(p) === 0
+//  str.indexOf(p, str.length - p.length) !== -1
+//  str.lastIndexOf(p) === str.length - p.length
+func preferStringStartsEndsWithBinary(
+  ctx *Context,
+  callNode, otherNode *shimast.Node,
+) bool {
+  callNode = stripParens(callNode)
+  otherNode = stripParens(otherNode)
+  if callNode == nil || otherNode == nil {
+    return false
+  }
+  if callNode.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := callNode.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return false
+  }
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if !ok {
+    return false
+  }
+  if method != "indexOf" && method != "lastIndexOf" {
+    return false
+  }
+  if receiver == nil {
+    return false
+  }
+  t := ctx.Checker.GetTypeAtLocation(receiver)
+  if !preferStringStartsEndsWithIsString(t) {
+    return false
+  }
+  args := call.Arguments
+  if args == nil || len(args.Nodes) == 0 {
+    return false
+  }
+  arg := stripParens(args.Nodes[0])
+  if arg == nil {
+    return false
+  }
+  receiverText := nodeText(ctx.File, receiver)
+  argText := nodeText(ctx.File, arg)
+  otherText := nodeText(ctx.File, otherNode)
+  if receiverText == "" || argText == "" {
+    return false
+  }
+  switch method {
+  case "indexOf":
+    // startsWith: `str.indexOf(p) === 0`
+    if len(args.Nodes) == 1 {
+      return otherText == "0"
+    }
+    // endsWith via positional indexOf: the second argument must
+    // equal `str.length - arg.length`, and the comparison must be
+    // against -1 (the sentinel for "not present at that
+    // position").
+    if len(args.Nodes) != 2 {
+      return false
+    }
+    second := stripParens(args.Nodes[1])
+    if !preferStringStartsEndsWithIsLengthMinusLength(ctx, second, receiverText, argText) {
+      return false
+    }
+    return preferStringStartsEndsWithIsMinusOne(otherText)
+  case "lastIndexOf":
+    // endsWith: `str.lastIndexOf(p) === str.length - p.length`
+    if len(args.Nodes) != 1 {
+      return false
+    }
+    return preferStringStartsEndsWithIsLengthMinusLengthText(otherText, receiverText, argText)
+  }
+  return false
+}
+
+// preferStringStartsEndsWithRegexTest reports whether `call` is a
+// `/^.../.test(str)` or `/...$/.test(str)` invocation on a regex
+// literal whose body is a static prefix or suffix — no metacharacters
+// other than the anchor and no flags that change the matching
+// semantics. The argument to `.test` must be a `string`-typed value;
+// without that the call is not equivalent to a startsWith/endsWith
+// rewrite (e.g. coercing a non-string regex argument).
+func preferStringStartsEndsWithRegexTest(
+  ctx *Context,
+  call *shimast.CallExpression,
+) bool {
+  if call == nil || call.Expression == nil || call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return false
+  }
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if !ok || method != "test" {
+    return false
+  }
+  receiver = stripParens(receiver)
+  if receiver == nil || receiver.Kind != shimast.KindRegularExpressionLiteral {
+    return false
+  }
+  raw := nodeText(ctx.File, receiver)
+  if !preferStringStartsEndsWithIsAnchoredStaticRegex(raw) {
+    return false
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil {
+    return false
+  }
+  return preferStringStartsEndsWithIsString(ctx.Checker.GetTypeAtLocation(arg))
+}
+
+// preferStringStartsEndsWithIsAnchoredStaticRegex reports whether
+// `raw` (the source text of a RegularExpressionLiteral, including the
+// surrounding `/`) encodes either `^prefix` or `suffix$` with no
+// metacharacters other than the anchor itself, and carries no flags
+// that change matching semantics (`i`, `m`, `s`, `u`, `v`). A flag
+// like `i` would lower-case both sides, which `startsWith` does not
+// do — so the rewrite would change meaning.
+func preferStringStartsEndsWithIsAnchoredStaticRegex(raw string) bool {
+  if len(raw) < 3 || raw[0] != '/' {
+    return false
+  }
+  closing := strings.LastIndexByte(raw, '/')
+  if closing <= 0 {
+    return false
+  }
+  pattern := raw[1:closing]
+  flags := raw[closing+1:]
+  if pattern == "" {
+    return false
+  }
+  for i := 0; i < len(flags); i++ {
+    switch flags[i] {
+    case 'g', 'y', 'd':
+      // stateful/position flags — fine for `.test` since we
+      // only call once
+    default:
+      return false
+    }
+  }
+  if pattern[0] == '^' {
+    return preferStringStartsEndsWithIsStaticString(pattern[1:])
+  }
+  if pattern[len(pattern)-1] == '$' {
+    return preferStringStartsEndsWithIsStaticString(pattern[:len(pattern)-1])
+  }
+  return false
+}
+
+// preferStringStartsEndsWithIsStaticString reports whether `pattern`
+// is a regex body made up only of literal characters (and accepted
+// escape sequences `\.`, `\\`, etc. that represent a single literal
+// character). Any metacharacter — `^`, `$`, `*`, `+`, `?`, `(`, `)`,
+// `[`, `]`, `{`, `}`, `|`, `.` — disqualifies the body because the
+// startsWith/endsWith rewrite would change matching semantics.
+func preferStringStartsEndsWithIsStaticString(pattern string) bool {
+  if pattern == "" {
+    return false
+  }
+  for i := 0; i < len(pattern); i++ {
+    ch := pattern[i]
+    if ch == '\\' {
+      // Accept only escapes that name a single literal
+      // character (`\.`, `\$`, `\^`, `\/`, `\\`, `\(`, `\)`,
+      // `\[`, `\]`, `\{`, `\}`, `\|`, `\+`, `\*`, `\?`).
+      // Reject character-class shortcuts (`\d`, `\w`, `\s`)
+      // and back-references — those would not survive a
+      // rewrite to startsWith/endsWith.
+      if i+1 >= len(pattern) {
+        return false
+      }
+      next := pattern[i+1]
+      switch next {
+      case '.', '$', '^', '/', '\\', '(', ')', '[', ']', '{', '}', '|', '+', '*', '?', '-':
+        i++
+        continue
+      }
+      return false
+    }
+    switch ch {
+    case '^', '$', '*', '+', '?', '(', ')', '[', ']', '{', '}', '|', '.':
+      return false
+    }
+  }
+  return true
+}
+
+// preferStringStartsEndsWithIsLengthMinusLength reports whether
+// `node` textually evaluates to `<receiver>.length - <arg>.length`.
+// The comparison is text-based (after stripping parens) because the
+// rewrite only fires when the call site spelled the offset that way
+// — matching the upstream rule's textual shape detector.
+func preferStringStartsEndsWithIsLengthMinusLength(
+  ctx *Context,
+  node *shimast.Node,
+  receiverText, argText string,
+) bool {
+  if node == nil {
+    return false
+  }
+  return preferStringStartsEndsWithIsLengthMinusLengthText(nodeText(ctx.File, node), receiverText, argText)
+}
+
+// preferStringStartsEndsWithIsLengthMinusLengthText is the text-level
+// half of `preferStringStartsEndsWithIsLengthMinusLength` — split out
+// so the `lastIndexOf === str.length - p.length` shape can use the
+// same matcher against the binary RHS text.
+func preferStringStartsEndsWithIsLengthMinusLengthText(text, receiverText, argText string) bool {
+  wanted := receiverText + ".length-" + argText + ".length"
+  return preferStringStartsEndsWithStripSpaces(text) == wanted
+}
+
+// preferStringStartsEndsWithStripSpaces removes whitespace from `s`.
+// Used for the textual equality match — `a.length - b.length` and
+// `a.length-b.length` should both match the canonical form.
+func preferStringStartsEndsWithStripSpaces(s string) string {
+  var b strings.Builder
+  for i := 0; i < len(s); i++ {
+    ch := s[i]
+    if ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n' {
+      continue
+    }
+    b.WriteByte(ch)
+  }
+  return b.String()
+}
+
+// preferStringStartsEndsWithIsMinusOne reports whether `text` is the
+// numeric literal `-1` (with or without internal whitespace).
+func preferStringStartsEndsWithIsMinusOne(text string) bool {
+  return preferStringStartsEndsWithStripSpaces(text) == "-1"
+}
+
+// preferStringStartsEndsWithIsString reports whether t is provably
+// string-like. Mirrors `isStringLikeType` in no-base-to-string but
+// rejects `any` / `unknown` / `never` so generic helpers don't fire.
+// Union and intersection types must have every constituent string-like.
+func preferStringStartsEndsWithIsString(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 !preferStringStartsEndsWithIsString(part) {
+        return false
+      }
+    }
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(preferStringStartsEndsWith{})
+}

package/linthost/rules_ts_promise_function_async.go

@@ -0,0 +1,77 @@
+// promiseFunctionAsync requires a function whose return type is
+// `Promise<T>` (or a Promise-like thenable) to be declared with the
+// `async` keyword. typescript-eslint:
+// https://typescript-eslint.io/rules/promise-function-async/
+//
+// Type-aware. An `async` function wraps a synchronous `throw` into a
+// rejected Promise so the caller's `await` / `.catch(...)` observes
+// it; the non-async equivalent throws synchronously and bypasses every
+// Promise-aware handler downstream. Marking the function `async` keeps
+// the rejection channel consistent with the declared return type.
+//
+// Skipped:
+//   - functions already declared `async` (the contract holds);
+//   - abstract methods and overload signatures (no body to wrap — the
+//     `async` keyword can only be applied to the implementation);
+//   - functions whose declared / inferred return type is not a
+//     Promise (`any` / `unknown` / `never` pass through, matching the
+//     conservative `isPromiseTypedExpression` baseline used by the
+//     surrounding async family).
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type promiseFunctionAsync struct{}
+
+func (promiseFunctionAsync) Name() string { return "typescript/promise-function-async" }
+func (promiseFunctionAsync) NeedsTypeChecker() bool {
+  return true
+}
+func (promiseFunctionAsync) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+  }
+}
+func (promiseFunctionAsync) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  if hasAsyncModifier(node) {
+    return
+  }
+  // Skip overload signatures and abstract methods — only the
+  // implementation signature carries an executable body that the
+  // `async` keyword could wrap.
+  if node.Body() == nil {
+    return
+  }
+  if hasModifier(node, shimast.KindAbstractKeyword) {
+    return
+  }
+  sig := ctx.Checker.GetSignatureFromDeclaration(node)
+  if sig == nil {
+    return
+  }
+  returnType := ctx.Checker.GetReturnTypeOfSignature(sig)
+  if returnType == nil {
+    return
+  }
+  if !isPromiseTypedExpression(ctx.Checker, returnType) {
+    return
+  }
+  startPos := keywordStart(ctx.File, node, "function")
+  if startPos >= 0 {
+    ctx.ReportRange(startPos, startPos+len("function"), "Function returning a Promise should be declared `async` so synchronous throws surface as a rejected Promise.")
+    return
+  }
+  ctx.Report(node, "Function returning a Promise should be declared `async` so synchronous throws surface as a rejected Promise.")
+}
+
+func init() {
+  Register(promiseFunctionAsync{})
+}

package/linthost/rules_ts_related_getter_setter_pairs.go

@@ -0,0 +1,113 @@
+// typescript/related-getter-setter-pairs reports a `get` accessor
+// whose declared return type does not match the parameter type of the
+// companion `set` accessor on the same class. The accessor pair
+// presents a single conceptual field at the call site — `obj.value =
+// X` followed by `Y = obj.value` should round-trip with compatible
+// types — but TypeScript otherwise lets the two accessors carry
+// independent annotations. The rule fires when the writer cannot
+// accept what the reader is about to surface.
+// https://typescript-eslint.io/rules/related-getter-setter-pairs/
+//
+// Type-aware. The comparison resolves both sides through
+// `GetTypeFromTypeNode` so type aliases, generic parameters, and union
+// constituents collapse to the same set of values before the
+// equality check. Without a Checker the rule short-circuits to a
+// no-op the way the other type-aware rules do.
+//
+// The rule visits each `KindGetAccessor`. For every getter that
+// carries a return-type annotation and lives inside a class
+// declaration / expression, it locates the matching `set` accessor by
+// name (using the same `classMembers` + `classMemberName` helpers as
+// `class-literal-property-style`) and compares the annotated types
+// bidirectionally — both sides must describe the same set of values
+// for the accessor pair to round-trip safely.
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type relatedGetterSetterPairs struct{}
+
+func (relatedGetterSetterPairs) Name() string {
+  return "typescript/related-getter-setter-pairs"
+}
+func (relatedGetterSetterPairs) NeedsTypeChecker() bool { return true }
+func (relatedGetterSetterPairs) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindGetAccessor}
+}
+func (relatedGetterSetterPairs) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  parent := node.Parent
+  if parent == nil ||
+    (parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
+    return
+  }
+  getReturnType := node.Type()
+  if getReturnType == nil {
+    // No annotated return type — nothing to compare against.
+    return
+  }
+  name := classMemberName(node)
+  if name == "" {
+    return
+  }
+  setter := findClassSetterFor(parent, name)
+  if setter == nil {
+    return
+  }
+  setParamType := setterParameterType(setter)
+  if setParamType == nil {
+    return
+  }
+  getType := ctx.Checker.GetTypeFromTypeNode(getReturnType)
+  setType := ctx.Checker.GetTypeFromTypeNode(setParamType)
+  if getType == nil || setType == nil {
+    return
+  }
+  // Bidirectional assignability stands in for type identity — the
+  // same shape `no-unnecessary-type-assertion` uses. The accessor
+  // pair is safe only when reading and writing describe the same
+  // set of values.
+  if ctx.Checker.IsTypeAssignableTo(getType, setType) &&
+    ctx.Checker.IsTypeAssignableTo(setType, getType) {
+    return
+  }
+  ctx.Report(node, "Getter return type does not match the corresponding setter parameter type on `"+name+"`.")
+}
+
+// findClassSetterFor returns the `set` accessor declared on `class`
+// whose name matches `name`, or nil when no such setter exists.
+func findClassSetterFor(class *shimast.Node, name string) *shimast.Node {
+  for _, member := range classMembers(class) {
+    if member == nil || member.Kind != shimast.KindSetAccessor {
+      continue
+    }
+    if classMemberName(member) == name {
+      return member
+    }
+  }
+  return nil
+}
+
+// setterParameterType returns the type-annotation node of a `set`
+// accessor's single parameter. A setter without a parameter, or with a
+// parameter that carries no annotation, returns nil — the rule cannot
+// compare against an inferred type.
+func setterParameterType(setter *shimast.Node) *shimast.Node {
+  params := setter.Parameters()
+  if len(params) == 0 {
+    return nil
+  }
+  decl := params[0].AsParameterDeclaration()
+  if decl == nil {
+    return nil
+  }
+  return decl.Type
+}
+
+func init() {
+  Register(relatedGetterSetterPairs{})
+}

package/linthost/rules_ts_require_array_sort_compare.go

@@ -0,0 +1,96 @@
+// typescript/require-array-sort-compare: require an explicit comparator
+// for `arr.sort()` and `arr.toSorted()`. Without a comparator, both
+// methods coerce elements to strings before ordering them, so
+// `[10, 2, 1].sort()` evaluates to `[1, 10, 2]` — almost never what the
+// caller meant. The fix is to pass `(a, b) => a - b`-style comparator.
+// typescript-eslint:
+// https://typescript-eslint.io/rules/require-array-sort-compare/
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// requireArraySortCompare reports `<arr>.sort()` and `<arr>.toSorted()`
+// when no comparator argument is supplied. Type-aware: the Checker
+// confirms the receiver is an array (or tuple) so user-defined methods
+// named `sort` / `toSorted` on non-array types do not trip the rule.
+type requireArraySortCompare struct{}
+
+func (requireArraySortCompare) Name() string {
+  return "typescript/require-array-sort-compare"
+}
+func (requireArraySortCompare) NeedsTypeChecker() bool {
+  return true
+}
+func (requireArraySortCompare) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (requireArraySortCompare) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  // Only fire when the callee is a property access ending in `.sort`
+  // or `.toSorted` and the call passes zero arguments.
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if !ok || (method != "sort" && method != "toSorted") {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    return
+  }
+  if receiver == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(receiver)
+  if t == nil {
+    return
+  }
+  if !requireArraySortCompareIsArrayLike(ctx.Checker, t) {
+    return
+  }
+  ctx.Report(node, "Require an explicit compareFunction for `."+method+"()` — without one, elements are coerced to strings before being ordered.")
+}
+
+// requireArraySortCompareIsArrayLike reports whether t is provably an
+// array or a tuple. The check follows the same recurse-into-constituents
+// pattern as `isAwaitable` so a union like `number[] | string[]` still
+// resolves to "array" via every constituent. `any` / `unknown` / `never`
+// are intentionally NOT treated as array-like — they propagate from
+// generic helpers and would explode the false-positive volume.
+func requireArraySortCompareIsArrayLike(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 !requireArraySortCompareIsArrayLike(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(requireArraySortCompare{})
+}