@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_prefer_logical_operator_over_ternary.go

@@ -0,0 +1,48 @@
+// unicorn/prefer-logical-operator-over-ternary: `x ? x : y` evaluates `x`
+// twice and adds a branch only to reproduce what `x || y` (for truthy
+// preservation) or `x ?? y` (for nullish-only) already say in one
+// shorter, allocation-free token. The ternary spelling tends to crop up
+// when authors forget the short-circuit operators exist; the rule nudges
+// them back to the canonical form.
+//
+// AST-only: visit `KindConditionalExpression`. Fire when the textual form
+// of `cond` (after `stripParens`) equals the textual form of `whenTrue`.
+// That covers the `cond ? cond : alt` shape. The negated `!x ? y : x`
+// case is left to a future iteration to keep the rule focused on a
+// single shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-logical-operator-over-ternary.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferLogicalOperatorOverTernary struct{}
+
+func (unicornPreferLogicalOperatorOverTernary) Name() string {
+  return "unicorn/prefer-logical-operator-over-ternary"
+}
+func (unicornPreferLogicalOperatorOverTernary) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindConditionalExpression}
+}
+func (unicornPreferLogicalOperatorOverTernary) Check(ctx *Context, node *shimast.Node) {
+  cond := node.AsConditionalExpression()
+  if cond == nil {
+    return
+  }
+  condExpr := stripParens(cond.Condition)
+  whenTrue := stripParens(cond.WhenTrue)
+  if condExpr == nil || whenTrue == nil {
+    return
+  }
+  condText := nodeText(ctx.File, condExpr)
+  if condText == "" {
+    return
+  }
+  if condText != nodeText(ctx.File, whenTrue) {
+    return
+  }
+  ctx.Report(node, "Prefer `a || b` / `a ?? b` over the equivalent ternary `a ? a : b`.")
+}
+
+func init() {
+  Register(unicornPreferLogicalOperatorOverTernary{})
+}

package/linthost/rules_unicorn_prefer_math_min_max.go

@@ -0,0 +1,60 @@
+// unicorn/prefer-math-min-max: `a < b ? a : b` is the long-hand spelling
+// of `Math.min(a, b)`; the conditional adds a branch and reads each
+// operand twice to do what the built-in does in one call. The built-ins
+// also handle the NaN edge case the conditional silently mis-routes,
+// so the rule pushes authors to switch.
+//
+// AST-only: visit `KindConditionalExpression`. Fire when the condition
+// (after `stripParens`) is a `KindBinaryExpression` whose operator is one
+// of `<`, `<=`, `>`, `>=` AND its two operands read textually as the
+// two branches of the conditional (either order — `a < b ? a : b` and
+// `a < b ? b : a` both qualify, since the rule covers both `Math.min`
+// and `Math.max`).
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-math-min-max.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferMathMinMax struct{}
+
+func (unicornPreferMathMinMax) Name() string { return "unicorn/prefer-math-min-max" }
+func (unicornPreferMathMinMax) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindConditionalExpression}
+}
+func (unicornPreferMathMinMax) Check(ctx *Context, node *shimast.Node) {
+  cond := node.AsConditionalExpression()
+  if cond == nil {
+    return
+  }
+  condExpr := stripParens(cond.Condition)
+  if condExpr == nil || condExpr.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  bin := condExpr.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindLessThanToken,
+    shimast.KindLessThanEqualsToken,
+    shimast.KindGreaterThanToken,
+    shimast.KindGreaterThanEqualsToken:
+  default:
+    return
+  }
+  leftText := nodeText(ctx.File, stripParens(bin.Left))
+  rightText := nodeText(ctx.File, stripParens(bin.Right))
+  if leftText == "" || rightText == "" {
+    return
+  }
+  trueText := nodeText(ctx.File, stripParens(cond.WhenTrue))
+  falseText := nodeText(ctx.File, stripParens(cond.WhenFalse))
+  if (leftText == trueText && rightText == falseText) ||
+    (leftText == falseText && rightText == trueText) {
+    ctx.Report(node, "Prefer `Math.min` / `Math.max` over a conditional comparing the same two values.")
+  }
+}
+
+func init() {
+  Register(unicornPreferMathMinMax{})
+}

package/linthost/rules_unicorn_prefer_math_trunc.go

@@ -0,0 +1,62 @@
+// unicorn/prefer-math-trunc: `~~x` and `x | 0` are folk idioms for
+// integer truncation that ride on the implicit Int32 coercion of the
+// bitwise operators. They lose values outside the int32 range and
+// confuse readers expecting a real math function. `Math.trunc(x)`
+// expresses the intent directly and handles the full numeric range.
+//
+// AST-only: visit `KindBinaryExpression` and `KindPrefixUnaryExpression`.
+// Fire on:
+//
+//   - `x | 0` — a BinaryExpression with `|` whose right operand is the
+//     numeric literal `0`.
+//   - `~~x` — a PrefixUnaryExpression with `~` whose operand is itself
+//     a PrefixUnaryExpression with `~` (the parser nests them as
+//     `~(~x)`).
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-math-trunc.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferMathTrunc struct{}
+
+func (unicornPreferMathTrunc) Name() string { return "unicorn/prefer-math-trunc" }
+func (unicornPreferMathTrunc) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression, shimast.KindPrefixUnaryExpression}
+}
+func (unicornPreferMathTrunc) Check(ctx *Context, node *shimast.Node) {
+  switch node.Kind {
+  case shimast.KindBinaryExpression:
+    expr := node.AsBinaryExpression()
+    if expr == nil || expr.OperatorToken == nil ||
+      expr.OperatorToken.Kind != shimast.KindBarToken {
+      return
+    }
+    right := stripParens(expr.Right)
+    if right == nil || right.Kind != shimast.KindNumericLiteral {
+      return
+    }
+    if numericLiteralText(right) != "0" {
+      return
+    }
+    ctx.Report(node, "Prefer `Math.trunc(x)` over `~~x` / `x | 0` for integer truncation.")
+  case shimast.KindPrefixUnaryExpression:
+    outer := node.AsPrefixUnaryExpression()
+    if outer == nil || outer.Operator != shimast.KindTildeToken || outer.Operand == nil {
+      return
+    }
+    operand := stripParens(outer.Operand)
+    if operand == nil || operand.Kind != shimast.KindPrefixUnaryExpression {
+      return
+    }
+    inner := operand.AsPrefixUnaryExpression()
+    if inner == nil || inner.Operator != shimast.KindTildeToken {
+      return
+    }
+    ctx.Report(node, "Prefer `Math.trunc(x)` over `~~x` / `x | 0` for integer truncation.")
+  }
+}
+
+func init() {
+  Register(unicornPreferMathTrunc{})
+}

package/linthost/rules_unicorn_prefer_modern_dom_apis.go

@@ -0,0 +1,47 @@
+// unicorn/prefer-modern-dom-apis: `Node#insertBefore`, `Node#replaceChild`,
+// and `Element#insertAdjacentText` are the legacy mutation methods that
+// still require the caller to thread a parent node and pass arguments in
+// a specific order. The `before` / `after` / `replaceWith` family on
+// `ChildNode` is the supported modern shape and accepts a variadic list
+// of nodes and strings without needing the parent reference.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose method identifier is one of the legacy mutation names, and fire
+// on the call. Receivers and argument shapes are not validated — the
+// method name alone is the signal the rule wants to discourage.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-modern-dom-apis.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornPreferModernDomApisMethods = map[string]struct{}{
+  "insertBefore":       {},
+  "replaceChild":       {},
+  "insertAdjacentText": {},
+}
+
+type unicornPreferModernDomApis struct{}
+
+func (unicornPreferModernDomApis) Name() string { return "unicorn/prefer-modern-dom-apis" }
+func (unicornPreferModernDomApis) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferModernDomApis) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  method := identifierText(access.Name())
+  if _, ok := unicornPreferModernDomApisMethods[method]; !ok {
+    return
+  }
+  ctx.Report(node, "Prefer `before` / `after` / `replaceWith` over `"+method+"`.")
+}
+
+func init() {
+  Register(unicornPreferModernDomApis{})
+}

package/linthost/rules_unicorn_prefer_modern_math_apis.go

@@ -0,0 +1,70 @@
+// unicorn/prefer-modern-math-apis: `Math.log(x) * Math.LOG10E` is the
+// classical pre-ES2015 spelling of `Math.log10(x)`. The arithmetic
+// identity is exact in the abstract but loses precision once it goes
+// through IEEE-754 multiplication, and the modern call also reads as
+// the operation it actually performs. The rule flags the multiplication
+// form for `LOG10E` and `LOG2E`.
+//
+// AST-only: visit `KindBinaryExpression`. Fire when the operator is `*`
+// and one operand is `Math.log(...)` while the other is
+// `PropertyAccess(Identifier("Math"), LOG10E)` or `LOG2E`. The
+// commutative `*` operator means `Math.log(x) * Math.LOG10E` and
+// `Math.LOG10E * Math.log(x)` both match.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-modern-math-apis.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferModernMathApis struct{}
+
+func (unicornPreferModernMathApis) Name() string { return "unicorn/prefer-modern-math-apis" }
+func (unicornPreferModernMathApis) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornPreferModernMathApis) Check(ctx *Context, node *shimast.Node) {
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil ||
+    bin.OperatorToken.Kind != shimast.KindAsteriskToken {
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if unicornPreferModernMathApisMatchesPair(left, right) ||
+    unicornPreferModernMathApisMatchesPair(right, left) {
+    ctx.Report(node, "Prefer `Math.log10(x)` / `Math.log2(x)` over `Math.log(x) * Math.LOG10E` / `Math.log(x) * Math.LOG2E`.")
+  }
+}
+
+// unicornPreferModernMathApisMatchesPair reports whether `callSide` is
+// `Math.log(...)` and `constSide` is `Math.LOG10E` or `Math.LOG2E`.
+func unicornPreferModernMathApisMatchesPair(callSide, constSide *shimast.Node) bool {
+  if callSide == nil || constSide == nil {
+    return false
+  }
+  if callSide.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := callSide.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return false
+  }
+  if !isMatchingPropertyAccess(call.Expression, "Math", "log") {
+    return false
+  }
+  if constSide.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  prop := constSide.AsPropertyAccessExpression()
+  if prop == nil || identifierText(prop.Expression) != "Math" {
+    return false
+  }
+  switch identifierText(prop.Name()) {
+  case "LOG10E", "LOG2E":
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(unicornPreferModernMathApis{})
+}

package/linthost/rules_unicorn_prefer_module.go

@@ -0,0 +1,50 @@
+// unicorn/prefer-module: ES modules are the spec-blessed module
+// system and provide cross-runtime semantics that CommonJS does not.
+// `require(...)` is dynamic, synchronous, and tied to Node's module
+// resolver; `__dirname` and `__filename` only exist inside CJS modules
+// and silently turn into `undefined` under ESM. The rule flags the
+// CommonJS-only constructs so the codebase converges on ESM-native
+// equivalents (`import` / `import.meta.dirname` / `import.meta.filename`).
+//
+// AST-only: visit `CallExpression` to match bare `require(...)` calls
+// and visit `Identifier` to match value-position reads of
+// `__dirname` / `__filename`. Identifier matches are gated by the
+// shared value-position helper so binding sites, property keys, and
+// type references are filtered out.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-module.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferModule struct{}
+
+func (unicornPreferModule) Name() string { return "unicorn/prefer-module" }
+func (unicornPreferModule) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression, shimast.KindIdentifier}
+}
+func (unicornPreferModule) Check(ctx *Context, node *shimast.Node) {
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil || call.Expression == nil {
+      return
+    }
+    if identifierText(call.Expression) != "require" {
+      return
+    }
+    ctx.Report(node, "Prefer ES modules over CommonJS — use `import` / `import.meta.dirname` / `import.meta.filename`.")
+  case shimast.KindIdentifier:
+    name := identifierText(node)
+    if name != "__dirname" && name != "__filename" {
+      return
+    }
+    if !isUnicornValuePositionIdentifier(node) {
+      return
+    }
+    ctx.Report(node, "Prefer ES modules over CommonJS — use `import` / `import.meta.dirname` / `import.meta.filename`.")
+  }
+}
+
+func init() {
+  Register(unicornPreferModule{})
+}

package/linthost/rules_unicorn_prefer_native_coercion_functions.go

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

package/linthost/rules_unicorn_prefer_negative_index.go

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

package/linthost/rules_unicorn_prefer_node_protocol.go

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