@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_unicorn_prefer_native_coercion_functions.go

@@ -0,0 +1,114 @@
+// unicorn/prefer-native-coercion-functions: an arrow that does nothing
+// but pass its parameter to `String` / `Number` / `Boolean` / `BigInt`
+// / `Symbol` is a wrapper around a function that already has the same
+// signature. Passing the built-in reference directly drops a closure
+// allocation, a stack frame, and a layer of indirection at every call
+// site while reading as the operation it actually performs.
+//
+// AST-only: visit `KindArrowFunction` and `KindFunctionExpression`. Fire
+// when the function takes exactly one bare-identifier parameter AND its
+// body is either an arrow expression body that calls one of the named
+// constructors with the parameter as the sole argument, or a block body
+// with a single `return <Name>(<param>);` statement.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-native-coercion-functions.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferNativeCoercionFunctions struct{}
+
+func (unicornPreferNativeCoercionFunctions) Name() string {
+	return "unicorn/prefer-native-coercion-functions"
+}
+func (unicornPreferNativeCoercionFunctions) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindArrowFunction, shimast.KindFunctionExpression}
+}
+func (unicornPreferNativeCoercionFunctions) Check(ctx *Context, node *shimast.Node) {
+	params := node.Parameters()
+	if len(params) != 1 {
+		return
+	}
+	paramName := parameterIdentifierName(params[0])
+	if paramName == "" {
+		return
+	}
+	var body *shimast.Node
+	switch node.Kind {
+	case shimast.KindArrowFunction:
+		if arrow := node.AsArrowFunction(); arrow != nil {
+			body = arrow.Body
+		}
+	case shimast.KindFunctionExpression:
+		if fn := node.AsFunctionExpression(); fn != nil {
+			body = fn.Body
+		}
+	}
+	if body == nil {
+		return
+	}
+	call := unicornPreferNativeCoercionBodyCall(body)
+	if call == nil {
+		return
+	}
+	if !unicornPreferNativeCoercionIsCoercion(call, paramName) {
+		return
+	}
+	ctx.Report(node, "Use the bare `String` / `Number` / `Boolean` / `BigInt` function reference instead of an arrow wrapper.")
+}
+
+// unicornPreferNativeCoercionBodyCall normalizes a function body to the
+// inner `CallExpression`. A concise arrow body returns its expression
+// directly; a block body must contain exactly one `return <expr>;` and
+// the returned expression must itself be a call.
+func unicornPreferNativeCoercionBodyCall(body *shimast.Node) *shimast.Node {
+	if body == nil {
+		return nil
+	}
+	if body.Kind != shimast.KindBlock {
+		expr := stripParens(body)
+		if expr == nil || expr.Kind != shimast.KindCallExpression {
+			return nil
+		}
+		return expr
+	}
+	block := body.AsBlock()
+	if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+		return nil
+	}
+	stmt := block.Statements.Nodes[0]
+	if stmt == nil || stmt.Kind != shimast.KindReturnStatement {
+		return nil
+	}
+	ret := stmt.AsReturnStatement()
+	if ret == nil || ret.Expression == nil {
+		return nil
+	}
+	expr := stripParens(ret.Expression)
+	if expr == nil || expr.Kind != shimast.KindCallExpression {
+		return nil
+	}
+	return expr
+}
+
+// unicornPreferNativeCoercionIsCoercion reports whether `call` is a
+// `String|Number|Boolean|BigInt|Symbol(<param>)` invocation where the
+// single argument is the parameter identifier.
+func unicornPreferNativeCoercionIsCoercion(call *shimast.Node, paramName string) bool {
+	c := call.AsCallExpression()
+	if c == nil || c.Expression == nil {
+		return false
+	}
+	switch identifierText(c.Expression) {
+	case "String", "Number", "Boolean", "BigInt", "Symbol":
+	default:
+		return false
+	}
+	if c.Arguments == nil || len(c.Arguments.Nodes) != 1 {
+		return false
+	}
+	return identifierText(stripParens(c.Arguments.Nodes[0])) == paramName
+}
+
+func init() {
+	Register(unicornPreferNativeCoercionFunctions{})
+}

package/linthost/rules_unicorn_prefer_negative_index.go

@@ -0,0 +1,74 @@
+// unicorn/prefer-negative-index: `arr.slice(arr.length - N)` is the
+// long-hand spelling of `arr.slice(-N)`. The subtraction repeats the
+// receiver, allocates an extra read, and obscures the intent. The same
+// idiom shows up across `slice`, `splice`, `toSpliced`, `at`, and
+// `lastIndexOf`; all five accept a negative index that means the same
+// thing the subtraction expresses, so the rule pushes authors there.
+//
+// AST-only: visit `KindCallExpression`. Fire when the callee is
+// `PropertyAccess(_, name)` for one of those five method names AND the
+// first argument is a `KindBinaryExpression` with operator `-`, LHS a
+// `PropertyAccess(_, length)`, and RHS a positive numeric literal.
+// Reports on the offending argument so the diagnostic anchors to the
+// expression the author would rewrite.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-negative-index.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferNegativeIndex struct{}
+
+func (unicornPreferNegativeIndex) Name() string { return "unicorn/prefer-negative-index" }
+func (unicornPreferNegativeIndex) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferNegativeIndex) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return
+	}
+	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	switch identifierText(access.Name()) {
+	case "slice", "splice", "toSpliced", "at", "lastIndexOf":
+	default:
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+		return
+	}
+	first := stripParens(call.Arguments.Nodes[0])
+	if first == nil || first.Kind != shimast.KindBinaryExpression {
+		return
+	}
+	bin := first.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil ||
+		bin.OperatorToken.Kind != shimast.KindMinusToken {
+		return
+	}
+	left := stripParens(bin.Left)
+	if left == nil || left.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	prop := left.AsPropertyAccessExpression()
+	if prop == nil || identifierText(prop.Name()) != "length" {
+		return
+	}
+	right := stripParens(bin.Right)
+	if right == nil || right.Kind != shimast.KindNumericLiteral {
+		return
+	}
+	if !unicornPreferAtIsPositiveInteger(numericLiteralText(right)) {
+		return
+	}
+	ctx.Report(first, "Use a negative index (`-N`) instead of `arr.length - N`.")
+}
+
+func init() {
+	Register(unicornPreferNegativeIndex{})
+}

package/linthost/rules_unicorn_prefer_node_protocol.go

@@ -0,0 +1,122 @@
+// unicorn/prefer-node-protocol: the bare Node built-in specifier
+// (`import "fs"` / `require("fs")`) is ambiguous — a userland package
+// named `fs` on the module path resolves first, silently hijacking
+// what readers assume is the Node built-in. The `node:` prefix removes
+// the ambiguity and is supported by every modern Node release.
+//
+// AST-only: visit `ImportDeclaration` for the static-import case and
+// `CallExpression` for the `require(...)` case. Both reduce to a
+// single string-literal specifier compared against the allowlist of
+// Node built-in module names; matching specifiers (without the
+// `node:` prefix) fire on the literal node itself so the diagnostic
+// underlines the specifier text the reader needs to change.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-node-protocol.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// unicornPreferNodeProtocolBuiltins enumerates the bare Node built-in
+// module specifiers that must be rewritten to use the `node:` prefix.
+var unicornPreferNodeProtocolBuiltins = map[string]struct{}{
+	"assert":              {},
+	"assert/strict":       {},
+	"async_hooks":         {},
+	"buffer":              {},
+	"child_process":       {},
+	"cluster":             {},
+	"console":             {},
+	"constants":           {},
+	"crypto":              {},
+	"dgram":               {},
+	"diagnostics_channel": {},
+	"dns":                 {},
+	"dns/promises":        {},
+	"domain":              {},
+	"events":              {},
+	"fs":                  {},
+	"fs/promises":         {},
+	"http":                {},
+	"http2":               {},
+	"https":               {},
+	"inspector":           {},
+	"module":              {},
+	"net":                 {},
+	"os":                  {},
+	"path":                {},
+	"path/posix":          {},
+	"path/win32":          {},
+	"perf_hooks":          {},
+	"process":             {},
+	"punycode":            {},
+	"querystring":         {},
+	"readline":            {},
+	"readline/promises":   {},
+	"repl":                {},
+	"stream":              {},
+	"stream/consumers":    {},
+	"stream/promises":     {},
+	"stream/web":          {},
+	"string_decoder":      {},
+	"sys":                 {},
+	"timers":              {},
+	"timers/promises":     {},
+	"tls":                 {},
+	"trace_events":        {},
+	"tty":                 {},
+	"url":                 {},
+	"util":                {},
+	"util/types":          {},
+	"v8":                  {},
+	"vm":                  {},
+	"wasi":                {},
+	"worker_threads":      {},
+	"zlib":                {},
+}
+
+type unicornPreferNodeProtocol struct{}
+
+func (unicornPreferNodeProtocol) Name() string { return "unicorn/prefer-node-protocol" }
+func (unicornPreferNodeProtocol) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindCallExpression}
+}
+func (unicornPreferNodeProtocol) Check(ctx *Context, node *shimast.Node) {
+	switch node.Kind {
+	case shimast.KindImportDeclaration:
+		imp := node.AsImportDeclaration()
+		if imp == nil || imp.ModuleSpecifier == nil {
+			return
+		}
+		if imp.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+			return
+		}
+		specifier := stringLiteralText(imp.ModuleSpecifier)
+		if _, ok := unicornPreferNodeProtocolBuiltins[specifier]; !ok {
+			return
+		}
+		ctx.Report(imp.ModuleSpecifier, "Prefer `node:` protocol when importing Node built-ins.")
+	case shimast.KindCallExpression:
+		call := node.AsCallExpression()
+		if call == nil || call.Expression == nil {
+			return
+		}
+		if identifierText(call.Expression) != "require" {
+			return
+		}
+		if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+			return
+		}
+		arg := call.Arguments.Nodes[0]
+		if arg == nil || arg.Kind != shimast.KindStringLiteral {
+			return
+		}
+		specifier := stringLiteralText(arg)
+		if _, ok := unicornPreferNodeProtocolBuiltins[specifier]; !ok {
+			return
+		}
+		ctx.Report(arg, "Prefer `node:` protocol when importing Node built-ins.")
+	}
+}
+
+func init() {
+	Register(unicornPreferNodeProtocol{})
+}

package/linthost/rules_unicorn_prefer_number_properties.go

@@ -0,0 +1,88 @@
+// unicorn/prefer-number-properties: the global functions `isNaN`,
+// `isFinite`, `parseFloat`, `parseInt`, and the global constants `NaN`,
+// `Infinity` were aliased onto the `Number` namespace in ES2015. The
+// `Number.*` forms coerce more predictably (`Number.isNaN("abc")` is
+// `false`, while the global `isNaN("abc")` is `true`) and are more
+// discoverable. The rule pushes authors to the namespaced spellings.
+//
+// AST-only: visit each `Identifier`. The text must be one of the six
+// shadowable names. The identifier must be in a value-expression
+// position — not the name part of a property access (`obj.isNaN`),
+// not the key of a property assignment, and not a binding name. Reports
+// on the identifier.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-number-properties.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornPreferNumberPropertiesNames = map[string]struct{}{
+	"isNaN":      {},
+	"isFinite":   {},
+	"parseFloat": {},
+	"parseInt":   {},
+	"NaN":        {},
+	"Infinity":   {},
+}
+
+type unicornPreferNumberProperties struct{}
+
+func (unicornPreferNumberProperties) Name() string {
+	return "unicorn/prefer-number-properties"
+}
+func (unicornPreferNumberProperties) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindIdentifier}
+}
+func (unicornPreferNumberProperties) Check(ctx *Context, node *shimast.Node) {
+	name := identifierText(node)
+	if _, ok := unicornPreferNumberPropertiesNames[name]; !ok {
+		return
+	}
+	parent := node.Parent
+	if parent == nil {
+		return
+	}
+	switch parent.Kind {
+	case shimast.KindPropertyAccessExpression:
+		// `obj.isNaN` — the identifier is the property name, not a
+		// reference to the global. `Number.isNaN(...)` itself also
+		// reaches here and must not be flagged.
+		access := parent.AsPropertyAccessExpression()
+		if access != nil && access.Name() == node {
+			return
+		}
+	case shimast.KindQualifiedName:
+		// Type-position `A.B` — same rationale as PropertyAccess.
+		return
+	case shimast.KindPropertyAssignment,
+		shimast.KindShorthandPropertyAssignment,
+		shimast.KindMethodDeclaration,
+		shimast.KindPropertyDeclaration,
+		shimast.KindEnumMember,
+		shimast.KindPropertySignature,
+		shimast.KindMethodSignature,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor:
+		// Member name slots on object/class shapes.
+		return
+	case shimast.KindParameter,
+		shimast.KindVariableDeclaration,
+		shimast.KindBindingElement,
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindClassDeclaration,
+		shimast.KindClassExpression,
+		shimast.KindImportSpecifier,
+		shimast.KindImportClause,
+		shimast.KindNamespaceImport,
+		shimast.KindExportSpecifier,
+		shimast.KindTypeParameter,
+		shimast.KindLabeledStatement:
+		// Binding / declaration names, not references to the global.
+		return
+	}
+	ctx.Report(node, "Prefer `Number.<X>` over the global `<X>` (e.g. `Number.isNaN`, `Number.parseInt`).")
+}
+
+func init() {
+	Register(unicornPreferNumberProperties{})
+}

package/linthost/rules_unicorn_prefer_object_from_entries.go

@@ -0,0 +1,55 @@
+// unicorn/prefer-object-from-entries: `entries.reduce((acc, [k, v]) =>
+// ({ ...acc, [k]: v }), {})` is the long-hand spelling of
+// `Object.fromEntries(entries)`. The reduce shape allocates a fresh
+// object at every step (O(n^2) total), reads as the operation rather
+// than the intent, and quietly drops to `Object` from whatever type the
+// entry shape implied. `Object.fromEntries` does the same thing in one
+// pass with one allocation and one well-known name.
+//
+// AST-only: visit `KindCallExpression`. Fire when the callee is
+// `PropertyAccess(_, reduce)` AND the call has exactly two arguments AND
+// the second argument is an empty `KindObjectLiteralExpression`. The
+// shape of the reducer is intentionally not inspected: an empty-object
+// seed in a `.reduce` chain is, in practice, the from-entries shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-object-from-entries.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferObjectFromEntries struct{}
+
+func (unicornPreferObjectFromEntries) Name() string {
+	return "unicorn/prefer-object-from-entries"
+}
+func (unicornPreferObjectFromEntries) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferObjectFromEntries) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return
+	}
+	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil || identifierText(access.Name()) != "reduce" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+		return
+	}
+	seed := stripParens(call.Arguments.Nodes[1])
+	if seed == nil || seed.Kind != shimast.KindObjectLiteralExpression {
+		return
+	}
+	obj := seed.AsObjectLiteralExpression()
+	if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 0 {
+		return
+	}
+	ctx.Report(node, "Prefer `Object.fromEntries(...)` over `.reduce((acc, ...) => ..., {})` patterns.")
+}
+
+func init() {
+	Register(unicornPreferObjectFromEntries{})
+}

package/linthost/rules_unicorn_prefer_optional_catch_binding.go

@@ -0,0 +1,62 @@
+// unicorn/prefer-optional-catch-binding: ES2019 introduced optional
+// catch bindings (`catch { ... }`) so that catch clauses that never
+// reference the thrown error don't need to declare a binding at all.
+// Holding onto the binding name keeps a dead local variable in source
+// and signals that the catch body still cares about the error when in
+// fact it doesn't.
+//
+// AST-only: visit each `CatchClause`, restrict to the common-case
+// binding names `e` and `error` (true scope analysis would require a
+// resolver), and confirm the body's source text does not contain the
+// binding name as a word-bounded identifier. The previous substring
+// scan was load-bearing-wrong: `strings.Contains(body, "e")` matches
+// nearly any English identifier, hiding the rule entirely; word
+// boundaries (`\bname\b`) correctly distinguish `e` from `error`,
+// `error` from `errorMessage`, etc. False positives on `name` inside
+// string literals or comments are acceptable because the rule is
+// conservative by design.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-optional-catch-binding.md
+package linthost
+
+import (
+	"regexp"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+var unicornPreferOptionalCatchBindingNamePattern = map[string]*regexp.Regexp{
+	"e":     regexp.MustCompile(`\be\b`),
+	"error": regexp.MustCompile(`\berror\b`),
+}
+
+type unicornPreferOptionalCatchBinding struct{}
+
+func (unicornPreferOptionalCatchBinding) Name() string {
+	return "unicorn/prefer-optional-catch-binding"
+}
+func (unicornPreferOptionalCatchBinding) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCatchClause}
+}
+func (unicornPreferOptionalCatchBinding) Check(ctx *Context, node *shimast.Node) {
+	catch := node.AsCatchClause()
+	if catch == nil || catch.VariableDeclaration == nil || catch.Block == nil {
+		return
+	}
+	binding := catch.VariableDeclaration.Name()
+	if binding == nil || binding.Kind != shimast.KindIdentifier {
+		return
+	}
+	name := identifierText(binding)
+	pattern, ok := unicornPreferOptionalCatchBindingNamePattern[name]
+	if !ok {
+		return
+	}
+	if pattern.MatchString(nodeText(ctx.File, catch.Block)) {
+		return
+	}
+	ctx.Report(binding, "Prefer optional catch binding `catch { ... }` when the error is unused.")
+}
+
+func init() {
+	Register(unicornPreferOptionalCatchBinding{})
+}

package/linthost/rules_unicorn_prefer_prototype_methods.go

@@ -0,0 +1,54 @@
+// unicorn/prefer-prototype-methods: `[].slice`, `[].push`,
+// `{}.hasOwnProperty` and similar empty-literal property accesses are
+// shorthand for grabbing a prototype method without typing
+// `Array.prototype.slice` / `Object.prototype.hasOwnProperty`. The
+// shorthand allocates a throwaway literal at every call, hides the
+// intent of borrowing a prototype method, and is slower than the
+// direct prototype lookup.
+//
+// AST-only: visit each `PropertyAccessExpression`, then match the
+// receiver against either an empty `ArrayLiteralExpression` (no
+// elements) or an empty `ObjectLiteralExpression` (no properties).
+// The property name is intentionally not restricted — any borrowed
+// method should switch to the explicit `<Constructor>.prototype.<m>`
+// form.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-prototype-methods.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferPrototypeMethods struct{}
+
+func (unicornPreferPrototypeMethods) Name() string { return "unicorn/prefer-prototype-methods" }
+func (unicornPreferPrototypeMethods) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornPreferPrototypeMethods) Check(ctx *Context, node *shimast.Node) {
+	access := node.AsPropertyAccessExpression()
+	if access == nil || access.Expression == nil {
+		return
+	}
+	receiver := stripParens(access.Expression)
+	if receiver == nil {
+		return
+	}
+	switch receiver.Kind {
+	case shimast.KindArrayLiteralExpression:
+		arr := receiver.AsArrayLiteralExpression()
+		if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 0 {
+			return
+		}
+	case shimast.KindObjectLiteralExpression:
+		obj := receiver.AsObjectLiteralExpression()
+		if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 0 {
+			return
+		}
+	default:
+		return
+	}
+	ctx.Report(node, "Use `Array.prototype.<method>` / `Object.prototype.<method>` instead of borrowing via an empty literal.")
+}
+
+func init() {
+	Register(unicornPreferPrototypeMethods{})
+}

package/linthost/rules_unicorn_prefer_query_selector.go

@@ -0,0 +1,56 @@
+// unicorn/prefer-query-selector: `getElementById`,
+// `getElementsByClassName`, and `getElementsByTagName` predate the CSS
+// selector family on `Document` and `Element`. Unifying every lookup on
+// `querySelector` / `querySelectorAll` lets callers compose selectors
+// without juggling three different method signatures and live-collection
+// semantics.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose method identifier is one of the legacy lookup names, and fire
+// when the call has exactly one string-literal argument. The
+// string-literal gate isolates the canonical id/class/tag shape from
+// runtime-built argument expressions that the rule would mis-suggest a
+// selector for.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-query-selector.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornPreferQuerySelectorMethods = map[string]struct{}{
+	"getElementById":         {},
+	"getElementsByClassName": {},
+	"getElementsByTagName":   {},
+}
+
+type unicornPreferQuerySelector struct{}
+
+func (unicornPreferQuerySelector) Name() string { return "unicorn/prefer-query-selector" }
+func (unicornPreferQuerySelector) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferQuerySelector) 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 := unicornPreferQuerySelectorMethods[method]; !ok {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+		return
+	}
+	arg := call.Arguments.Nodes[0]
+	if arg == nil || arg.Kind != shimast.KindStringLiteral {
+		return
+	}
+	ctx.Report(node, "Prefer `querySelector` / `querySelectorAll` over `"+method+"`.")
+}
+
+func init() {
+	Register(unicornPreferQuerySelector{})
+}

package/linthost/rules_unicorn_prefer_reflect_apply.go

@@ -0,0 +1,36 @@
+// unicorn/prefer-reflect-apply: `Function.prototype.apply.call(fn, thisArg, args)`
+// is the long-hand pre-`Reflect.apply` workaround for invoking `apply`
+// when the receiver may have shadowed it. `Reflect.apply(fn, thisArg, args)`
+// expresses the same intent in a single named operation and survives
+// `apply` being deleted from the prototype chain.
+//
+// AST-only and text-driven: visit each `CallExpression` and match the
+// callee against the exact textual chain `Function.prototype.apply.call`.
+// Comparing against the source text is the cleanest conservative
+// recognition; alternate spellings (computed access, intermediate
+// aliases) are intentionally out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-reflect-apply.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferReflectApply struct{}
+
+func (unicornPreferReflectApply) Name() string { return "unicorn/prefer-reflect-apply" }
+func (unicornPreferReflectApply) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferReflectApply) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return
+	}
+	if nodeText(ctx.File, call.Expression) != "Function.prototype.apply.call" {
+		return
+	}
+	ctx.Report(node, "Prefer `Reflect.apply` over `Function.prototype.apply.call`.")
+}
+
+func init() {
+	Register(unicornPreferReflectApply{})
+}