@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_prefer_blob_reading_methods.go

@@ -0,0 +1,44 @@
+// unicorn/prefer-blob-reading-methods: `FileReader#readAsArrayBuffer`
+// and `FileReader#readAsText` predate the promise-returning `Blob`
+// methods. They require attaching `load` / `error` listeners and reading
+// `reader.result` in a callback, while `Blob#arrayBuffer()` and
+// `Blob#text()` return a Promise that resolves to the same value
+// directly. The newer shape is shorter, easier to reason about, and the
+// rule discourages the legacy callback form.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose method identifier is `readAsArrayBuffer` or `readAsText`, and
+// fire on the call. The receiver is not type-checked — the syntactic
+// shape is the signal regardless of whether the value is statically a
+// `FileReader`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-blob-reading-methods.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferBlobReadingMethods struct{}
+
+func (unicornPreferBlobReadingMethods) Name() string {
+  return "unicorn/prefer-blob-reading-methods"
+}
+func (unicornPreferBlobReadingMethods) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferBlobReadingMethods) 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
+  }
+  switch identifierText(access.Name()) {
+  case "readAsArrayBuffer", "readAsText":
+    ctx.Report(node, "Prefer `Blob#arrayBuffer()` / `Blob#text()` over `FileReader#readAsArrayBuffer` / `readAsText`.")
+  }
+}
+
+func init() {
+  Register(unicornPreferBlobReadingMethods{})
+}

package/linthost/rules_unicorn_prefer_class_fields.go

@@ -0,0 +1,93 @@
+// unicorn/prefer-class-fields: assigning a primitive literal to
+// `this.<field>` inside a class constructor is a TC39-era pattern that
+// modern class-field declarations now express directly. The class-field
+// form is shorter, makes the field visible at the class level without
+// stepping through the constructor body, and avoids accidentally
+// re-initializing a property that was already declared with a typed
+// declaration.
+//
+// AST-only: visit `KindConstructor`. For each top-level statement in the
+// constructor body, fire on any `ExpressionStatement` whose expression
+// is an `=` `BinaryExpression` whose LHS is a property access on
+// `this` and whose RHS is a primitive literal (`StringLiteral`,
+// `NumericLiteral`, `KindTrueKeyword`, `KindFalseKeyword`,
+// `KindNullKeyword`). The check is per-assignment, not per-constructor,
+// so a constructor mixing several such assignments reports each one.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-class-fields.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferClassFields struct{}
+
+func (unicornPreferClassFields) Name() string { return "unicorn/prefer-class-fields" }
+func (unicornPreferClassFields) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindConstructor}
+}
+func (unicornPreferClassFields) Check(ctx *Context, node *shimast.Node) {
+  ctor := node.AsConstructorDeclaration()
+  if ctor == nil || ctor.Body == nil {
+    return
+  }
+  body := ctor.Body.AsBlock()
+  if body == nil || body.Statements == nil {
+    return
+  }
+  for _, stmt := range body.Statements.Nodes {
+    if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+      continue
+    }
+    exprStmt := stmt.AsExpressionStatement()
+    if exprStmt == nil || exprStmt.Expression == nil {
+      continue
+    }
+    expr := stripParens(exprStmt.Expression)
+    if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+      continue
+    }
+    bin := expr.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil || bin.OperatorToken.Kind != shimast.KindEqualsToken {
+      continue
+    }
+    lhs := stripParens(bin.Left)
+    if lhs == nil || lhs.Kind != shimast.KindPropertyAccessExpression {
+      continue
+    }
+    access := lhs.AsPropertyAccessExpression()
+    if access == nil {
+      continue
+    }
+    receiver := stripParens(access.Expression)
+    if receiver == nil || receiver.Kind != shimast.KindThisKeyword {
+      continue
+    }
+    rhs := stripParens(bin.Right)
+    if !isPrimitiveLiteralForClassField(rhs) {
+      continue
+    }
+    ctx.Report(expr, "Prefer class field declarations over constructor assignments to `this.field`.")
+  }
+}
+
+// isPrimitiveLiteralForClassField reports whether `node` is one of the
+// primitive-literal kinds that the prefer-class-fields rule treats as
+// "trivially hoistable" to a class field initializer.
+func isPrimitiveLiteralForClassField(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindNoSubstitutionTemplateLiteral:
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(unicornPreferClassFields{})
+}

package/linthost/rules_unicorn_prefer_classlist_toggle.go

@@ -0,0 +1,120 @@
+// unicorn/prefer-classlist-toggle: an `if (cond) el.classList.add(name)
+// else el.classList.remove(name)` block can be collapsed into a single
+// `el.classList.toggle(name, cond)` call. The toggle form is shorter,
+// avoids accidental drift between the two branches, and matches the
+// spec-blessed shape for conditional class management.
+//
+// AST-only minimum-viable port: visit `IfStatement` and match when both
+// branches contain a single `ExpressionStatement` of
+// `X.classList.add(arg)` and `X.classList.remove(arg)` (in either
+// order), with identical receiver text on `X.classList` and identical
+// argument text. Textual identity uses `nodeText` so this works without
+// the Checker; receivers that differ at the type level but share their
+// spelling will still match (the rule's signal is the syntactic shape
+// of the two-branch toggle).
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-classlist-toggle.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferClasslistToggle struct{}
+
+func (unicornPreferClasslistToggle) Name() string { return "unicorn/prefer-classlist-toggle" }
+func (unicornPreferClasslistToggle) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindIfStatement}
+}
+func (unicornPreferClasslistToggle) Check(ctx *Context, node *shimast.Node) {
+  stmt := node.AsIfStatement()
+  if stmt == nil || stmt.ThenStatement == nil || stmt.ElseStatement == nil {
+    return
+  }
+  thenCall := classlistToggleSingleCall(stmt.ThenStatement)
+  elseCall := classlistToggleSingleCall(stmt.ElseStatement)
+  if thenCall == nil || elseCall == nil {
+    return
+  }
+  thenMethod, thenReceiver, thenArg := classlistAddRemoveParts(thenCall)
+  elseMethod, elseReceiver, elseArg := classlistAddRemoveParts(elseCall)
+  if thenMethod == "" || elseMethod == "" {
+    return
+  }
+  // One branch must be `add`, the other `remove` — order does not
+  // matter; the toggle rewrite is symmetric.
+  if !((thenMethod == "add" && elseMethod == "remove") ||
+    (thenMethod == "remove" && elseMethod == "add")) {
+    return
+  }
+  if nodeText(ctx.File, thenReceiver) != nodeText(ctx.File, elseReceiver) {
+    return
+  }
+  if nodeText(ctx.File, thenArg) != nodeText(ctx.File, elseArg) {
+    return
+  }
+  ctx.Report(node, "Prefer `classList.toggle(name, condition)` over manual `add`/`remove` branches.")
+}
+
+// classlistToggleSingleCall returns the single CallExpression inside a
+// then/else branch — accepting either a bare ExpressionStatement or a
+// Block wrapping exactly one ExpressionStatement. Returns nil for any
+// other shape.
+func classlistToggleSingleCall(branch *shimast.Node) *shimast.Node {
+  if branch == nil {
+    return nil
+  }
+  stmt := branch
+  if branch.Kind == shimast.KindBlock {
+    block := branch.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.KindExpressionStatement {
+    return nil
+  }
+  expr := stmt.AsExpressionStatement()
+  if expr == nil || expr.Expression == nil {
+    return nil
+  }
+  call := stripParens(expr.Expression)
+  if call == nil || call.Kind != shimast.KindCallExpression {
+    return nil
+  }
+  return call
+}
+
+// classlistAddRemoveParts pulls (method, receiver, arg) out of a
+// `X.classList.add(arg)` / `X.classList.remove(arg)` call, where
+// `receiver` is the `X.classList` chain (the property-access expression
+// node) and `arg` is the single argument. Returns ("", nil, nil) for
+// any other shape.
+func classlistAddRemoveParts(call *shimast.Node) (string, *shimast.Node, *shimast.Node) {
+  ce := call.AsCallExpression()
+  if ce == nil || ce.Expression == nil || ce.Arguments == nil || len(ce.Arguments.Nodes) != 1 {
+    return "", nil, nil
+  }
+  if ce.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return "", nil, nil
+  }
+  access := ce.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return "", nil, nil
+  }
+  method := identifierText(access.Name())
+  if method != "add" && method != "remove" {
+    return "", nil, nil
+  }
+  receiver := access.Expression
+  if receiver == nil || receiver.Kind != shimast.KindPropertyAccessExpression {
+    return "", nil, nil
+  }
+  receiverAccess := receiver.AsPropertyAccessExpression()
+  if receiverAccess == nil || identifierText(receiverAccess.Name()) != "classList" {
+    return "", nil, nil
+  }
+  return method, receiver, ce.Arguments.Nodes[0]
+}
+
+func init() {
+  Register(unicornPreferClasslistToggle{})
+}

package/linthost/rules_unicorn_prefer_code_point.go

@@ -0,0 +1,49 @@
+// unicorn/prefer-code-point: `String#charCodeAt` and
+// `String.fromCharCode` operate on UTF-16 code units, so they split
+// astral characters (anything above U+FFFF) into surrogate pairs and
+// return numbers that no longer correspond to the Unicode code point
+// the source string visually shows. `String#codePointAt` and
+// `String.fromCodePoint` operate on full code points and round-trip
+// astral characters correctly.
+//
+// AST-only: visit `CallExpression`, match property-access callees whose
+// method identifier is `charCodeAt` or `fromCharCode`. For
+// `fromCharCode` also require the receiver to be the literal identifier
+// `String` so we only flag the static `String.fromCharCode` form; for
+// `charCodeAt` the receiver may be anything (any string instance).
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-code-point.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferCodePoint struct{}
+
+func (unicornPreferCodePoint) Name() string { return "unicorn/prefer-code-point" }
+func (unicornPreferCodePoint) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferCodePoint) 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
+  }
+  switch identifierText(access.Name()) {
+  case "charCodeAt":
+    // Instance call — receiver type is irrelevant.
+    ctx.Report(node, "Prefer `String#codePointAt()` / `String.fromCodePoint()` over `charCodeAt` / `fromCharCode`.")
+  case "fromCharCode":
+    // Static call — only the `String.fromCharCode(...)` shape.
+    if identifierText(access.Expression) != "String" {
+      return
+    }
+    ctx.Report(node, "Prefer `String#codePointAt()` / `String.fromCodePoint()` over `charCodeAt` / `fromCharCode`.")
+  }
+}
+
+func init() {
+  Register(unicornPreferCodePoint{})
+}

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