@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

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{})
+}

package/linthost/rules_unicorn_prefer_import_meta_properties.go

@@ -0,0 +1,66 @@
+// unicorn/prefer-import-meta-properties: the legacy
+// `fileURLToPath(import.meta.url)` pattern was the only way to obtain
+// the on-disk path of the current ES module before Node added the
+// dedicated `import.meta.dirname` and `import.meta.filename`
+// properties. Once those exist, the workaround is pure noise — it
+// imports `url` for one call and adds a layer the reader has to
+// translate back to "the current file's directory / filename".
+//
+// AST-only: visit `CallExpression`, match a bare `fileURLToPath`
+// callee, and check that the sole argument is the property access
+// `import.meta.url`. The canonical legacy shape is the only case
+// covered — other call sites of `fileURLToPath` are out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-import-meta-properties.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferImportMetaProperties struct{}
+
+func (unicornPreferImportMetaProperties) Name() string {
+  return "unicorn/prefer-import-meta-properties"
+}
+func (unicornPreferImportMetaProperties) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferImportMetaProperties) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if identifierText(call.Expression) != "fileURLToPath" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := arg.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "url" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil {
+    return
+  }
+  // `import.meta` parses as either a MetaProperty token or a
+  // PropertyAccess(import, meta) chain depending on the path; both
+  // resolve textually to the same source span.
+  if receiver.Kind == shimast.KindMetaProperty {
+    ctx.Report(node, "Prefer `import.meta.dirname` / `import.meta.filename` over `fileURLToPath(import.meta.url)`.")
+    return
+  }
+  if isMatchingPropertyAccess(receiver, "import", "meta") {
+    ctx.Report(node, "Prefer `import.meta.dirname` / `import.meta.filename` over `fileURLToPath(import.meta.url)`.")
+  }
+}
+
+func init() {
+  Register(unicornPreferImportMetaProperties{})
+}

package/linthost/rules_unicorn_prefer_includes.go

@@ -0,0 +1,149 @@
+// unicorn/prefer-includes: `arr.indexOf(x) !== -1` (and its `=== -1`,
+// `> -1`, `>= 0`, `< 0` siblings) is the legacy idiom for membership
+// testing. The intent is obvious only after the reader translates the
+// magic number; `arr.includes(x)` says the same thing without the
+// translation step. The rule applies to both arrays and strings — both
+// expose `indexOf` and both expose `includes`.
+//
+// AST-only: a `BinaryExpression` whose operator is one of the
+// recognized comparisons and whose operands are `<call>.indexOf(...)`
+// vs. one of `-1` / `0` (allowing the literal-or-unary-minus shape for
+// `-1`) matches. For symmetric operators (`===`, `!==`, `==`, `!=`)
+// either operand may carry the call. For asymmetric operators (`<`,
+// `>=`, `>`) only the canonical orientation `indexOf(x) <op> <literal>`
+// is recognized; the swapped form (`0 < indexOf(x)`) has different
+// semantics (e.g. "found at index >= 1") and is intentionally NOT
+// rewritten to `includes`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-includes.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferIncludes struct{}
+
+func (unicornPreferIncludes) Name() string { return "unicorn/prefer-includes" }
+func (unicornPreferIncludes) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornPreferIncludes) Check(ctx *Context, node *shimast.Node) {
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+    return
+  }
+  op := bin.OperatorToken.Kind
+  wantNegOne := false
+  wantZero := false
+  switch op {
+  case shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken:
+    wantNegOne = true
+  case shimast.KindLessThanToken:
+    // `indexOf(x) < 0`
+    wantZero = true
+  case shimast.KindGreaterThanEqualsToken:
+    // `indexOf(x) >= 0`
+    wantZero = true
+  case shimast.KindGreaterThanToken:
+    // Not in the canonical set for this orientation; handled below
+    // via `> -1` matching against the negative-one form.
+    wantNegOne = true
+  default:
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  matched := unicornPreferIncludesMatches(left, right, op, wantNegOne, wantZero)
+  // Equality is symmetric — also try the swapped orientation.
+  // Asymmetric operators (`<`, `>=`, `>`) only match the canonical
+  // orientation; swapping `indexOf(x) < 0` to `0 < indexOf(x)` changes
+  // the meaning ("found at index >= 1") and must not be rewritten.
+  if !matched {
+    switch op {
+    case shimast.KindEqualsEqualsEqualsToken,
+      shimast.KindExclamationEqualsEqualsToken,
+      shimast.KindEqualsEqualsToken,
+      shimast.KindExclamationEqualsToken:
+      matched = unicornPreferIncludesMatches(right, left, op, wantNegOne, wantZero)
+    }
+  }
+  if matched {
+    ctx.Report(node, "Prefer `Array#includes()` / `String#includes()` over `indexOf` comparisons.")
+  }
+}
+
+func unicornPreferIncludesMatches(
+  callSide, literalSide *shimast.Node,
+  op shimast.Kind,
+  wantNegOne, wantZero bool,
+) bool {
+  if callSide == nil || literalSide == nil {
+    return false
+  }
+  if callSide.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := callSide.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "indexOf" {
+    return false
+  }
+  // `> -1`, `>= 0`, `< 0`, `=== -1`, `!== -1`, `== -1`, `!= -1`.
+  switch op {
+  case shimast.KindGreaterThanToken:
+    // Only `indexOf(x) > -1` matches.
+    return unicornPreferIncludesIsNegativeOne(literalSide)
+  case shimast.KindLessThanToken:
+    // Only `indexOf(x) < 0` matches.
+    return unicornPreferIncludesIsZero(literalSide)
+  case shimast.KindGreaterThanEqualsToken:
+    // Only `indexOf(x) >= 0` matches.
+    return unicornPreferIncludesIsZero(literalSide)
+  }
+  if wantNegOne && unicornPreferIncludesIsNegativeOne(literalSide) {
+    return true
+  }
+  if wantZero && unicornPreferIncludesIsZero(literalSide) {
+    return true
+  }
+  return false
+}
+
+func unicornPreferIncludesIsNegativeOne(node *shimast.Node) bool {
+  node = stripParens(node)
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindPrefixUnaryExpression {
+    prefix := node.AsPrefixUnaryExpression()
+    if prefix == nil || prefix.Operator != shimast.KindMinusToken || prefix.Operand == nil {
+      return false
+    }
+    if prefix.Operand.Kind != shimast.KindNumericLiteral {
+      return false
+    }
+    return numericLiteralText(prefix.Operand) == "1"
+  }
+  if node.Kind == shimast.KindNumericLiteral {
+    // Some tokenizers preserve the leading `-` in the literal text.
+    return numericLiteralText(node) == "-1"
+  }
+  return false
+}
+
+func unicornPreferIncludesIsZero(node *shimast.Node) bool {
+  node = stripParens(node)
+  if node == nil || node.Kind != shimast.KindNumericLiteral {
+    return false
+  }
+  return numericLiteralText(node) == "0"
+}
+
+func init() {
+  Register(unicornPreferIncludes{})
+}

package/linthost/rules_unicorn_prefer_json_parse_buffer.go

@@ -0,0 +1,65 @@
+// unicorn/prefer-json-parse-buffer: as of Node 21, `JSON.parse`
+// accepts a `Buffer` directly and decodes it internally, so the common
+// `JSON.parse(buf.toString())` pattern allocates an extra intermediate
+// string for nothing. Dropping the `.toString()` avoids the allocation
+// and reads at least as clearly.
+//
+// AST-only: visit `CallExpression`. Match the outer call where the
+// callee is `JSON.parse` (`PropertyAccess(Identifier("JSON"), parse)`)
+// AND the single argument is itself a `CallExpression` whose callee is
+// `PropertyAccess(_, toString)` taking no arguments — i.e. the
+// syntactic shape `JSON.parse(x.toString())`. The receiver type of
+// `x` is not checked, so non-buffer receivers will produce false
+// positives; this is the documented trade for an AST-only port.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-json-parse-buffer.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferJsonParseBuffer struct{}
+
+func (unicornPreferJsonParseBuffer) Name() string { return "unicorn/prefer-json-parse-buffer" }
+func (unicornPreferJsonParseBuffer) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferJsonParseBuffer) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  // Callee must be `JSON.parse`.
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Expression) != "JSON" || identifierText(access.Name()) != "parse" {
+    return
+  }
+  // Argument must be `_.toString()` with no arguments.
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindCallExpression {
+    return
+  }
+  innerCall := arg.AsCallExpression()
+  if innerCall == nil || innerCall.Expression == nil {
+    return
+  }
+  if innerCall.Arguments != nil && len(innerCall.Arguments.Nodes) != 0 {
+    return
+  }
+  if innerCall.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  innerAccess := innerCall.Expression.AsPropertyAccessExpression()
+  if innerAccess == nil || identifierText(innerAccess.Name()) != "toString" {
+    return
+  }
+  ctx.Report(node, "Prefer passing a `Buffer` directly to `JSON.parse` (Node 21+) over decoding to a string first.")
+}
+
+func init() {
+  Register(unicornPreferJsonParseBuffer{})
+}

package/linthost/rules_unicorn_prefer_keyboard_event_key.go

@@ -0,0 +1,38 @@
+// unicorn/prefer-keyboard-event-key: `KeyboardEvent#keyCode`,
+// `KeyboardEvent#charCode`, and `KeyboardEvent#which` are all
+// deprecated. They expose layout-dependent integer codes that change
+// across browsers and keyboard layouts and force code to maintain
+// magic-number tables. `KeyboardEvent#key` returns the resolved key
+// label as a string and is the spec-blessed replacement.
+//
+// AST-only: visit `PropertyAccessExpression` and match the right-hand
+// identifier name against the deprecated property set. The receiver
+// is intentionally not type-checked — the rule accepts the syntactic
+// shape as the signal, which produces a small number of harmless
+// false positives on non-event objects but is the correct trade for
+// an AST-only port.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-keyboard-event-key.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferKeyboardEventKey struct{}
+
+func (unicornPreferKeyboardEventKey) Name() string { return "unicorn/prefer-keyboard-event-key" }
+func (unicornPreferKeyboardEventKey) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornPreferKeyboardEventKey) Check(ctx *Context, node *shimast.Node) {
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "keyCode", "charCode", "which":
+    ctx.Report(node, "Prefer `KeyboardEvent#key` over the deprecated `keyCode` / `charCode` / `which`.")
+  }
+}
+
+func init() {
+  Register(unicornPreferKeyboardEventKey{})
+}