@ttsc/lint 0.13.1 → 0.14.0-dev.20260528

package/linthost/rules_unicorn_no_array_sort.go

@@ -0,0 +1,43 @@
+// unicorn/no-array-sort: `Array#sort()` mutates the array in place and
+// returns the same reference, so any caller holding the original sees
+// the sorted order too. ES2023 introduced `Array#toSorted()`, which
+// returns a fresh sorted copy and leaves the source untouched; 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 `sort`, and accept either
+// zero arguments or exactly one (the optional comparator). Calls with
+// two or more arguments are almost certainly a different `sort` on a
+// user-defined type and are excluded by design.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-sort.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoArraySort struct{}
+
+func (unicornNoArraySort) Name() string { return "unicorn/no-array-sort" }
+func (unicornNoArraySort) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArraySort) 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()) != "sort" {
+		return
+	}
+	if call.Arguments != nil && len(call.Arguments.Nodes) > 1 {
+		return
+	}
+	ctx.Report(node, "Prefer `Array#toSorted()` over the mutating `Array#sort()`.")
+}
+
+func init() {
+	Register(unicornNoArraySort{})
+}

package/linthost/rules_unicorn_no_await_expression_member.go

@@ -0,0 +1,40 @@
+// unicorn/no-await-expression-member: `(await foo).bar` and
+// `(await foo)[index]` mix two reading positions in one expression —
+// the resolution step (`await foo`) and the projection step (`.bar`).
+// Splitting them into a temporary `const value = await foo; value.bar`
+// makes the order of operations explicit and lines up better with
+// stepping through the async function in a debugger.
+//
+// AST-only: any `PropertyAccessExpression` whose receiver is an
+// `AwaitExpression` (possibly wrapped in `ParenthesizedExpression`) fires.
+// `ElementAccessExpression` is left out of this minimal pass — the
+// PropertyAccess shape is the canonical violation cited in the upstream
+// docs and matches the receiver shape directly via `stripParens`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-await-expression-member.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoAwaitExpressionMember struct{}
+
+func (unicornNoAwaitExpressionMember) Name() string {
+	return "unicorn/no-await-expression-member"
+}
+func (unicornNoAwaitExpressionMember) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornNoAwaitExpressionMember) Check(ctx *Context, node *shimast.Node) {
+	access := node.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	receiver := stripParens(access.Expression)
+	if receiver == nil || receiver.Kind != shimast.KindAwaitExpression {
+		return
+	}
+	ctx.Report(node, "Don't use member access on an `await` expression — assign the awaited value to a variable first.")
+}
+
+func init() {
+	Register(unicornNoAwaitExpressionMember{})
+}

package/linthost/rules_unicorn_no_await_in_promise_methods.go

@@ -0,0 +1,69 @@
+// unicorn/no-await-in-promise-methods: awaiting an element inside the
+// array argument of `Promise.all` / `Promise.allSettled` / `Promise.race`
+// / `Promise.any` defeats the parallelism the call exists for. The
+// awaits resolve serially in source order before the array is even
+// handed to `Promise.<method>`, so the combinator only sees the
+// already-resolved values.
+//
+// AST-only: visit each `CallExpression`, match the callee against
+// `Promise.<method>` for the four parallel combinators, and check the
+// sole argument's `ArrayLiteralExpression` elements for any
+// `AwaitExpression` shape. Fire on the offending await node so the
+// report anchors to the actual misuse.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-await-in-promise-methods.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoAwaitInPromiseMethodsMethods = map[string]struct{}{
+	"all":        {},
+	"allSettled": {},
+	"race":       {},
+	"any":        {},
+}
+
+type unicornNoAwaitInPromiseMethods struct{}
+
+func (unicornNoAwaitInPromiseMethods) Name() string {
+	return "unicorn/no-await-in-promise-methods"
+}
+func (unicornNoAwaitInPromiseMethods) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoAwaitInPromiseMethods) 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.Expression) != "Promise" {
+		return
+	}
+	method := identifierText(access.Name())
+	if _, ok := unicornNoAwaitInPromiseMethodsMethods[method]; !ok {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+		return
+	}
+	arg := call.Arguments.Nodes[0]
+	if arg == nil || arg.Kind != shimast.KindArrayLiteralExpression {
+		return
+	}
+	arr := arg.AsArrayLiteralExpression()
+	if arr == nil || arr.Elements == nil {
+		return
+	}
+	for _, elem := range arr.Elements.Nodes {
+		if elem != nil && elem.Kind == shimast.KindAwaitExpression {
+			ctx.Report(elem, "Don't `await` inside `Promise."+method+"` array members — the awaits serialize the calls.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornNoAwaitInPromiseMethods{})
+}

package/linthost/rules_unicorn_no_console_spaces.go

@@ -0,0 +1,61 @@
+// unicorn/no-console-spaces: `console.log("a ", "b")` produces
+// `"a  b"` with a doubled space because the runtime already inserts a
+// single ASCII space between arguments. Leading/trailing whitespace on
+// the literal duplicates that separator and is almost always a leftover
+// from hand-formatting. The rule flags every string-literal argument
+// whose content starts or ends with a space so the source converges on
+// argument-only content and the runtime owns the separator.
+//
+// AST-only and identifier-text-driven: dispatch on `CallExpression`,
+// match a `console.<method>` callee against the six common log
+// methods, and report each `StringLiteral` argument with a leading or
+// trailing space. The receiver is matched by identifier text only;
+// shadowed `console` bindings are out of scope, mirroring the other
+// console-shape rules in this family.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-console-spaces.md
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornNoConsoleSpaces struct{}
+
+func (unicornNoConsoleSpaces) Name() string { return "unicorn/no-console-spaces" }
+func (unicornNoConsoleSpaces) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoConsoleSpaces) 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 || identifierText(access.Expression) != "console" {
+		return
+	}
+	switch identifierText(access.Name()) {
+	case "log", "warn", "error", "info", "debug", "trace":
+	default:
+		return
+	}
+	if call.Arguments == nil {
+		return
+	}
+	for _, arg := range call.Arguments.Nodes {
+		if arg == nil || arg.Kind != shimast.KindStringLiteral {
+			continue
+		}
+		text := stringLiteralText(arg)
+		if strings.HasPrefix(text, " ") || strings.HasSuffix(text, " ") {
+			ctx.Report(arg, "Don't include leading or trailing spaces in `console.<method>` arguments.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornNoConsoleSpaces{})
+}

package/linthost/rules_unicorn_no_document_cookie.go

@@ -0,0 +1,41 @@
+// unicorn/no-document-cookie: writing to (or reading) `document.cookie`
+// directly mixes name/value parsing, serialization, attribute handling,
+// and quoting concerns into one mutable string. The replacement is the
+// async Cookie Store API (`cookieStore.set`/`cookieStore.get`) or a
+// dedicated cookie wrapper — both surface attribute fields as data
+// instead of string-encoded options.
+//
+// AST-only and identifier-text-driven: any `PropertyAccessExpression`
+// whose receiver identifier is `document` and whose property name is
+// `cookie` matches, so the same visit handles both the read
+// (`document.cookie`) and the assignment LHS (`document.cookie = "..."`).
+// Shadowed `document` bindings and computed/optional access are out of
+// scope, mirroring `unicorn/no-process-exit`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-document-cookie.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoDocumentCookie struct{}
+
+func (unicornNoDocumentCookie) Name() string { return "unicorn/no-document-cookie" }
+func (unicornNoDocumentCookie) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornNoDocumentCookie) Check(ctx *Context, node *shimast.Node) {
+	access := node.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Expression) != "document" {
+		return
+	}
+	if identifierText(access.Name()) != "cookie" {
+		return
+	}
+	ctx.Report(node, "Don't use `document.cookie` directly; use the Cookie Store API or a wrapper.")
+}
+
+func init() {
+	Register(unicornNoDocumentCookie{})
+}

package/linthost/rules_unicorn_no_empty_file.go

@@ -0,0 +1,44 @@
+// unicorn/no-empty-file: a source file with no executable contribution
+// — every statement is a bare `;` empty-statement (or there are no
+// statements at all) — usually exists by accident: a placeholder kept
+// around past its purpose, a generator output for a missing input, or
+// a copy of a file whose body was deleted. The rule flags these so the
+// file is either filled with content or removed.
+//
+// SourceFile dispatch: the engine fires `KindSourceFile` visits once
+// per file at the file root (see engine.runFile). For visibility into
+// where the diagnostic lands when reporters render `path:line:col`, the
+// rule reports on the first statement node when one exists (so the
+// pointer matches the file's source line); when the file truly has no
+// statements at all it falls back to `ReportRange(0, 0, …)` so the
+// diagnostic still surfaces.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-empty-file.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoEmptyFile struct{}
+
+func (unicornNoEmptyFile) Name() string           { return "unicorn/no-empty-file" }
+func (unicornNoEmptyFile) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornNoEmptyFile) Check(ctx *Context, node *shimast.Node) {
+	if ctx.File == nil {
+		return
+	}
+	statements := ctx.File.Statements
+	const message = "Empty files are not allowed."
+	if statements == nil || len(statements.Nodes) == 0 {
+		ctx.ReportRange(0, 0, message)
+		return
+	}
+	for _, stmt := range statements.Nodes {
+		if stmt == nil || stmt.Kind != shimast.KindEmptyStatement {
+			return
+		}
+	}
+	ctx.Report(statements.Nodes[0], message)
+}
+
+func init() {
+	Register(unicornNoEmptyFile{})
+}

package/linthost/rules_unicorn_no_for_loop.go

@@ -0,0 +1,102 @@
+// unicorn/no-for-loop: the classic `for (let i = 0; i < arr.length; i++)`
+// pattern is an index-based array walk that has a direct `for…of`
+// translation. The index variable, the length re-read, and the manual
+// increment are all incidental bookkeeping the language now expresses
+// with one keyword.
+//
+// AST-only and syntactic: dispatch on `ForStatement` and match the
+// three classic shapes — `let i = 0` initializer, `i < X.length`
+// condition (the RHS must be a `.length` access; bare counters
+// `i < n` are not flagged because the suggested `for…of` rewrite does
+// not apply), and `i++` incrementor. The length operand is not
+// required to resolve to an array at the type level; the syntactic
+// shape is the signal the rule wants to discourage.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-for-loop.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoForLoop struct{}
+
+func (unicornNoForLoop) Name() string           { return "unicorn/no-for-loop" }
+func (unicornNoForLoop) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindForStatement} }
+func (unicornNoForLoop) Check(ctx *Context, node *shimast.Node) {
+	stmt := node.AsForStatement()
+	if stmt == nil || stmt.Initializer == nil || stmt.Condition == nil || stmt.Incrementor == nil {
+		return
+	}
+	indexName := indexInitializerName(stmt.Initializer)
+	if indexName == "" {
+		return
+	}
+	if !isLessThanCondition(stmt.Condition, indexName) {
+		return
+	}
+	if !isPostfixIncrementOf(stmt.Incrementor, indexName) {
+		return
+	}
+	ctx.Report(node, "Use `for…of` over an index-based `for` loop over an array.")
+}
+
+// indexInitializerName returns the variable name of a `let i = 0`
+// initializer, or "" when the initializer is anything else.
+func indexInitializerName(init *shimast.Node) string {
+	if init == nil || init.Kind != shimast.KindVariableDeclarationList {
+		return ""
+	}
+	list := init.AsVariableDeclarationList()
+	if list == nil || list.Declarations == nil || len(list.Declarations.Nodes) != 1 {
+		return ""
+	}
+	decl := list.Declarations.Nodes[0].AsVariableDeclaration()
+	if decl == nil || decl.Initializer == nil {
+		return ""
+	}
+	if numericLiteralText(stripParens(decl.Initializer)) != "0" {
+		return ""
+	}
+	return identifierText(decl.Name())
+}
+
+// isLessThanCondition reports whether `cond` has the shape
+// `<name> < <something>.length`. The right-hand operand must be a
+// property access ending in `length`; bare counter loops such as
+// `for (let i = 0; i < n; i++)` are NOT flagged because the rule's
+// suggested rewrite (`for…of`) only applies to array iteration.
+func isLessThanCondition(cond *shimast.Node, name string) bool {
+	node := stripParens(cond)
+	if node == nil || node.Kind != shimast.KindBinaryExpression {
+		return false
+	}
+	bin := node.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil ||
+		bin.OperatorToken.Kind != shimast.KindLessThanToken {
+		return false
+	}
+	if identifierText(stripParens(bin.Left)) != name {
+		return false
+	}
+	right := stripParens(bin.Right)
+	if right == nil || right.Kind != shimast.KindPropertyAccessExpression {
+		return false
+	}
+	access := right.AsPropertyAccessExpression()
+	return access != nil && identifierText(access.Name()) == "length"
+}
+
+// isPostfixIncrementOf reports whether `inc` has the shape `<name>++`.
+func isPostfixIncrementOf(inc *shimast.Node, name string) bool {
+	node := stripParens(inc)
+	if node == nil || node.Kind != shimast.KindPostfixUnaryExpression {
+		return false
+	}
+	post := node.AsPostfixUnaryExpression()
+	if post == nil || post.Operator != shimast.KindPlusPlusToken {
+		return false
+	}
+	return identifierText(post.Operand) == name
+}
+
+func init() {
+	Register(unicornNoForLoop{})
+}

package/linthost/rules_unicorn_no_hex_escape.go

@@ -0,0 +1,42 @@
+// unicorn/no-hex-escape: `\xHH` escapes inside string and template
+// literals are legal but they read worse than the equivalent
+// `\u00HH` Unicode escape — there's only one way to write a Unicode
+// escape, while a hex escape silently widens to a Unicode escape at
+// runtime anyway. The rule nudges authors toward the Unicode form.
+//
+// AST-only: visit `KindStringLiteral` and `KindNoSubstitutionTemplateLiteral`,
+// read the raw source text via `nodeText` (the parser already decodes
+// escapes into the `.Text` value, so a normal accessor would see `©`
+// instead of `\xA9`), and fire when the source contains a `\xHH`
+// occurrence where HH is two hex digits.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-hex-escape.md
+package linthost
+
+import (
+	"regexp"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+var unicornNoHexEscapePattern = regexp.MustCompile(`\\x[0-9A-Fa-f]{2}`)
+
+type unicornNoHexEscape struct{}
+
+func (unicornNoHexEscape) Name() string { return "unicorn/no-hex-escape" }
+func (unicornNoHexEscape) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+}
+func (unicornNoHexEscape) Check(ctx *Context, node *shimast.Node) {
+	source := nodeText(ctx.File, node)
+	if source == "" {
+		return
+	}
+	if unicornNoHexEscapePattern.MatchString(source) {
+		ctx.Report(node, "Prefer Unicode escapes (`\\uXXXX`) over hex escapes (`\\xHH`).")
+	}
+}
+
+func init() {
+	Register(unicornNoHexEscape{})
+}

package/linthost/rules_unicorn_no_immediate_mutation.go

@@ -0,0 +1,90 @@
+// unicorn/no-immediate-mutation: mutating an expression on the same
+// statement that produces it — e.g. `[1, 2, 3].push(4)` or
+// `arr.map(...).sort()` — discards the mutator's return value (which is
+// either the new length or `void`) and obscures whether the author
+// wanted the array, the count, or the side effect. The rule splits the
+// two operations: construct first, then mutate (or use the non-mutating
+// counterpart).
+//
+// AST-only: visit each `CallExpression`. Match when the callee is a
+// `PropertyAccessExpression(receiver, name)` where `name` is one of the
+// mutating array methods AND the receiver (after `stripParens`) is
+// either an `ArrayLiteralExpression` or another call expression whose
+// callee is a non-mutating array method that produces a fresh array.
+// Fire on the outer call.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-immediate-mutation.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoImmediateMutationMethods = map[string]struct{}{
+	"push":       {},
+	"pop":        {},
+	"shift":      {},
+	"unshift":    {},
+	"splice":     {},
+	"sort":       {},
+	"reverse":    {},
+	"copyWithin": {},
+	"fill":       {},
+}
+
+var unicornNoImmediateMutationFreshMethods = map[string]struct{}{
+	"map":     {},
+	"filter":  {},
+	"slice":   {},
+	"concat":  {},
+	"flat":    {},
+	"flatMap": {},
+}
+
+type unicornNoImmediateMutation struct{}
+
+func (unicornNoImmediateMutation) Name() string { return "unicorn/no-immediate-mutation" }
+func (unicornNoImmediateMutation) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoImmediateMutation) 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
+	}
+	method := identifierText(access.Name())
+	if _, ok := unicornNoImmediateMutationMethods[method]; !ok {
+		return
+	}
+	receiver := stripParens(access.Expression)
+	if receiver == nil {
+		return
+	}
+	if receiver.Kind == shimast.KindArrayLiteralExpression {
+		ctx.Report(node, "Don't mutate a freshly built array — separate the construction and the mutation, or use a non-mutating method.")
+		return
+	}
+	if receiver.Kind == shimast.KindCallExpression {
+		inner := receiver.AsCallExpression()
+		if inner == nil || inner.Expression == nil ||
+			inner.Expression.Kind != shimast.KindPropertyAccessExpression {
+			return
+		}
+		innerAccess := inner.Expression.AsPropertyAccessExpression()
+		if innerAccess == nil {
+			return
+		}
+		innerName := identifierText(innerAccess.Name())
+		if _, ok := unicornNoImmediateMutationFreshMethods[innerName]; ok {
+			ctx.Report(node, "Don't mutate a freshly built array — separate the construction and the mutation, or use a non-mutating method.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornNoImmediateMutation{})
+}

package/linthost/rules_unicorn_no_instanceof_builtins.go

@@ -0,0 +1,66 @@
+// unicorn/no-instanceof-builtins: `x instanceof Array` (and the other
+// built-in container constructors) is broken across realms and for
+// user-defined subclasses. The cross-realm hazard is well known —
+// `Array` in an iframe is a different constructor than the host
+// `Array`, so a cross-realm value fails the check despite being an
+// array; the subclass hazard is subtler — `instanceof` walks the
+// prototype chain, so a `MyError extends Error` still passes
+// `x instanceof Error` and obscures the actual type.
+//
+// AST-only: visit each `BinaryExpression` whose operator token is
+// `instanceof`. The right-hand operand must be a bare identifier whose
+// text appears in the built-in allowlist. Property-access or computed
+// right-hand operands are out of scope because they cannot be matched
+// syntactically against the global names.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-instanceof-builtins.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoInstanceofBuiltinsNames = map[string]struct{}{
+	"Array":          {},
+	"Error":          {},
+	"EvalError":      {},
+	"RangeError":     {},
+	"ReferenceError": {},
+	"SyntaxError":    {},
+	"TypeError":      {},
+	"URIError":       {},
+	"AggregateError": {},
+	"Map":            {},
+	"Set":            {},
+	"WeakMap":        {},
+	"WeakSet":        {},
+	"Date":           {},
+	"RegExp":         {},
+	"Promise":        {},
+	"Function":       {},
+}
+
+type unicornNoInstanceofBuiltins struct{}
+
+func (unicornNoInstanceofBuiltins) Name() string { return "unicorn/no-instanceof-builtins" }
+func (unicornNoInstanceofBuiltins) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornNoInstanceofBuiltins) Check(ctx *Context, node *shimast.Node) {
+	bin := node.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil || bin.Right == nil {
+		return
+	}
+	if bin.OperatorToken.Kind != shimast.KindInstanceOfKeyword {
+		return
+	}
+	name := identifierText(bin.Right)
+	if name == "" {
+		return
+	}
+	if _, ok := unicornNoInstanceofBuiltinsNames[name]; !ok {
+		return
+	}
+	ctx.Report(node, "Don't use `instanceof <Builtin>` — it breaks across realms and for subclasses. Use a type predicate or duck-typing instead.")
+}
+
+func init() {
+	Register(unicornNoInstanceofBuiltins{})
+}

package/linthost/rules_unicorn_no_invalid_fetch_options.go

@@ -0,0 +1,79 @@
+// unicorn/no-invalid-fetch-options: passing a `body` together with a
+// `GET` or `HEAD` `fetch()` call throws at runtime because the spec
+// forbids a request body for those methods. The rule catches the
+// mismatch at parse time so the throw never reaches production.
+//
+// AST-only: visit each `CallExpression`, match when the callee is a
+// bare `fetch` identifier and the second argument is an object literal
+// containing both a string-literal `method` of `GET` / `HEAD`
+// (case-insensitive) AND a `body` property of any shape. Report on the
+// call so the diagnostic lands at the offending site.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-invalid-fetch-options.md
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornNoInvalidFetchOptions struct{}
+
+func (unicornNoInvalidFetchOptions) Name() string { return "unicorn/no-invalid-fetch-options" }
+func (unicornNoInvalidFetchOptions) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoInvalidFetchOptions) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil {
+		return
+	}
+	if identifierText(call.Expression) != "fetch" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
+		return
+	}
+	init := stripParens(call.Arguments.Nodes[1])
+	if init == nil || init.Kind != shimast.KindObjectLiteralExpression {
+		return
+	}
+	obj := init.AsObjectLiteralExpression()
+	if obj == nil || obj.Properties == nil {
+		return
+	}
+	hasBody := false
+	methodIsBodyless := false
+	for _, prop := range obj.Properties.Nodes {
+		if prop == nil || prop.Kind != shimast.KindPropertyAssignment {
+			continue
+		}
+		assignment := prop.AsPropertyAssignment()
+		if assignment == nil || assignment.Name() == nil {
+			continue
+		}
+		key := identifierText(assignment.Name())
+		if key == "" && assignment.Name().Kind == shimast.KindStringLiteral {
+			key = stringLiteralText(assignment.Name())
+		}
+		switch key {
+		case "body":
+			hasBody = true
+		case "method":
+			value := stripParens(assignment.Initializer)
+			if value != nil && value.Kind == shimast.KindStringLiteral {
+				m := strings.ToLower(stringLiteralText(value))
+				if m == "get" || m == "head" {
+					methodIsBodyless = true
+				}
+			}
+		}
+	}
+	if hasBody && methodIsBodyless {
+		ctx.Report(node, "Don't pass `body` with GET/HEAD `fetch` — it throws at runtime.")
+	}
+}
+
+func init() {
+	Register(unicornNoInvalidFetchOptions{})
+}