@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_prefer_arrow_callback.go

@@ -0,0 +1,124 @@
+// preferArrowCallback: a `function() { … }` expression passed as a
+// callback argument predates ES2015 arrow functions. The arrow form is
+// shorter, captures `this` lexically (the usual intent for a callback),
+// and avoids the named-binding hoisting of `function` expressions.
+// https://eslint.org/docs/latest/rules/prefer-arrow-callback
+//
+// AST-only: visit every `CallExpression`/`NewExpression` and check
+// whether any of its arguments is a `FunctionExpression`. A few shapes
+// are skipped because converting them would change behaviour:
+//
+//   - generators (`function* () {}`) cannot be arrows at all.
+//   - bodies that read `this` or `arguments` rely on the function
+//     expression's own binding; an arrow would capture the surrounding
+//     binding instead.
+//   - functions immediately followed by `.bind(…)` opt the caller into
+//     an explicit `this` binding that an arrow cannot honour.
+//
+// Named function expressions (`function name() { … }`) still flag —
+// ESLint's default `allowNamedFunctions` is `false` — but a body that
+// references the function's own name through the inner binding is left
+// alone so the recursion stays valid.
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type preferArrowCallback struct{}
+
+func (preferArrowCallback) Name() string { return "prefer-arrow-callback" }
+func (preferArrowCallback) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression, shimast.KindNewExpression}
+}
+func (preferArrowCallback) Check(ctx *Context, node *shimast.Node) {
+	args := callArgumentsList(node)
+	if args == nil {
+		return
+	}
+	for _, arg := range args.Nodes {
+		fn := stripParens(arg)
+		if fn == nil || fn.Kind != shimast.KindFunctionExpression {
+			continue
+		}
+		if !preferArrowCallbackEligible(fn) {
+			continue
+		}
+		ctx.Report(fn, "Unexpected function expression. Use an arrow function instead.")
+	}
+}
+
+// callArgumentsList returns the argument NodeList of a CallExpression or
+// NewExpression, or nil when the node either lacks arguments or is not a
+// call/new shape.
+func callArgumentsList(node *shimast.Node) *shimast.NodeList {
+	switch node.Kind {
+	case shimast.KindCallExpression:
+		call := node.AsCallExpression()
+		if call == nil {
+			return nil
+		}
+		return call.Arguments
+	case shimast.KindNewExpression:
+		newExpr := node.AsNewExpression()
+		if newExpr == nil {
+			return nil
+		}
+		return newExpr.Arguments
+	}
+	return nil
+}
+
+// preferArrowCallbackEligible reports whether `fn` (a FunctionExpression)
+// can be converted to an arrow without changing observable behaviour.
+// The function must not be a generator, must not read `this` or
+// `arguments` outside any nested function-like, and must not reference
+// its own inner name (a self-recursion handle that an arrow cannot
+// reproduce).
+func preferArrowCallbackEligible(fn *shimast.Node) bool {
+	expr := fn.AsFunctionExpression()
+	if expr == nil {
+		return false
+	}
+	if expr.AsteriskToken != nil {
+		return false
+	}
+	innerName := identifierText(expr.Name())
+	body := expr.Body
+	if body == nil {
+		return true
+	}
+	usesForbidden := false
+	walkFunctionBody(body, func(child *shimast.Node) {
+		if usesForbidden || child == nil {
+			return
+		}
+		switch child.Kind {
+		case shimast.KindThisKeyword:
+			usesForbidden = true
+		case shimast.KindIdentifier:
+			text := identifierText(child)
+			if text == "arguments" {
+				// Skip `obj.arguments` — that's an unrelated member access.
+				if parent := child.Parent; parent != nil && parent.Kind == shimast.KindPropertyAccessExpression {
+					if access := parent.AsPropertyAccessExpression(); access != nil && access.Name() == child {
+						return
+					}
+				}
+				usesForbidden = true
+				return
+			}
+			if innerName != "" && text == innerName {
+				if parent := child.Parent; parent != nil && parent.Kind == shimast.KindPropertyAccessExpression {
+					if access := parent.AsPropertyAccessExpression(); access != nil && access.Name() == child {
+						return
+					}
+				}
+				usesForbidden = true
+			}
+		}
+	})
+	return !usesForbidden
+}
+
+func init() {
+	Register(preferArrowCallback{})
+}

package/linthost/rules_prefer_destructuring.go

@@ -0,0 +1,98 @@
+// preferDestructuring: a variable declaration whose initializer is a
+// single property or index access (`const a = obj.a;`, `const x =
+// arr[0];`) is just longhand for the destructuring form (`const { a }
+// = obj;`, `const [x] = arr;`). The destructuring form reads at the
+// site as "extracts this from that", names the source object once, and
+// scales to multi-field extraction without retyping the receiver.
+// https://eslint.org/docs/latest/rules/prefer-destructuring
+//
+// AST-only: each visited `VariableDeclaration` is checked for an
+// initializer shape that destructuring would replace verbatim:
+//
+//   - `obj.<name>` where the variable name matches `<name>`
+//   - `arr[<n>]` where `<n>` is a numeric literal
+//
+// Computed string-literal access (`obj["a"]`) is skipped — that idiom
+// is usually deliberate (e.g. key with hyphens or reserved-word
+// keys). The receiver must be a plain identifier or property access;
+// call expressions and other compound shapes are not flagged because
+// the receiver would be re-evaluated under destructuring.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type preferDestructuring struct{}
+
+func (preferDestructuring) Name() string { return "prefer-destructuring" }
+func (preferDestructuring) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindVariableDeclaration}
+}
+func (preferDestructuring) Check(ctx *Context, node *shimast.Node) {
+	decl := node.AsVariableDeclaration()
+	if decl == nil || decl.Initializer == nil {
+		return
+	}
+	// Only fire on plain identifier bindings — destructuring already
+	// happens on `const { a } = obj;`.
+	name := decl.Name()
+	if name == nil || name.Kind != shimast.KindIdentifier {
+		return
+	}
+	varName := identifierText(name)
+	if varName == "" {
+		return
+	}
+	init := stripParens(decl.Initializer)
+	if init == nil {
+		return
+	}
+	switch init.Kind {
+	case shimast.KindPropertyAccessExpression:
+		access := init.AsPropertyAccessExpression()
+		if access == nil || access.Expression == nil || !preferDestructuringSimpleReceiver(access.Expression) {
+			return
+		}
+		propName := access.Name()
+		if propName == nil || propName.Kind != shimast.KindIdentifier {
+			return
+		}
+		if identifierText(propName) != varName {
+			return
+		}
+		ctx.Report(node, "Use object destructuring (`const { "+varName+" } = obj`).")
+	case shimast.KindElementAccessExpression:
+		access := init.AsElementAccessExpression()
+		if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
+			return
+		}
+		if !preferDestructuringSimpleReceiver(access.Expression) {
+			return
+		}
+		// Only numeric-literal index — array destructuring.
+		idx := stripParens(access.ArgumentExpression)
+		if idx == nil || idx.Kind != shimast.KindNumericLiteral {
+			return
+		}
+		ctx.Report(node, "Use array destructuring (`const ["+varName+"] = arr`).")
+	}
+}
+
+func preferDestructuringSimpleReceiver(node *shimast.Node) bool {
+	n := stripParens(node)
+	if n == nil {
+		return false
+	}
+	switch n.Kind {
+	case shimast.KindIdentifier,
+		shimast.KindThisKeyword,
+		shimast.KindPropertyAccessExpression:
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(preferDestructuring{})
+}

package/linthost/rules_prefer_named_capture_group.go

@@ -0,0 +1,129 @@
+// preferNamedCaptureGroup: an unnamed capturing group `(…)` in a
+// regular-expression literal has to be referenced by ordinal number.
+// Named groups `(?<name>…)` document the captured value at the
+// definition site and survive pattern edits that would otherwise renumber
+// the groups silently.
+// https://eslint.org/docs/latest/rules/prefer-named-capture-group
+//
+// AST-only: scan the pattern of every `RegularExpressionLiteral`,
+// stepping past escapes and character classes (where `(` is a literal
+// '(' rather than a group opener). Each `(` that is not followed by `?:`,
+// `?<name>`, `?<=`, `?<!`, `?=`, or `?!` is an unnamed capture group and
+// fires the rule. Character-class contents are skipped because '(' there
+// is a literal byte, never a group opener.
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type preferNamedCaptureGroup struct{}
+
+func (preferNamedCaptureGroup) Name() string { return "prefer-named-capture-group" }
+func (preferNamedCaptureGroup) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindRegularExpressionLiteral}
+}
+func (preferNamedCaptureGroup) Check(ctx *Context, node *shimast.Node) {
+	raw := nodeText(ctx.File, node)
+	if len(raw) < 2 || raw[0] != '/' {
+		return
+	}
+	closing := lastSlashOutsideClass(raw)
+	if closing <= 0 {
+		return
+	}
+	pattern := raw[1:closing]
+	if regexpHasUnnamedCapture(pattern) {
+		ctx.Report(node, "Capture group should be named.")
+	}
+}
+
+// regexpHasUnnamedCapture reports whether `pattern` contains at least
+// one capturing group that is neither a non-capturing group (`(?:…)`),
+// a named group (`(?<name>…)`), nor a lookaround assertion (`(?=…)`,
+// `(?!…)`, `(?<=…)`, `(?<!…)`). The scan skips escape sequences and
+// character-class contents because `(` is a literal byte in those
+// positions and never opens a group.
+func regexpHasUnnamedCapture(pattern string) bool {
+	inClass := false
+	for i := 0; i < len(pattern); i++ {
+		ch := pattern[i]
+		if ch == '\\' {
+			i++
+			continue
+		}
+		if inClass {
+			if ch == ']' {
+				inClass = false
+			}
+			continue
+		}
+		if ch == '[' {
+			inClass = true
+			continue
+		}
+		if ch != '(' {
+			continue
+		}
+		// `(` is a group opener; classify what follows.
+		if i+1 >= len(pattern) || pattern[i+1] != '?' {
+			return true
+		}
+		if i+2 >= len(pattern) {
+			// `(?` with nothing after — treat as malformed but not flagged;
+			// the parser would have rejected this regex if it was truly
+			// invalid, so leave it alone.
+			continue
+		}
+		switch pattern[i+2] {
+		case ':', '=', '!':
+			// non-capturing or lookahead
+			continue
+		case '<':
+			if i+3 < len(pattern) && (pattern[i+3] == '=' || pattern[i+3] == '!') {
+				// lookbehind `(?<=` / `(?<!`
+				continue
+			}
+			// named capture `(?<name>…)`
+			continue
+		}
+		// `(?` followed by something else (e.g. an inline flag group).
+		// Treat as unnamed; ESLint flags these too because they still
+		// capture under the standard regex semantics they target.
+		return true
+	}
+	return false
+}
+
+// lastSlashOutsideClass returns the index of the closing `/` of a regex
+// literal, accounting for `/` characters that appear inside escapes or
+// character classes. Returns -1 when no closing slash is found.
+func lastSlashOutsideClass(raw string) int {
+	if len(raw) < 2 || raw[0] != '/' {
+		return -1
+	}
+	inClass := false
+	for i := 1; i < len(raw); i++ {
+		ch := raw[i]
+		if ch == '\\' {
+			i++
+			continue
+		}
+		if inClass {
+			if ch == ']' {
+				inClass = false
+			}
+			continue
+		}
+		if ch == '[' {
+			inClass = true
+			continue
+		}
+		if ch == '/' {
+			return i
+		}
+	}
+	return -1
+}
+
+func init() {
+	Register(preferNamedCaptureGroup{})
+}

package/linthost/rules_prefer_rest_params.go

@@ -0,0 +1,94 @@
+// preferRestParams: a non-arrow function body that reads from
+// `arguments` is using the legacy variadic-argument shape that predates
+// ES6 rest parameters. Replacing the `arguments` access with
+// `(...args)` declares the variadic contract on the signature, makes
+// the parameter list iterable like every other JS array, and lets a
+// reader see the variadic intent without reading the body.
+// https://eslint.org/docs/latest/rules/prefer-rest-params
+//
+// AST-only: each visited function-like that owns its own `arguments`
+// binding (function declaration, function expression, method, accessor,
+// constructor — i.e. NOT an arrow function) is scanned for an
+// `Identifier(arguments)` use inside its body. The walk stops at nested
+// function-like boundaries via the shared `walkFunctionBody` helper.
+// Property names like `obj.arguments` are skipped because they
+// reference an unrelated member; only bare identifier reads count.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type preferRestParams struct{}
+
+func (preferRestParams) Name() string { return "prefer-rest-params" }
+func (preferRestParams) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindMethodDeclaration,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+		shimast.KindConstructor,
+	}
+}
+func (preferRestParams) Check(ctx *Context, node *shimast.Node) {
+	body := preferRestParamsBody(node)
+	if body == nil {
+		return
+	}
+	reported := false
+	walkFunctionBody(body, func(child *shimast.Node) {
+		if reported || child == nil {
+			return
+		}
+		if child.Kind != shimast.KindIdentifier {
+			return
+		}
+		if identifierText(child) != "arguments" {
+			return
+		}
+		// Skip `obj.arguments` — that's an unrelated member access.
+		if parent := child.Parent; parent != nil && parent.Kind == shimast.KindPropertyAccessExpression {
+			if access := parent.AsPropertyAccessExpression(); access != nil && access.Name() == child {
+				return
+			}
+		}
+		reported = true
+		ctx.Report(child, "Use rest parameters (`...args`) instead of `arguments`.")
+	})
+}
+
+func preferRestParamsBody(node *shimast.Node) *shimast.Node {
+	switch node.Kind {
+	case shimast.KindFunctionDeclaration:
+		if fn := node.AsFunctionDeclaration(); fn != nil {
+			return fn.Body
+		}
+	case shimast.KindFunctionExpression:
+		if fn := node.AsFunctionExpression(); fn != nil {
+			return fn.Body
+		}
+	case shimast.KindMethodDeclaration:
+		if m := node.AsMethodDeclaration(); m != nil {
+			return m.Body
+		}
+	case shimast.KindGetAccessor:
+		if a := node.AsGetAccessorDeclaration(); a != nil {
+			return a.Body
+		}
+	case shimast.KindSetAccessor:
+		if a := node.AsSetAccessorDeclaration(); a != nil {
+			return a.Body
+		}
+	case shimast.KindConstructor:
+		if c := node.AsConstructorDeclaration(); c != nil {
+			return c.Body
+		}
+	}
+	return nil
+}
+
+func init() {
+	Register(preferRestParams{})
+}

package/linthost/rules_problems.go

@@ -8,12 +8,13 @@
 package linthost
 
 import (
+  "strconv"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-// no-dupe-else-if: `if (a) {} else if (a) {}` — the second branch is
+// noDupeElseIf: `if (a) {} else if (a) {}` — the second branch is
 // unreachable.
 type noDupeElseIf struct{}
 
@@ -49,7 +50,7 @@ func (noDupeElseIf) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-ex-assign: `try { } catch (e) { e = 1; }` — reassigning the catch
+// noExAssign: `try { } catch (e) { e = 1; }` — reassigning the catch
 // binding silently throws away the error.
 type noExAssign struct{}
 
@@ -74,8 +75,8 @@ func (noExAssign) Check(ctx *Context, node *shimast.Node) {
 }
 
 // walkAssignments invokes `report` on every `<name> = ...` shape inside
-// `root`. Used by no-ex-assign to scan a single catch block; the
-// file-wide no-func-assign / no-class-assign scans go through
+// `root`. Used by noExAssign to scan a single catch block; the
+// file-wide noFuncAssign / noClassAssign scans go through
 // reportAssignmentsToDeclarations instead.
 func walkAssignments(root *shimast.Node, name string, report func(*shimast.Node)) {
   if root == nil {
@@ -98,7 +99,7 @@ func walkAssignments(root *shimast.Node, name string, report func(*shimast.Node)
   })
 }
 
-// no-empty-character-class: `/[]/` matches nothing.
+// noEmptyCharacterClass: `/[]/` matches nothing.
 type noEmptyCharacterClass struct{}
 
 func (noEmptyCharacterClass) Name() string { return "no-empty-character-class" }
@@ -133,7 +134,7 @@ func hasEmptyCharClass(src string) bool {
   return false
 }
 
-// no-misleading-character-class: `/[👍]/` — surrogate pairs in regex.
+// noMisleadingCharacterClass: `/[👍]/` — surrogate pairs in regex.
 type noMisleadingCharacterClass struct{}
 
 func (noMisleadingCharacterClass) Name() string { return "no-misleading-character-class" }
@@ -178,10 +179,10 @@ func regexHasSurrogatePair(src string) bool {
   return false
 }
 
-// no-loss-of-precision: `9007199254740993` — integer literal larger than
-// `Number.MAX_SAFE_INTEGER`. We read the *source* form (not the parser's
-// normalized .Text, which has already lost precision) and decide off
-// that.
+// noLossOfPrecision: `9007199254740993` — decimal numeric literal whose
+// source text changes when parsed as a JavaScript Number. We read the source
+// form instead of the parser's normalized .Text, which has already lost
+// precision.
 type noLossOfPrecision struct{}
 
 func (noLossOfPrecision) Name() string           { return "no-loss-of-precision" }
@@ -196,10 +197,10 @@ func (noLossOfPrecision) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// numericLiteralLosesPrecision reports whether the decimal integer literal
-// text exceeds Number.MAX_SAFE_INTEGER (2^53 - 1). Non-decimal literals
-// (hex, octal, binary) and literals with exponents or decimal points are
-// exempt because their precision loss is caller-visible and intentional.
+// numericLiteralLosesPrecision reports whether the decimal integer literal text
+// changes when parsed as a JavaScript Number. Non-decimal literals (hex, octal,
+// binary) and literals with exponents or decimal points are exempt because
+// their precision loss is caller-visible and intentional.
 func numericLiteralLosesPrecision(text string) bool {
   // Strip underscore separators, exponents, decimal/hex/oct/binary
   // markers — for the simple-base-10 integer case the round-trip
@@ -216,19 +217,29 @@ func numericLiteralLosesPrecision(text string) bool {
   if trimmed == "" {
     return false
   }
-  // Number.MAX_SAFE_INTEGER is 2^53-1 = 9007199254740991; 2^53 itself
-  // (9007199254740992) is the first integer that float64 cannot round-trip.
-  const maxSafe = "9007199254740992"
-  if len(trimmed) < len(maxSafe) {
+  // 2^53 is unsafe for arithmetic comparisons but still exactly representable.
+  // 2^53+1 is the first plain decimal integer that changes when parsed.
+  const firstPossibleLoss = "9007199254740993"
+  if len(trimmed) < len(firstPossibleLoss) {
     return false
   }
-  if len(trimmed) > len(maxSafe) {
+  if len(trimmed) == len(firstPossibleLoss) && trimmed < firstPossibleLoss {
+    return false
+  }
+  // Number.MAX_VALUE is around 1.79e308, so any integer with more than 309
+  // decimal digits cannot round-trip through a finite JavaScript Number.
+  const maxFiniteDecimalDigits = 309
+  if len(trimmed) > maxFiniteDecimalDigits {
     return true
   }
-  return trimmed > maxSafe
+  parsed, err := strconv.ParseFloat(trimmed, 64)
+  if err != nil && parsed == 0 {
+    return false
+  }
+  return strconv.FormatFloat(parsed, 'f', 0, 64) != trimmed
 }
 
-// no-class-assign: assigning to a class declaration's name.
+// noClassAssign: assigning to a class declaration's name.
 type noClassAssign struct{}
 
 func (noClassAssign) Name() string           { return "no-class-assign" }
@@ -237,7 +248,7 @@ func (noClassAssign) Check(ctx *Context, node *shimast.Node) {
   reportAssignmentsToDeclarations(ctx, node, shimast.KindClassDeclaration, "is a class.")
 }
 
-// no-func-assign: same idea, but for function declarations.
+// noFuncAssign: same idea, but for function declarations.
 type noFuncAssign struct{}
 
 func (noFuncAssign) Name() string           { return "no-func-assign" }
@@ -308,7 +319,7 @@ func declarationName(n *shimast.Node) string {
   return ""
 }
 
-// no-prototype-builtins: `obj.hasOwnProperty(x)` — should be
+// noPrototypeBuiltins: `obj.hasOwnProperty(x)` — should be
 // `Object.prototype.hasOwnProperty.call(obj, x)` or `Object.hasOwn`.
 type noPrototypeBuiltins struct{}
 
@@ -333,7 +344,7 @@ func (noPrototypeBuiltins) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-async-promise-executor: `new Promise(async (resolve) => {...})`.
+// noAsyncPromiseExecutor: `new Promise(async (resolve) => {...})`.
 type noAsyncPromiseExecutor struct{}
 
 func (noAsyncPromiseExecutor) Name() string { return "no-async-promise-executor" }
@@ -360,7 +371,7 @@ func (noAsyncPromiseExecutor) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-promise-executor-return: `new Promise(() => 1)` — the value is
+// noPromiseExecutorReturn: `new Promise(() => 1)` — the value is
 // thrown away.
 type noPromiseExecutorReturn struct{}
 
@@ -390,7 +401,7 @@ func (noPromiseExecutorReturn) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-control-regex: `/\x00/` — control characters in regex are usually
+// noControlRegex: `/\x00/` — control characters in regex are usually
 // the result of accidentally typing the escape rather than the printable
 // counterpart.
 type noControlRegex struct{}
@@ -454,7 +465,7 @@ func hexDigit(b byte) int {
   return -1
 }
 
-// no-irregular-whitespace: zero-width spaces, NBSP, etc. The TS parser
+// noIrregularWhitespace: zero-width spaces, NBSP, etc. The TS parser
 // accepts them but copy-paste into source is almost always a mistake.
 type noIrregularWhitespace struct{}
 
@@ -491,7 +502,7 @@ func isIrregularWhitespace(r rune) bool {
   return false
 }
 
-// no-fallthrough: `switch` cases that fall through to the next label
+// noFallthrough: `switch` cases that fall through to the next label
 // without an explicit `break` / `return` / `throw` / `continue`.
 type noFallthrough struct{}
 
@@ -549,7 +560,7 @@ func isTerminating(stmt *shimast.Node) bool {
   return false
 }
 
-// no-inner-declarations: `function foo() { if (x) { function bar() {} } }`
+// noInnerDeclarations: `function foo() { if (x) { function bar() {} } }`
 // — inner function declarations are hoisted differently in strict mode
 // vs sloppy and are confusing.
 type noInnerDeclarations struct{}
@@ -592,7 +603,7 @@ func (noInnerDeclarations) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Move "+what+" declaration to the function scope.")
 }
 
-// no-obj-calls: `Math()`, `JSON()` — these globals are objects, not
+// noObjCalls: `Math()`, `JSON()` — these globals are objects, not
 // callables. ESLint catches a small list.
 type noObjCalls struct{}