@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_unicorn_prefer_array_index_of.go

@@ -0,0 +1,147 @@
+// unicorn/prefer-array-index-of: `arr.findIndex(x => x === literal)` is
+// the long-hand spelling of `arr.indexOf(literal)`. Both return the
+// index of the first matching element; `indexOf` is a direct comparison
+// against a value and is faster, shorter, and clearer about intent.
+//
+// AST-only: visit each `CallExpression` whose callee is
+// `PropertyAccess(_, findIndex)`. The single argument must be a
+// function (`ArrowFunction` or `FunctionExpression`) with exactly one
+// parameter. The function body — concise body, or a block body whose
+// single statement is a `return` — must be a strict-equality comparison
+// between the parameter identifier and a literal (string, number,
+// boolean, null, bigint). Reports on the call.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-index-of.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferArrayIndexOf struct{}
+
+func (unicornPreferArrayIndexOf) Name() string { return "unicorn/prefer-array-index-of" }
+func (unicornPreferArrayIndexOf) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferArrayIndexOf) 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 || identifierText(access.Name()) != "findIndex" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+		return
+	}
+	fn := stripParens(call.Arguments.Nodes[0])
+	if fn == nil {
+		return
+	}
+	var body *shimast.Node
+	switch fn.Kind {
+	case shimast.KindArrowFunction:
+		arrow := fn.AsArrowFunction()
+		if arrow == nil {
+			return
+		}
+		body = arrow.Body
+	case shimast.KindFunctionExpression:
+		expr := fn.AsFunctionExpression()
+		if expr == nil {
+			return
+		}
+		body = expr.Body
+	default:
+		return
+	}
+	params := fn.Parameters()
+	if len(params) != 1 {
+		return
+	}
+	paramName := parameterIdentifierName(params[0])
+	if paramName == "" {
+		return
+	}
+	expr := unicornPreferArrayIndexOfBodyExpression(body)
+	if expr == nil {
+		return
+	}
+	bin := expr.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil ||
+		bin.OperatorToken.Kind != shimast.KindEqualsEqualsEqualsToken {
+		return
+	}
+	left := stripParens(bin.Left)
+	right := stripParens(bin.Right)
+	if left == nil || right == nil {
+		return
+	}
+	if unicornPreferArrayIndexOfMatchesParam(left, paramName) &&
+		unicornPreferArrayIndexOfIsLiteral(right) {
+		ctx.Report(node, "Prefer `Array#indexOf()` over `Array#findIndex(x => x === literal)`.")
+		return
+	}
+	if unicornPreferArrayIndexOfMatchesParam(right, paramName) &&
+		unicornPreferArrayIndexOfIsLiteral(left) {
+		ctx.Report(node, "Prefer `Array#indexOf()` over `Array#findIndex(x => x === literal)`.")
+	}
+}
+
+// unicornPreferArrayIndexOfBodyExpression normalizes the function body to
+// the comparison expression: a concise arrow body returns its expression,
+// a block body with a single `return expr;` returns the expression.
+func unicornPreferArrayIndexOfBodyExpression(body *shimast.Node) *shimast.Node {
+	if body == nil {
+		return nil
+	}
+	if body.Kind != shimast.KindBlock {
+		expr := stripParens(body)
+		if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+			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.KindBinaryExpression {
+		return nil
+	}
+	return expr
+}
+
+func unicornPreferArrayIndexOfMatchesParam(node *shimast.Node, name string) bool {
+	return identifierText(node) == name
+}
+
+func unicornPreferArrayIndexOfIsLiteral(node *shimast.Node) bool {
+	if node == nil {
+		return false
+	}
+	switch node.Kind {
+	case shimast.KindStringLiteral,
+		shimast.KindNumericLiteral,
+		shimast.KindBigIntLiteral,
+		shimast.KindNoSubstitutionTemplateLiteral,
+		shimast.KindNullKeyword,
+		shimast.KindTrueKeyword,
+		shimast.KindFalseKeyword:
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(unicornPreferArrayIndexOf{})
+}

package/linthost/rules_unicorn_prefer_array_some.go

@@ -0,0 +1,67 @@
+// unicorn/prefer-array-some: `arr.filter(predicate).length > 0` walks the
+// whole array and allocates an intermediate filtered array just to ask
+// the boolean question "does any element match?". `arr.some(predicate)`
+// short-circuits at the first hit and reads as the intent.
+//
+// AST-only: visit each `BinaryExpression`. The operator must be one of
+// `>`, `>=`, `!==`, `!=`. The left operand must be
+// `PropertyAccess(CallExpression(_, filter), length)`. The right operand
+// must be the numeric literal `0`. Reports on the binary expression.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-some.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferArraySome struct{}
+
+func (unicornPreferArraySome) Name() string { return "unicorn/prefer-array-some" }
+func (unicornPreferArraySome) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornPreferArraySome) Check(ctx *Context, node *shimast.Node) {
+	bin := node.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+		return
+	}
+	switch bin.OperatorToken.Kind {
+	case shimast.KindGreaterThanToken,
+		shimast.KindGreaterThanEqualsToken,
+		shimast.KindExclamationEqualsEqualsToken,
+		shimast.KindExclamationEqualsToken:
+	default:
+		return
+	}
+	right := stripParens(bin.Right)
+	if right == nil || right.Kind != shimast.KindNumericLiteral {
+		return
+	}
+	if numericLiteralText(right) != "0" {
+		return
+	}
+	left := stripParens(bin.Left)
+	if left == nil || left.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	outer := left.AsPropertyAccessExpression()
+	if outer == nil || identifierText(outer.Name()) != "length" {
+		return
+	}
+	receiver := stripParens(outer.Expression)
+	if receiver == nil || receiver.Kind != shimast.KindCallExpression {
+		return
+	}
+	call := receiver.AsCallExpression()
+	if call == nil || call.Expression == nil ||
+		call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil || identifierText(access.Name()) != "filter" {
+		return
+	}
+	ctx.Report(node, "Prefer `Array#some()` over `.filter(...).length > 0`.")
+}
+
+func init() {
+	Register(unicornPreferArraySome{})
+}

package/linthost/rules_unicorn_prefer_at.go

@@ -0,0 +1,77 @@
+// unicorn/prefer-at: `arr[arr.length - 1]` is the legacy spelling of
+// "last element". ES2022 introduced `Array#at(-N)` (and `String#at(-N)`)
+// which lets you reach for the same value from the tail without
+// repeating the receiver and the subtraction. The rule pushes authors
+// toward the built-in.
+//
+// AST-only: visit each `ElementAccessExpression`. The index expression
+// must be a `BinaryExpression` whose operator is `-`, whose left side is
+// `PropertyAccess(_, length)`, and whose right side is a positive
+// numeric literal. The receiver of the `.length` access does not need
+// to match the element-access receiver textually; mismatches are
+// uncommon enough that the AST-only check stays useful in practice.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-at.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferAt struct{}
+
+func (unicornPreferAt) Name() string { return "unicorn/prefer-at" }
+func (unicornPreferAt) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindElementAccessExpression}
+}
+func (unicornPreferAt) Check(ctx *Context, node *shimast.Node) {
+	access := node.AsElementAccessExpression()
+	if access == nil || access.ArgumentExpression == nil {
+		return
+	}
+	index := stripParens(access.ArgumentExpression)
+	if index == nil || index.Kind != shimast.KindBinaryExpression {
+		return
+	}
+	bin := index.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
+	}
+	text := numericLiteralText(right)
+	if !unicornPreferAtIsPositiveInteger(text) {
+		return
+	}
+	ctx.Report(node, "Prefer `Array#at(-N)` / `String#at(-N)` over `arr[arr.length - N]`.")
+}
+
+// unicornPreferAtIsPositiveInteger reports whether `text` is the literal
+// form of a positive integer (>= 1). Leading zeros are accepted because
+// the JS scanner already normalized them; the only rejections are the
+// empty string, plain `0`, and anything containing a non-digit (decimals,
+// `e`-notation, hex, bigint suffix).
+func unicornPreferAtIsPositiveInteger(text string) bool {
+	if text == "" || text == "0" {
+		return false
+	}
+	for i := 0; i < len(text); i++ {
+		c := text[i]
+		if c < '0' || c > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+func init() {
+	Register(unicornPreferAt{})
+}

package/linthost/rules_unicorn_prefer_bigint_literals.go

@@ -0,0 +1,77 @@
+// unicorn/prefer-bigint-literals: `BigInt(1)` and `BigInt("1")` both
+// allocate a BigInt at runtime through a constructor call, while the
+// equivalent `1n` literal is one parse-time token with no call
+// overhead. The rule asks authors to use the literal form when the
+// argument is a known integer.
+//
+// AST-only: visit `KindCallExpression`, fire when the callee is the
+// bare `BigInt` identifier called with exactly one argument that is
+// either a numeric literal of any shape, or a string literal whose
+// content is a decimal-digit-only integer (optionally signed). The
+// conservative string check avoids flagging `BigInt("0x10")` and
+// other shapes that need a runtime parse.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-bigint-literals.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferBigintLiterals struct{}
+
+func (unicornPreferBigintLiterals) Name() string { return "unicorn/prefer-bigint-literals" }
+func (unicornPreferBigintLiterals) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferBigintLiterals) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || identifierText(call.Expression) != "BigInt" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+		return
+	}
+	arg := stripParens(call.Arguments.Nodes[0])
+	if arg == nil {
+		return
+	}
+	switch arg.Kind {
+	case shimast.KindNumericLiteral:
+		// `BigInt(1)` — always rewritable to `1n`.
+	case shimast.KindStringLiteral:
+		text := stringLiteralText(arg)
+		if !unicornPreferBigintLiteralsIsDecimalInteger(text) {
+			return
+		}
+	default:
+		return
+	}
+	ctx.Report(node, "Prefer BigInt literal `1n` over `BigInt(1)`.")
+}
+
+// unicornPreferBigintLiteralsIsDecimalInteger reports whether `text` is
+// a non-empty decimal-integer literal — digits only, optional leading
+// minus. The check is intentionally conservative; anything more exotic
+// (hex prefix, exponent, decimal point) leaves the BigInt call alone.
+func unicornPreferBigintLiteralsIsDecimalInteger(text string) bool {
+	if text == "" {
+		return false
+	}
+	i := 0
+	if text[0] == '-' || text[0] == '+' {
+		i++
+	}
+	if i == len(text) {
+		return false
+	}
+	for ; i < len(text); i++ {
+		ch := text[i]
+		if ch < '0' || ch > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+func init() {
+	Register(unicornPreferBigintLiterals{})
+}

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