@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_unicorn_prefer_date_now.go

@@ -0,0 +1,78 @@
+// unicorn/prefer-date-now: three idioms compute the current epoch
+// milliseconds at runtime — `new Date().getTime()`, `new Date().valueOf()`,
+// and `+new Date()`. All three allocate a Date instance only to throw
+// it away. `Date.now()` does the same thing with no allocation and
+// reads as exactly what it means; the rule asks authors to switch.
+//
+// AST-only: visit `KindCallExpression` (the `.getTime()` / `.valueOf()`
+// callers) and `KindPrefixUnaryExpression` (the `+new Date()` form).
+// Fire on:
+//
+//   - `(new Date()).getTime()` / `(new Date()).valueOf()` — a call
+//     with no arguments whose callee is a PropertyAccessExpression
+//     on a NewExpression with callee `Date`.
+//   - `+new Date()` — a `+` prefix whose operand is a NewExpression
+//     with callee `Date`.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-date-now.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferDateNow struct{}
+
+func (unicornPreferDateNow) Name() string { return "unicorn/prefer-date-now" }
+func (unicornPreferDateNow) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression, shimast.KindPrefixUnaryExpression}
+}
+func (unicornPreferDateNow) Check(ctx *Context, node *shimast.Node) {
+	switch node.Kind {
+	case shimast.KindCallExpression:
+		call := node.AsCallExpression()
+		if call == nil || call.Expression == nil {
+			return
+		}
+		if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+			return
+		}
+		access := stripParens(call.Expression)
+		if access == nil || access.Kind != shimast.KindPropertyAccessExpression {
+			return
+		}
+		propAccess := access.AsPropertyAccessExpression()
+		if propAccess == nil {
+			return
+		}
+		method := identifierText(propAccess.Name())
+		if method != "getTime" && method != "valueOf" {
+			return
+		}
+		receiver := stripParens(propAccess.Expression)
+		if receiver == nil || receiver.Kind != shimast.KindNewExpression {
+			return
+		}
+		ne := receiver.AsNewExpression()
+		if ne == nil || identifierText(ne.Expression) != "Date" {
+			return
+		}
+		ctx.Report(node, "Prefer `Date.now()` over `new Date().getTime()` / `+new Date()`.")
+	case shimast.KindPrefixUnaryExpression:
+		prefix := node.AsPrefixUnaryExpression()
+		if prefix == nil || prefix.Operator != shimast.KindPlusToken || prefix.Operand == nil {
+			return
+		}
+		operand := stripParens(prefix.Operand)
+		if operand == nil || operand.Kind != shimast.KindNewExpression {
+			return
+		}
+		ne := operand.AsNewExpression()
+		if ne == nil || identifierText(ne.Expression) != "Date" {
+			return
+		}
+		ctx.Report(node, "Prefer `Date.now()` over `new Date().getTime()` / `+new Date()`.")
+	}
+}
+
+func init() {
+	Register(unicornPreferDateNow{})
+}

package/linthost/rules_unicorn_prefer_default_parameters.go

@@ -0,0 +1,144 @@
+// unicorn/prefer-default-parameters: the legacy pattern of reassigning
+// an undefined-or-falsy parameter to a literal at the top of a function
+// body (`name = name ?? "guest"`) has been redundant since ES2015. A
+// default-parameter expression (`name = "guest"`) covers the same case,
+// reads as exactly what it means, and avoids both the visual noise and
+// the missed-edit risk of keeping the name in three places.
+//
+// AST-only: visit every function-like declaration. Fire when the first
+// body statement is `<param> = <param> ?? <literal>` — an
+// `ExpressionStatement` containing an `=` `BinaryExpression` whose LHS
+// is a bare identifier matching a parameter name, and whose RHS is a
+// `??` `BinaryExpression` whose LHS is the same identifier and whose
+// RHS is a primitive literal. The rule is conservative on purpose: it
+// stays away from `||` (which has different semantics for falsy
+// non-undefined values) and the explicit-ternary shape, since both add
+// branches the default-parameter rewrite does not strictly preserve.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-default-parameters.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferDefaultParameters struct{}
+
+func (unicornPreferDefaultParameters) Name() string {
+	return "unicorn/prefer-default-parameters"
+}
+func (unicornPreferDefaultParameters) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindArrowFunction,
+		shimast.KindFunctionExpression,
+		shimast.KindMethodDeclaration,
+	}
+}
+func (unicornPreferDefaultParameters) Check(ctx *Context, node *shimast.Node) {
+	body := defaultParameterFunctionBody(node)
+	if body == nil {
+		return
+	}
+	if body.Statements == nil || len(body.Statements.Nodes) == 0 {
+		return
+	}
+	first := body.Statements.Nodes[0]
+	if first == nil || first.Kind != shimast.KindExpressionStatement {
+		return
+	}
+	exprStmt := first.AsExpressionStatement()
+	if exprStmt == nil || exprStmt.Expression == nil {
+		return
+	}
+	expr := stripParens(exprStmt.Expression)
+	if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+		return
+	}
+	assign := expr.AsBinaryExpression()
+	if assign == nil || assign.OperatorToken == nil || assign.OperatorToken.Kind != shimast.KindEqualsToken {
+		return
+	}
+	target := identifierText(stripParens(assign.Left))
+	if target == "" {
+		return
+	}
+	if !functionHasParameterNamed(node, target) {
+		return
+	}
+	rhs := stripParens(assign.Right)
+	if rhs == nil || rhs.Kind != shimast.KindBinaryExpression {
+		return
+	}
+	coalesce := rhs.AsBinaryExpression()
+	if coalesce == nil || coalesce.OperatorToken == nil ||
+		coalesce.OperatorToken.Kind != shimast.KindQuestionQuestionToken {
+		return
+	}
+	if identifierText(stripParens(coalesce.Left)) != target {
+		return
+	}
+	if !isLiteralExpression(stripParens(coalesce.Right)) {
+		return
+	}
+	ctx.Report(expr, "Prefer default parameters over `param = param ?? default` reassignments.")
+}
+
+// defaultParameterFunctionBody returns the BlockStatement body of a
+// function-like node, or nil when the function has an expression body
+// (arrow `=> expr`) or an overload signature without a body. The
+// rule only fires on statement-level reassignments, so a body-less
+// shape is a non-match by definition.
+func defaultParameterFunctionBody(node *shimast.Node) *shimast.Block {
+	if node == nil {
+		return nil
+	}
+	var body *shimast.Node
+	switch node.Kind {
+	case shimast.KindFunctionDeclaration:
+		if fn := node.AsFunctionDeclaration(); fn != nil {
+			body = fn.Body
+		}
+	case shimast.KindFunctionExpression:
+		if fn := node.AsFunctionExpression(); fn != nil {
+			body = fn.Body
+		}
+	case shimast.KindArrowFunction:
+		if fn := node.AsArrowFunction(); fn != nil {
+			body = fn.Body
+		}
+	case shimast.KindMethodDeclaration:
+		if fn := node.AsMethodDeclaration(); fn != nil {
+			body = fn.Body
+		}
+	}
+	if body == nil || body.Kind != shimast.KindBlock {
+		return nil
+	}
+	return body.AsBlock()
+}
+
+// functionHasParameterNamed reports whether any parameter of the
+// function-like node is a plain `Identifier` whose lexical text equals
+// `name`. Destructured parameters are intentionally ignored — the rule
+// cannot prove which inner binding a top-of-body reassignment refers to
+// without semantic analysis.
+func functionHasParameterNamed(node *shimast.Node, name string) bool {
+	if node == nil || name == "" {
+		return false
+	}
+	for _, p := range node.Parameters() {
+		if p == nil {
+			continue
+		}
+		decl := p.AsParameterDeclaration()
+		if decl == nil {
+			continue
+		}
+		if identifierText(decl.Name()) == name {
+			return true
+		}
+	}
+	return false
+}
+
+func init() {
+	Register(unicornPreferDefaultParameters{})
+}

package/linthost/rules_unicorn_prefer_dom_node_append.go

@@ -0,0 +1,40 @@
+// unicorn/prefer-dom-node-append: `Node#appendChild` accepts a single
+// child node, returns the appended node, and throws when handed a string
+// — its `Node#append` successor accepts a variadic list of nodes and
+// strings, returns `undefined`, and is the supported modern shape. The
+// legacy form is what the rule discourages.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose method identifier is `appendChild`, 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 a `Node` at the type level.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-dom-node-append.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferDomNodeAppend struct{}
+
+func (unicornPreferDomNodeAppend) Name() string { return "unicorn/prefer-dom-node-append" }
+func (unicornPreferDomNodeAppend) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferDomNodeAppend) 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()) != "appendChild" {
+		return
+	}
+	ctx.Report(node, "Prefer `Node#append()` over `Node#appendChild()`.")
+}
+
+func init() {
+	Register(unicornPreferDomNodeAppend{})
+}

package/linthost/rules_unicorn_prefer_dom_node_dataset.go

@@ -0,0 +1,55 @@
+// unicorn/prefer-dom-node-dataset: `Element#dataset` exposes every
+// `data-*` attribute as a typed string property, including coordinated
+// kebab-case → camelCase mapping and conversion to/from values. Reaching
+// for `getAttribute("data-foo")` or `setAttribute("data-foo", …)`
+// reintroduces string-key bookkeeping the platform already covers.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose method identifier is `getAttribute` or `setAttribute`, and fire
+// when the first argument is a `StringLiteral` whose text starts with
+// `data-`. The literal-prefix gate isolates the data-attribute path from
+// every other attribute the same methods reach.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-dom-node-dataset.md
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornPreferDomNodeDataset struct{}
+
+func (unicornPreferDomNodeDataset) Name() string { return "unicorn/prefer-dom-node-dataset" }
+func (unicornPreferDomNodeDataset) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferDomNodeDataset) 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 != "getAttribute" && method != "setAttribute" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+		return
+	}
+	first := call.Arguments.Nodes[0]
+	if first == nil || first.Kind != shimast.KindStringLiteral {
+		return
+	}
+	if !strings.HasPrefix(stringLiteralText(first), "data-") {
+		return
+	}
+	ctx.Report(node, "Prefer `.dataset` over `getAttribute` / `setAttribute` for `data-*` attributes.")
+}
+
+func init() {
+	Register(unicornPreferDomNodeDataset{})
+}

package/linthost/rules_unicorn_prefer_dom_node_remove.go

@@ -0,0 +1,41 @@
+// unicorn/prefer-dom-node-remove: `parent.removeChild(child)` requires
+// the caller to thread the parent through to detach a node — `child.remove()`
+// is the supported modern shape and avoids the dangling-reference class
+// of bugs where the wrong parent is consulted.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose method identifier is `removeChild`, and fire when the call has
+// exactly one argument. The single-argument gate isolates the canonical
+// detach shape from custom `removeChild` overloads that take more.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-dom-node-remove.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferDomNodeRemove struct{}
+
+func (unicornPreferDomNodeRemove) Name() string { return "unicorn/prefer-dom-node-remove" }
+func (unicornPreferDomNodeRemove) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferDomNodeRemove) 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()) != "removeChild" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+		return
+	}
+	ctx.Report(node, "Prefer `ChildNode#remove()` over `parentNode.removeChild(child)`.")
+}
+
+func init() {
+	Register(unicornPreferDomNodeRemove{})
+}

package/linthost/rules_unicorn_prefer_dom_node_text_content.go

@@ -0,0 +1,37 @@
+// unicorn/prefer-dom-node-text-content: `HTMLElement#innerText` triggers
+// layout, ignores hidden subtrees, and varies across engines — its
+// `Node#textContent` counterpart returns the raw concatenated text of
+// every descendant text node and is the supported modern shape.
+//
+// AST-only and identifier-text-driven: visit every
+// `PropertyAccessExpression`, match the property name `innerText`, and
+// fire on the property-access node. The receiver expression is not
+// type-checked; the legacy property name is the signal the rule
+// discourages.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-dom-node-text-content.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferDomNodeTextContent struct{}
+
+func (unicornPreferDomNodeTextContent) Name() string {
+	return "unicorn/prefer-dom-node-text-content"
+}
+func (unicornPreferDomNodeTextContent) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornPreferDomNodeTextContent) Check(ctx *Context, node *shimast.Node) {
+	access := node.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Name()) != "innerText" {
+		return
+	}
+	ctx.Report(node, "Prefer `Node#textContent` over `HTMLElement#innerText`.")
+}
+
+func init() {
+	Register(unicornPreferDomNodeTextContent{})
+}

package/linthost/rules_unicorn_prefer_event_target.go

@@ -0,0 +1,36 @@
+// unicorn/prefer-event-target: Node's `EventEmitter` is the legacy
+// event API. The browser and modern Node (`>=15`) both ship the
+// standard `EventTarget` interface, which works in both runtimes
+// without a polyfill. Code that needs to run in both should prefer
+// `EventTarget` so it stays portable.
+//
+// AST-only: visit `NewExpression`. Match when the callee is a bare
+// identifier whose name is `EventEmitter`. The receiver is not
+// type-checked — the rule's signal is the literal `new EventEmitter()`
+// shape; a `new events.EventEmitter()` qualified form would not match,
+// matching upstream's own AST-only behavior.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-event-target.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferEventTarget struct{}
+
+func (unicornPreferEventTarget) Name() string { return "unicorn/prefer-event-target" }
+func (unicornPreferEventTarget) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNewExpression}
+}
+func (unicornPreferEventTarget) Check(ctx *Context, node *shimast.Node) {
+	ne := node.AsNewExpression()
+	if ne == nil || ne.Expression == nil {
+		return
+	}
+	if identifierText(ne.Expression) != "EventEmitter" {
+		return
+	}
+	ctx.Report(node, "Prefer `EventTarget` over `EventEmitter` when sharing code between Node and the browser.")
+}
+
+func init() {
+	Register(unicornPreferEventTarget{})
+}

package/linthost/rules_unicorn_prefer_export_from.go

@@ -0,0 +1,129 @@
+// unicorn/prefer-export-from: when the only purpose of a local import is
+// to re-export it under the same name, the canonical shape is the
+// `export { X } from "Y"` re-export, which skips the intermediate local
+// binding entirely. The split `import { X } from "Y"; export { X };`
+// form is longer, allocates a binding that never gets used, and reads
+// as if the author meant to consume `X` locally before deciding not to.
+//
+// AST-only minimum-viable port: visit `SourceFile` and walk top-level
+// statements once. Build a map from each unrenamed named-binding of an
+// `import { X } from "Y"` declaration to its module specifier text, then
+// fire on every later `export { X };` statement (no rename, no
+// `from`-clause) whose identifier appears in that map. Default and
+// namespace imports, renamed bindings, and re-exports with their own
+// `from`-clause are out of scope; the MVP only catches the textbook
+// "import then immediately re-export" pair.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-export-from.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferExportFrom struct{}
+
+func (unicornPreferExportFrom) Name() string { return "unicorn/prefer-export-from" }
+func (unicornPreferExportFrom) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornPreferExportFrom) Check(ctx *Context, node *shimast.Node) {
+	statements := node.Statements()
+	if len(statements) == 0 {
+		return
+	}
+	// Map of locally-imported simple binding name → true. Built on a
+	// first pass so a re-export earlier in the file does not accidentally
+	// match an import declared later; the upstream rule is anchored on
+	// "imported above, re-exported below" ordering.
+	imported := map[string]bool{}
+	for _, stmt := range statements {
+		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
+			continue
+		}
+		decl := stmt.AsImportDeclaration()
+		if decl == nil || decl.ImportClause == nil {
+			continue
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil || clause.NamedBindings == nil ||
+			clause.NamedBindings.Kind != shimast.KindNamedImports {
+			continue
+		}
+		// A default-bound or namespace-mixed import is out of scope: the
+		// MVP only rewrites pure `import { X } from "Y"` pairs.
+		if clause.Name() != nil {
+			continue
+		}
+		named := clause.NamedBindings.AsNamedImports()
+		if named == nil || named.Elements == nil {
+			continue
+		}
+		for _, spec := range named.Elements.Nodes {
+			s := spec.AsImportSpecifier()
+			if s == nil {
+				continue
+			}
+			// PropertyName is set only when the specifier is renamed
+			// (`import { a as b }`); skip those — `export { b }` would
+			// require `export { b as b } from "Y"` which is itself a
+			// useless rename.
+			if s.PropertyName != nil {
+				continue
+			}
+			name := identifierText(s.Name())
+			if name == "" {
+				continue
+			}
+			imported[name] = true
+		}
+	}
+	if len(imported) == 0 {
+		return
+	}
+	for _, stmt := range statements {
+		if stmt == nil || stmt.Kind != shimast.KindExportDeclaration {
+			continue
+		}
+		decl := stmt.AsExportDeclaration()
+		if decl == nil || decl.ExportClause == nil {
+			continue
+		}
+		// Skip `export { X } from "Y"` — already in the target shape.
+		if decl.ModuleSpecifier != nil {
+			continue
+		}
+		if decl.ExportClause.Kind != shimast.KindNamedExports {
+			continue
+		}
+		named := decl.ExportClause.AsNamedExports()
+		if named == nil || named.Elements == nil || len(named.Elements.Nodes) == 0 {
+			continue
+		}
+		matched := false
+		for _, el := range named.Elements.Nodes {
+			spec := el.AsExportSpecifier()
+			if spec == nil {
+				continue
+			}
+			// PropertyName != nil means `export { a as b }` — a rename
+			// the from-clause rewrite cannot preserve without also
+			// touching the import side. Skip.
+			if spec.PropertyName != nil {
+				continue
+			}
+			name := identifierText(spec.Name())
+			if name == "" {
+				continue
+			}
+			if imported[name] {
+				matched = true
+				break
+			}
+		}
+		if matched {
+			ctx.Report(stmt, "Use `export { X } from \"Y\"` instead of importing then re-exporting.")
+		}
+	}
+}
+
+func init() {
+	Register(unicornPreferExportFrom{})
+}

package/linthost/rules_unicorn_prefer_global_this.go

@@ -0,0 +1,127 @@
+// unicorn/prefer-global-this: `window`, `self`, and `global` are
+// environment-specific global aliases. Using them locks code to a
+// single runtime (browser, worker, Node) and forces feature-detection
+// boilerplate when the same code needs to run elsewhere. `globalThis`
+// is the standardized cross-runtime alias and the canonical form for
+// the same reference.
+//
+// AST-only: visit every `Identifier`. The rule fires only when the
+// identifier sits in a value-expression position; declaration names,
+// property-access right sides, parameter names, property-assignment
+// keys, and type references are filtered out by parent-kind gating so
+// the diagnostic is anchored on actual reads of the global.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-global-this.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferGlobalThis struct{}
+
+func (unicornPreferGlobalThis) Name() string { return "unicorn/prefer-global-this" }
+func (unicornPreferGlobalThis) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindIdentifier}
+}
+func (unicornPreferGlobalThis) Check(ctx *Context, node *shimast.Node) {
+	name := identifierText(node)
+	switch name {
+	case "window", "self", "global":
+	default:
+		return
+	}
+	if !isUnicornValuePositionIdentifier(node) {
+		return
+	}
+	ctx.Report(node, "Prefer `globalThis` over `window` / `self` / `global`.")
+}
+
+// isUnicornValuePositionIdentifier reports whether `node` (a bare
+// Identifier) appears in a value-expression position rather than as a
+// binding name, property key, member-access right side, or type
+// reference. Declaration names and property keys are read positions
+// for the *name* itself, so they must not contribute to rules that
+// flag *uses* of a global.
+func isUnicornValuePositionIdentifier(node *shimast.Node) bool {
+	if node == nil || node.Kind != shimast.KindIdentifier || node.Parent == nil {
+		return false
+	}
+	parent := node.Parent
+	switch parent.Kind {
+	case shimast.KindVariableDeclaration:
+		decl := parent.AsVariableDeclaration()
+		if decl != nil && decl.Name() == node {
+			return false
+		}
+	case shimast.KindBindingElement:
+		elem := parent.AsBindingElement()
+		if elem != nil && elem.Name() == node {
+			return false
+		}
+	case shimast.KindParameter:
+		param := parent.AsParameterDeclaration()
+		if param != nil && param.Name() == node {
+			return false
+		}
+	case shimast.KindFunctionDeclaration:
+		fn := parent.AsFunctionDeclaration()
+		if fn != nil && fn.Name() == node {
+			return false
+		}
+	case shimast.KindFunctionExpression:
+		fn := parent.AsFunctionExpression()
+		if fn != nil && fn.Name() == node {
+			return false
+		}
+	case shimast.KindClassDeclaration:
+		cls := parent.AsClassDeclaration()
+		if cls != nil && cls.Name() == node {
+			return false
+		}
+	case shimast.KindClassExpression:
+		cls := parent.AsClassExpression()
+		if cls != nil && cls.Name() == node {
+			return false
+		}
+	case shimast.KindPropertyAccessExpression:
+		access := parent.AsPropertyAccessExpression()
+		if access != nil && access.Name() == node {
+			return false
+		}
+	case shimast.KindPropertyAssignment:
+		prop := parent.AsPropertyAssignment()
+		if prop != nil && prop.Name() == node {
+			return false
+		}
+	case shimast.KindShorthandPropertyAssignment:
+		// `{window}` shorthand — the identifier is both name and read,
+		// but the read here is the value position, so allow.
+	case shimast.KindMethodDeclaration,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+		shimast.KindPropertyDeclaration:
+		// These have a Name() slot that is not a value expression.
+		return false
+	case shimast.KindTypeReference,
+		shimast.KindQualifiedName,
+		shimast.KindImportSpecifier,
+		shimast.KindExportSpecifier,
+		shimast.KindNamespaceImport,
+		shimast.KindImportClause,
+		shimast.KindNamespaceExport,
+		shimast.KindLabeledStatement,
+		shimast.KindBreakStatement,
+		shimast.KindContinueStatement,
+		shimast.KindJsxAttribute,
+		shimast.KindEnumDeclaration,
+		shimast.KindEnumMember,
+		shimast.KindModuleDeclaration,
+		shimast.KindTypeParameter,
+		shimast.KindInterfaceDeclaration,
+		shimast.KindTypeAliasDeclaration:
+		return false
+	}
+	return true
+}
+
+func init() {
+	Register(unicornPreferGlobalThis{})
+}