@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

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

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