@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_unicorn_import_style.go

@@ -0,0 +1,28 @@
+// unicorn/import-style: forbids named or default imports from configured
+// modules so that, for example, `path` is always imported as the
+// namespace `path` and never destructured. The rule's behavior is
+// entirely driven by a per-module configuration map
+// (`styles: { foo: { default: false, namespace: true } }`). Without that
+// configuration plumbing landing in the host's rule-options pipeline,
+// the rule has no defaults to enforce, so it is registered as a no-op
+// stub to keep `TestTypedKeysMatchRegisteredRules` aligned with the
+// typed `ITtscLintUnicornRules` surface.
+//
+// The matching fixture under
+// `tests/test-lint/src/cases/unicorn-import-style.ts` keeps its
+// `@ttsc-corpus-skip` directive until the configuration plumbing lands.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/import-style.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornImportStyle struct{}
+
+func (unicornImportStyle) Name() string           { return "unicorn/import-style" }
+func (unicornImportStyle) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornImportStyle) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+	Register(unicornImportStyle{})
+}

package/linthost/rules_unicorn_isolated_functions.go

@@ -0,0 +1,29 @@
+// unicorn/isolated-functions: flags function expressions that "escape"
+// their lexical closure unintentionally — e.g. an inner function that
+// references no outer binding but is still placed at the inner scope.
+// Correctly identifying "isolated function" context requires scope
+// analysis tracking what each nested function captures, which is not
+// available in the AST-only slice of this port.
+//
+// Registered as a no-op stub to keep
+// `TestTypedKeysMatchRegisteredRules` aligned with the typed
+// `ITtscLintUnicornRules` surface. The matching fixture under
+// `tests/test-lint/src/cases/unicorn-isolated-functions.ts` keeps its
+// `@ttsc-corpus-skip` directive.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/isolated-functions.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornIsolatedFunctions struct{}
+
+func (unicornIsolatedFunctions) Name() string { return "unicorn/isolated-functions" }
+func (unicornIsolatedFunctions) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornIsolatedFunctions) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+	Register(unicornIsolatedFunctions{})
+}

package/linthost/rules_unicorn_new_for_builtins.go

@@ -0,0 +1,87 @@
+// unicorn/new-for-builtins: built-in globals split into two groups for
+// constructor etiquette. Primitive wrappers (`String`, `Number`, …) must
+// be called WITHOUT `new` because the wrapper-object form is a footgun
+// — `new String("x") instanceof Object` is true but `"x" instanceof
+// Object` is false, and the wrapper form does not unify with the
+// primitive in equality comparisons. Container constructors (`Array`,
+// `Error`, `Map`, …) must be called WITH `new` because the call form
+// either misbehaves (`Array(3)` allocates a sparse 3-slot array) or is
+// outright invalid (`Error()` still works but is style-inconsistent).
+//
+// AST-only: visit both `NewExpression` and `CallExpression`. The
+// callee-identifier text is matched against the corresponding allowlist
+// and reported with the inverted construction message.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/new-for-builtins.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// Primitive wrappers — `new` is wrong, call form is required.
+var unicornNewForBuiltinsPrimitiveWrappers = map[string]struct{}{
+	"String":  {},
+	"Number":  {},
+	"Boolean": {},
+	"Symbol":  {},
+	"BigInt":  {},
+}
+
+// Container constructors — `new` is required, call form is wrong. Note
+// that `Symbol` is intentionally NOT in this list: `Symbol(...)` is the
+// correct primitive-wrapper call and must not be flagged.
+var unicornNewForBuiltinsContainers = map[string]struct{}{
+	"Array":          {},
+	"Error":          {},
+	"EvalError":      {},
+	"RangeError":     {},
+	"ReferenceError": {},
+	"SyntaxError":    {},
+	"TypeError":      {},
+	"URIError":       {},
+	"AggregateError": {},
+	"Object":         {},
+	"Map":            {},
+	"Set":            {},
+	"WeakMap":        {},
+	"WeakSet":        {},
+	"Date":           {},
+	"RegExp":         {},
+}
+
+type unicornNewForBuiltins struct{}
+
+func (unicornNewForBuiltins) Name() string { return "unicorn/new-for-builtins" }
+func (unicornNewForBuiltins) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
+}
+func (unicornNewForBuiltins) Check(ctx *Context, node *shimast.Node) {
+	switch node.Kind {
+	case shimast.KindNewExpression:
+		ne := node.AsNewExpression()
+		if ne == nil {
+			return
+		}
+		name := identifierText(ne.Expression)
+		if name == "" {
+			return
+		}
+		if _, ok := unicornNewForBuiltinsPrimitiveWrappers[name]; ok {
+			ctx.Report(node, "Don't use `new "+name+"(...)` with a primitive wrapper like `"+name+"`.")
+		}
+	case shimast.KindCallExpression:
+		call := node.AsCallExpression()
+		if call == nil {
+			return
+		}
+		name := identifierText(call.Expression)
+		if name == "" {
+			return
+		}
+		if _, ok := unicornNewForBuiltinsContainers[name]; ok {
+			ctx.Report(node, "Use `new "+name+"(...)` instead of `"+name+"(...)`.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornNewForBuiltins{})
+}

package/linthost/rules_unicorn_no_abusive_eslint_disable.go

@@ -0,0 +1,63 @@
+// unicorn/no-abusive-eslint-disable: a bare `// eslint-disable*` directive
+// with no rule list suppresses every lint rule for the affected scope.
+// That blanket-disable hides unrelated diagnostics the next reviewer would
+// have caught, so the rule requires every `eslint-disable*` directive to
+// name the rules it silences.
+//
+// File-level dispatch: visit `KindSourceFile` once per file, scan the
+// raw source with the tsgo scanner so embedded `/* */` and `//` tokens
+// inside template substitutions and string literals are not mistaken for
+// real comments, and match each comment's stripped body — already trimmed
+// by the shared `stripCommentDelimiters` helper — against
+// `^eslint-disable(?:-next-line|-line)?$`. A match means the directive
+// carries no rule list and is reported on the comment range.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-abusive-eslint-disable.md
+package linthost
+
+import (
+	"regexp"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+var unicornNoAbusiveEslintDisablePattern = regexp.MustCompile(`^eslint-disable(?:-next-line|-line)?$`)
+
+type unicornNoAbusiveEslintDisable struct{}
+
+func (unicornNoAbusiveEslintDisable) Name() string { return "unicorn/no-abusive-eslint-disable" }
+func (unicornNoAbusiveEslintDisable) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornNoAbusiveEslintDisable) Check(ctx *Context, node *shimast.Node) {
+	if ctx.File == nil {
+		return
+	}
+	src := ctx.File.Text()
+	scanner := shimscanner.NewScanner()
+	scanner.SetText(src)
+	scanner.SetSkipTrivia(false)
+	for {
+		kind := scanner.Scan()
+		if kind == shimast.KindEndOfFile {
+			break
+		}
+		if kind != shimast.KindSingleLineCommentTrivia && kind != shimast.KindMultiLineCommentTrivia {
+			continue
+		}
+		start := scanner.TokenStart()
+		end := scanner.TokenEnd()
+		if start < 0 || end > len(src) || end <= start {
+			continue
+		}
+		body := stripCommentDelimiters(src[start:end])
+		if !unicornNoAbusiveEslintDisablePattern.MatchString(body) {
+			continue
+		}
+		ctx.ReportRange(start, end, "Specify the rules to disable in each `eslint-disable*` directive.")
+	}
+}
+
+func init() {
+	Register(unicornNoAbusiveEslintDisable{})
+}

package/linthost/rules_unicorn_no_accessor_recursion.go

@@ -0,0 +1,115 @@
+// unicorn/no-accessor-recursion: a `get value()` that reads
+// `this.value` triggers itself — the getter is the only thing that
+// resolves `this.value`, so the call recurses until the stack runs
+// out. The same holds for setters, computed and string-keyed names,
+// and class / object-literal accessors. The rule pins every read of
+// `this.<X>` inside the `<X>` accessor as a recursion bug.
+//
+// AST-only: visit both `KindGetAccessor` and `KindSetAccessor`. Take
+// the accessor's own name and walk its body, reporting every
+// `KindPropertyAccessExpression(KindThisKeyword, <name>)` that
+// matches. The walk does NOT descend into nested non-arrow function
+// bodies (`FunctionDeclaration`, `FunctionExpression`,
+// `MethodDeclaration`, `GetAccessor`, `SetAccessor`,
+// `Constructor`), because those rebind `this`. Arrow functions
+// preserve the outer `this` and are walked through.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-accessor-recursion.md
+package linthost
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornNoAccessorRecursion struct{}
+
+func (unicornNoAccessorRecursion) Name() string { return "unicorn/no-accessor-recursion" }
+func (unicornNoAccessorRecursion) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindGetAccessor, shimast.KindSetAccessor}
+}
+func (unicornNoAccessorRecursion) Check(ctx *Context, node *shimast.Node) {
+	name := unicornAccessorRecursionName(node)
+	if name == "" {
+		return
+	}
+	body := node.Body()
+	if body == nil {
+		return
+	}
+	unicornAccessorRecursionWalkRespectingThisBoundary(body, func(child *shimast.Node) {
+		if child == nil || child.Kind != shimast.KindPropertyAccessExpression {
+			return
+		}
+		access := child.AsPropertyAccessExpression()
+		if access == nil || access.Expression == nil {
+			return
+		}
+		if access.Expression.Kind != shimast.KindThisKeyword {
+			return
+		}
+		if identifierText(access.Name()) != name {
+			return
+		}
+		ctx.Report(child, fmt.Sprintf("Reading `this.%s` inside the `%s` accessor recurses forever.", name, name))
+	})
+}
+
+// unicornAccessorRecursionWalkRespectingThisBoundary walks `node` and
+// its descendants depth-first, but does not descend into bodies that
+// rebind `this`. Arrow functions are walked through because they
+// capture the outer `this`.
+func unicornAccessorRecursionWalkRespectingThisBoundary(node *shimast.Node, visit func(*shimast.Node)) {
+	if node == nil {
+		return
+	}
+	visit(node)
+	node.ForEachChild(func(child *shimast.Node) bool {
+		if child == nil {
+			return false
+		}
+		switch child.Kind {
+		case shimast.KindFunctionDeclaration,
+			shimast.KindFunctionExpression,
+			shimast.KindMethodDeclaration,
+			shimast.KindGetAccessor,
+			shimast.KindSetAccessor,
+			shimast.KindConstructor:
+			return false
+		}
+		unicornAccessorRecursionWalkRespectingThisBoundary(child, visit)
+		return false
+	})
+}
+
+// unicornAccessorRecursionName returns the property name of a
+// get/set accessor declaration. Only bare Identifier and StringLiteral
+// names are supported because computed names cannot be matched against
+// the `this.<X>` shape statically.
+func unicornAccessorRecursionName(node *shimast.Node) string {
+	var name *shimast.Node
+	switch node.Kind {
+	case shimast.KindGetAccessor:
+		if g := node.AsGetAccessorDeclaration(); g != nil {
+			name = g.Name()
+		}
+	case shimast.KindSetAccessor:
+		if s := node.AsSetAccessorDeclaration(); s != nil {
+			name = s.Name()
+		}
+	}
+	if name == nil {
+		return ""
+	}
+	switch name.Kind {
+	case shimast.KindIdentifier:
+		return identifierText(name)
+	case shimast.KindStringLiteral:
+		return stringLiteralText(name)
+	}
+	return ""
+}
+
+func init() {
+	Register(unicornNoAccessorRecursion{})
+}

package/linthost/rules_unicorn_no_anonymous_default_export.go

@@ -0,0 +1,74 @@
+// unicorn/no-anonymous-default-export: `export default function () {}`
+// and `export default class {}` (and the arrow-function equivalent)
+// leave the exported value without a local binding name. Stack traces,
+// dev-tools labels, and downstream `import X from …` all rebind to the
+// importer's chosen name, so the export site contributes nothing to
+// readability. Giving the function/class a name keeps the original
+// identifier visible everywhere.
+//
+// AST-only: TypeScript-Go's parser splits the two surface forms of
+// `export default`. `export default <expression>` parses as
+// `KindExportAssignment`; `export default function …` / `export default
+// class …` parse as `KindFunctionDeclaration` / `KindClassDeclaration`
+// with `export` + `default` modifiers and an optional `Name()`. The
+// rule covers both paths: it reports an `ExportAssignment` whose
+// expression is a `KindFunctionExpression`/`KindArrowFunction`/
+// `KindClassExpression` with no name, and reports an export-default
+// `Function`/`ClassDeclaration` whose `Name()` is nil.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-anonymous-default-export.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoAnonymousDefaultExport struct{}
+
+func (unicornNoAnonymousDefaultExport) Name() string {
+	return "unicorn/no-anonymous-default-export"
+}
+func (unicornNoAnonymousDefaultExport) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindExportAssignment,
+		shimast.KindFunctionDeclaration,
+		shimast.KindClassDeclaration,
+	}
+}
+func (unicornNoAnonymousDefaultExport) Check(ctx *Context, node *shimast.Node) {
+	switch node.Kind {
+	case shimast.KindExportAssignment:
+		assign := node.AsExportAssignment()
+		if assign == nil || assign.IsExportEquals || assign.Expression == nil {
+			return
+		}
+		expr := stripParens(assign.Expression)
+		if expr == nil {
+			return
+		}
+		switch expr.Kind {
+		case shimast.KindFunctionExpression:
+			if fn := expr.AsFunctionExpression(); fn != nil && fn.Name() == nil {
+				ctx.Report(node, "Give a name to the default export.")
+			}
+		case shimast.KindArrowFunction:
+			// Arrow functions never bind a name; an `export default` of
+			// one is always anonymous.
+			ctx.Report(node, "Give a name to the default export.")
+		case shimast.KindClassExpression:
+			if cls := expr.AsClassExpression(); cls != nil && cls.Name() == nil {
+				ctx.Report(node, "Give a name to the default export.")
+			}
+		}
+	case shimast.KindFunctionDeclaration, shimast.KindClassDeclaration:
+		if !hasModifier(node, shimast.KindExportKeyword) ||
+			!hasModifier(node, shimast.KindDefaultKeyword) {
+			return
+		}
+		if node.Name() == nil {
+			ctx.Report(node, "Give a name to the default export.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornNoAnonymousDefaultExport{})
+}

package/linthost/rules_unicorn_no_array_callback_reference.go

@@ -0,0 +1,65 @@
+// unicorn/no-array-callback-reference: passing a function reference
+// directly to an `Array#…` iteration method silently exposes it to
+// extra positional arguments. `[1,2,3].filter(isEven)` passes `isEven`
+// the index and the source array as well as the element, which is fine
+// for `isEven` but breaks the moment the predicate's signature grows
+// optional parameters. Wrapping in an arrow that takes just the value
+// pins the call shape locally.
+//
+// AST-only: each visited `CallExpression` is matched against a
+// property-access callee whose method name is one of the iteration
+// methods, and the first argument is checked for the bare-identifier
+// shape. Anything more elaborate (member access, arrow, call result)
+// has already named the call shape explicitly and is out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-callback-reference.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoArrayCallbackReferenceMethods = map[string]struct{}{
+	"every":         {},
+	"filter":        {},
+	"find":          {},
+	"findIndex":     {},
+	"findLast":      {},
+	"findLastIndex": {},
+	"flatMap":       {},
+	"forEach":       {},
+	"map":           {},
+	"some":          {},
+}
+
+type unicornNoArrayCallbackReference struct{}
+
+func (unicornNoArrayCallbackReference) Name() string {
+	return "unicorn/no-array-callback-reference"
+}
+func (unicornNoArrayCallbackReference) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayCallbackReference) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	method := identifierText(access.Name())
+	if _, ok := unicornNoArrayCallbackReferenceMethods[method]; !ok {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+		return
+	}
+	first := call.Arguments.Nodes[0]
+	if first == nil || first.Kind != shimast.KindIdentifier {
+		return
+	}
+	ctx.Report(first, "Don't pass a function reference directly to `Array#"+method+"` — wrap it in an arrow that takes only the value.")
+}
+
+func init() {
+	Register(unicornNoArrayCallbackReference{})
+}

package/linthost/rules_unicorn_no_array_for_each.go

@@ -0,0 +1,40 @@
+// unicorn/no-array-for-each: `Array#forEach` is harder to short-circuit and
+// to reason about than a `for…of` loop — `break`/`continue`/`return` from
+// the loop body all become per-iteration callback returns with different
+// semantics, and async/await inside the callback silently no-ops because
+// the iteration callback is not awaited.
+//
+// AST-only: dispatch on each `CallExpression`, look for a property-access
+// callee whose method identifier is `forEach`, and fire on the call. The
+// receiver expression is not type-checked — the syntactic shape is the
+// signal the rule wants to discourage, regardless of whether the value is
+// known to be an array at the type level.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-for-each.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoArrayForEach struct{}
+
+func (unicornNoArrayForEach) Name() string { return "unicorn/no-array-for-each" }
+func (unicornNoArrayForEach) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayForEach) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Name()) != "forEach" {
+		return
+	}
+	ctx.Report(node, "Use `for…of` instead of `.forEach(…)`.")
+}
+
+func init() {
+	Register(unicornNoArrayForEach{})
+}

package/linthost/rules_unicorn_no_array_method_this_argument.go

@@ -0,0 +1,61 @@
+// unicorn/no-array-method-this-argument: the iteration methods on
+// `Array.prototype` accept an optional `thisArg` after the callback. The
+// runtime binds that `thisArg` only for non-arrow callbacks — arrow
+// callbacks ignore it entirely — so the second argument's behavior
+// depends on the callable shape of the first. Replacing it with a closure
+// that captures the intended value makes the binding unambiguous and
+// arrow-safe.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose method identifier is one of the Array.prototype iteration methods
+// that accept a thisArg, and fire when the call has exactly two
+// arguments. One argument is the canonical no-thisArg shape; three or
+// more means a different callsite signature and is out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-method-this-argument.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoArrayMethodThisArgumentMethods = map[string]struct{}{
+	"every":         {},
+	"filter":        {},
+	"find":          {},
+	"findIndex":     {},
+	"findLast":      {},
+	"findLastIndex": {},
+	"flatMap":       {},
+	"forEach":       {},
+	"map":           {},
+	"some":          {},
+}
+
+type unicornNoArrayMethodThisArgument struct{}
+
+func (unicornNoArrayMethodThisArgument) Name() string {
+	return "unicorn/no-array-method-this-argument"
+}
+func (unicornNoArrayMethodThisArgument) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayMethodThisArgument) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	method := identifierText(access.Name())
+	if _, ok := unicornNoArrayMethodThisArgumentMethods[method]; !ok {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+		return
+	}
+	ctx.Report(node, "Don't use `thisArg` on `Array#"+method+"` — use an explicit closure that captures the value instead.")
+}
+
+func init() {
+	Register(unicornNoArrayMethodThisArgument{})
+}

package/linthost/rules_unicorn_no_array_reduce.go

@@ -0,0 +1,41 @@
+// unicorn/no-array-reduce: `Array#reduce` and `Array#reduceRight` collapse
+// an iteration into a single callback that has to encode both the
+// accumulator state and the per-element step, which routinely produces
+// less-readable code than an explicit loop. The rule pushes authors
+// toward `for…of` (or a typed accumulator initialized outside the loop)
+// so the state and the step live on separate lines.
+//
+// AST-only: visit each `CallExpression`, check that the callee is a
+// property access whose method identifier is `reduce` or `reduceRight`,
+// and fire on the call. The receiver expression is not type-checked —
+// the syntactic shape is the signal the rule wants to discourage.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-reduce.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoArrayReduce struct{}
+
+func (unicornNoArrayReduce) Name() string { return "unicorn/no-array-reduce" }
+func (unicornNoArrayReduce) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayReduce) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	method := identifierText(access.Name())
+	if method != "reduce" && method != "reduceRight" {
+		return
+	}
+	ctx.Report(node, "Avoid `Array#"+method+"()` — use an explicit loop or `for…of` instead.")
+}
+
+func init() {
+	Register(unicornNoArrayReduce{})
+}

package/linthost/rules_unicorn_no_array_reverse.go

@@ -0,0 +1,44 @@
+// unicorn/no-array-reverse: `Array#reverse()` mutates the array in place
+// and also returns the same reference, which lets aliasing bugs slip into
+// otherwise-pure pipelines (`const out = input.reverse()` rewrites
+// `input` too). ES2023 ships `Array#toReversed()`, which produces a new
+// array and leaves the source untouched, so the rule pushes authors
+// toward the non-mutating form.
+//
+// AST-only: visit each `CallExpression`, check that the callee is a
+// property access whose method identifier is `reverse`, and require zero
+// arguments — `reverse` accepts none, so a non-empty argument list is
+// almost certainly a different `reverse` on a user-defined type and is
+// excluded by design.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-reverse.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoArrayReverse struct{}
+
+func (unicornNoArrayReverse) Name() string { return "unicorn/no-array-reverse" }
+func (unicornNoArrayReverse) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayReverse) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Name()) != "reverse" {
+		return
+	}
+	if call.Arguments != nil && len(call.Arguments.Nodes) != 0 {
+		return
+	}
+	ctx.Report(node, "Prefer `Array#toReversed()` over the mutating `Array#reverse()`.")
+}
+
+func init() {
+	Register(unicornNoArrayReverse{})
+}