@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_unicorn_prefer_string_starts_ends_with.go

@@ -0,0 +1,148 @@
+// unicorn/prefer-string-starts-ends-with: `s.slice(0, 4) === "http"` and
+// `s.slice(-3) === "abc"` are the legacy spellings of `s.startsWith(...)`
+// and `s.endsWith(...)`. The String methods are clearer about intent, do
+// not allocate the intermediate substring, and have been available for
+// over a decade.
+//
+// AST-only: visit each `BinaryExpression` whose operator is `===` or
+// `!==`. One operand must be a `CallExpression` of the shape
+// `_.slice(0, N)` or `_.slice(-N)` (the `-N` form being a unary minus
+// over a numeric literal) and the other operand must be a string literal
+// whose text length matches N. Reports on the binary expression.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-starts-ends-with.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferStringStartsEndsWith struct{}
+
+func (unicornPreferStringStartsEndsWith) Name() string {
+	return "unicorn/prefer-string-starts-ends-with"
+}
+func (unicornPreferStringStartsEndsWith) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornPreferStringStartsEndsWith) 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.KindEqualsEqualsEqualsToken,
+		shimast.KindExclamationEqualsEqualsToken:
+	default:
+		return
+	}
+	left := stripParens(bin.Left)
+	right := stripParens(bin.Right)
+	if unicornPreferStringStartsEndsWithMatches(left, right) ||
+		unicornPreferStringStartsEndsWithMatches(right, left) {
+		ctx.Report(node, "Prefer `String#startsWith()` / `String#endsWith()` over slice-and-compare.")
+	}
+}
+
+// unicornPreferStringStartsEndsWithMatches reports whether `callSide` is
+// the slice call and `literalSide` is a matching string literal.
+func unicornPreferStringStartsEndsWithMatches(callSide, literalSide *shimast.Node) bool {
+	if callSide == nil || literalSide == nil {
+		return false
+	}
+	if callSide.Kind != shimast.KindCallExpression {
+		return false
+	}
+	if literalSide.Kind != shimast.KindStringLiteral &&
+		literalSide.Kind != shimast.KindNoSubstitutionTemplateLiteral {
+		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()) != "slice" {
+		return false
+	}
+	if call.Arguments == nil {
+		return false
+	}
+	args := call.Arguments.Nodes
+	wantLen := -1
+	switch len(args) {
+	case 2:
+		first := stripParens(args[0])
+		second := stripParens(args[1])
+		if first == nil || first.Kind != shimast.KindNumericLiteral ||
+			numericLiteralText(first) != "0" {
+			return false
+		}
+		if second == nil || second.Kind != shimast.KindNumericLiteral {
+			return false
+		}
+		if !unicornPreferStringStartsEndsWithDigits(numericLiteralText(second)) {
+			return false
+		}
+		wantLen = unicornPreferStringStartsEndsWithToInt(numericLiteralText(second))
+	case 1:
+		// `.slice(-N)` — a unary minus over a positive numeric literal.
+		only := stripParens(args[0])
+		if only == nil || only.Kind != shimast.KindPrefixUnaryExpression {
+			return false
+		}
+		prefix := only.AsPrefixUnaryExpression()
+		if prefix == nil || prefix.Operator != shimast.KindMinusToken ||
+			prefix.Operand == nil ||
+			prefix.Operand.Kind != shimast.KindNumericLiteral {
+			return false
+		}
+		text := numericLiteralText(prefix.Operand)
+		if !unicornPreferStringStartsEndsWithDigits(text) {
+			return false
+		}
+		wantLen = unicornPreferStringStartsEndsWithToInt(text)
+	default:
+		return false
+	}
+	if wantLen <= 0 {
+		return false
+	}
+	return len(stringLiteralText(literalSide)) == wantLen
+}
+
+// unicornPreferStringStartsEndsWithDigits reports whether `text` is a
+// non-empty ASCII decimal-integer literal. Decimals, hex, and `e`-notation
+// are rejected since the rule only handles fixed-length prefixes.
+func unicornPreferStringStartsEndsWithDigits(text string) bool {
+	if text == "" {
+		return false
+	}
+	for i := 0; i < len(text); i++ {
+		c := text[i]
+		if c < '0' || c > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+// unicornPreferStringStartsEndsWithToInt parses an ASCII decimal-integer
+// literal into an int. Callers must have validated the input first; this
+// helper returns -1 only as a defensive fallback for an overflow guard.
+func unicornPreferStringStartsEndsWithToInt(text string) int {
+	n := 0
+	for i := 0; i < len(text); i++ {
+		c := text[i]
+		if c < '0' || c > '9' {
+			return -1
+		}
+		n = n*10 + int(c-'0')
+		if n > 1<<30 {
+			return -1
+		}
+	}
+	return n
+}
+
+func init() {
+	Register(unicornPreferStringStartsEndsWith{})
+}

package/linthost/rules_unicorn_prefer_string_trim_start_end.go

@@ -0,0 +1,48 @@
+// unicorn/prefer-string-trim-start-end: `String#trimLeft` and
+// `String#trimRight` are the deprecated names for what
+// `String#trimStart` / `String#trimEnd` express directly. The deprecated
+// names are still callable but should be replaced for consistency with
+// the modern naming. The rule fires on zero-argument calls to either
+// deprecated method.
+//
+// AST-only: a `CallExpression` whose callee is `.trimLeft` or
+// `.trimRight` and whose argument list is empty matches. Arguments are
+// theoretically not allowed on either method, but the AST does not
+// know that — the rule defends against the syntactic shape only.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-trim-start-end.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferStringTrimStartEnd struct{}
+
+func (unicornPreferStringTrimStartEnd) Name() string {
+	return "unicorn/prefer-string-trim-start-end"
+}
+func (unicornPreferStringTrimStartEnd) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferStringTrimStartEnd) 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 "trimLeft", "trimRight":
+	default:
+		return
+	}
+	if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+		return
+	}
+	ctx.Report(node, "Prefer `String#trimStart` / `String#trimEnd` over the deprecated `trimLeft` / `trimRight`.")
+}
+
+func init() {
+	Register(unicornPreferStringTrimStartEnd{})
+}

package/linthost/rules_unicorn_prefer_structured_clone.go

@@ -0,0 +1,71 @@
+// unicorn/prefer-structured-clone: `JSON.parse(JSON.stringify(x))` is
+// the historical deep-clone idiom. It silently drops everything JSON
+// cannot round-trip — `Date`, `Map`, `Set`, typed arrays, cyclic
+// references — and re-allocates a large intermediate string. The
+// platform-native `structuredClone(x)` handles every transferable type,
+// supports cycles, and avoids the string round-trip entirely.
+//
+// AST-only: visit each `CallExpression`, match `JSON.parse(arg)` whose
+// single `arg` is itself a `JSON.stringify(...)` call. Both gates lock
+// the receiver to the bare `JSON` identifier so member-access chains
+// reading `parse`/`stringify` on a renamed alias do not trip the rule.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-structured-clone.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferStructuredClone struct{}
+
+func (unicornPreferStructuredClone) Name() string {
+	return "unicorn/prefer-structured-clone"
+}
+func (unicornPreferStructuredClone) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferStructuredClone) Check(ctx *Context, node *shimast.Node) {
+	if !isJSONMethodCall(node, "parse") {
+		return
+	}
+	outer := node.AsCallExpression()
+	if outer == nil || outer.Arguments == nil || len(outer.Arguments.Nodes) != 1 {
+		return
+	}
+	arg := stripParens(outer.Arguments.Nodes[0])
+	if arg == nil || arg.Kind != shimast.KindCallExpression {
+		return
+	}
+	if !isJSONMethodCall(arg, "stringify") {
+		return
+	}
+	ctx.Report(node, "Prefer `structuredClone(x)` over `JSON.parse(JSON.stringify(x))`.")
+}
+
+// isJSONMethodCall reports whether `node` is a CallExpression whose
+// callee is `JSON.<method>` — a property access reading `method` on a
+// bare `JSON` identifier. The bare-identifier gate keeps the rule from
+// firing on `aliased.parse(...)` shapes that happen to share the
+// method name.
+func isJSONMethodCall(node *shimast.Node, method string) bool {
+	if node == nil || node.Kind != shimast.KindCallExpression {
+		return false
+	}
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return false
+	}
+	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return false
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return false
+	}
+	if identifierText(access.Name()) != method {
+		return false
+	}
+	return identifierText(stripParens(access.Expression)) == "JSON"
+}
+
+func init() {
+	Register(unicornPreferStructuredClone{})
+}

package/linthost/rules_unicorn_prefer_switch.go

@@ -0,0 +1,103 @@
+// unicorn/prefer-switch: a long `if (x === "a") {…} else if (x === "b")
+// {…} else if (x === "c") {…}` ladder repeats both the discriminant and
+// the equality check on every branch; `switch (x)` collapses the cascade
+// into one labelled lookup and signals intent ("dispatch on the value of
+// x") more directly. The cliff for the rewrite is at three branches —
+// fewer than that, the if-cascade and the switch are about equally
+// readable.
+//
+// AST-only minimum-viable port: visit `IfStatement` and only fire on
+// the outermost `if` of a chain. Walk the else-chain and require it to
+// contain THREE OR MORE `else if` clauses whose condition is a
+// `BinaryExpression` with `===` (or `==`) AND whose left operand is
+// textually identical to the outermost if's left operand AND whose
+// right operand is a string-or-numeric literal. The outermost `if`
+// itself must satisfy the same shape. The shape constraint is
+// intentionally conservative — switch can only dispatch on equality
+// against literal labels.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-switch.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSwitch struct{}
+
+func (unicornPreferSwitch) Name() string { return "unicorn/prefer-switch" }
+func (unicornPreferSwitch) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindIfStatement}
+}
+func (unicornPreferSwitch) Check(ctx *Context, node *shimast.Node) {
+	// Only fire on the outermost if — if our parent is also an
+	// `IfStatement` whose else-branch is `node`, this is a middle of the
+	// chain and a higher-up visit will report it once.
+	if node.Parent != nil && node.Parent.Kind == shimast.KindIfStatement {
+		parent := node.Parent.AsIfStatement()
+		if parent != nil && parent.ElseStatement == node {
+			return
+		}
+	}
+	stmt := node.AsIfStatement()
+	if stmt == nil || stmt.Expression == nil {
+		return
+	}
+	discriminant, ok := unicornPreferSwitchDiscriminant(ctx, stmt.Expression)
+	if !ok {
+		return
+	}
+	// Count the outermost `if` plus every well-shaped `else if` that
+	// compares against the same discriminant.
+	branches := 1
+	cur := stmt.ElseStatement
+	for cur != nil && cur.Kind == shimast.KindIfStatement {
+		inner := cur.AsIfStatement()
+		if inner == nil || inner.Expression == nil {
+			return
+		}
+		next, ok := unicornPreferSwitchDiscriminant(ctx, inner.Expression)
+		if !ok || next != discriminant {
+			return
+		}
+		branches++
+		cur = inner.ElseStatement
+	}
+	if branches >= 3 {
+		ctx.Report(node, "Three or more `else if` clauses comparing the same value should be a `switch`.")
+	}
+}
+
+// unicornPreferSwitchDiscriminant returns the textual form of the left
+// operand of an `===`/`==` comparison against a string-or-numeric
+// literal. Returns ok=false for any other shape.
+func unicornPreferSwitchDiscriminant(ctx *Context, expr *shimast.Node) (string, bool) {
+	expr = stripParens(expr)
+	if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+		return "", false
+	}
+	bin := expr.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil {
+		return "", false
+	}
+	switch bin.OperatorToken.Kind {
+	case shimast.KindEqualsEqualsEqualsToken, shimast.KindEqualsEqualsToken:
+	default:
+		return "", false
+	}
+	right := stripParens(bin.Right)
+	if right == nil {
+		return "", false
+	}
+	switch right.Kind {
+	case shimast.KindStringLiteral, shimast.KindNumericLiteral:
+	default:
+		return "", false
+	}
+	left := stripParens(bin.Left)
+	if left == nil {
+		return "", false
+	}
+	return nodeText(ctx.File, left), true
+}
+
+func init() {
+	Register(unicornPreferSwitch{})
+}

package/linthost/rules_unicorn_prefer_ternary.go

@@ -0,0 +1,71 @@
+// unicorn/prefer-ternary: when an `if`/`else` pair only differs in the
+// value being returned (or, in the upstream rule, assigned), the
+// equivalent `return cond ? a : b` is one line, removes the
+// duplicated `return` keyword, and matches the shape of every other
+// "pick one of two values" expression in the language.
+//
+// AST-only minimum-viable port: visit `IfStatement` and match only the
+// return-statement case. Both then- and else-branches must each be a
+// single `ReturnStatement` with a non-nil expression — either a bare
+// `return …;` directly under the if, or a block wrapping exactly one
+// such return. The assignment shape (`if (cond) x = a; else x = b;`)
+// from the upstream rule is out of scope for this MVP; both call sites
+// look syntactically symmetric, so adding the assignment branch later
+// is a straightforward extension.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-ternary.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferTernary struct{}
+
+func (unicornPreferTernary) Name() string { return "unicorn/prefer-ternary" }
+func (unicornPreferTernary) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindIfStatement}
+}
+func (unicornPreferTernary) Check(ctx *Context, node *shimast.Node) {
+	stmt := node.AsIfStatement()
+	if stmt == nil || stmt.ThenStatement == nil || stmt.ElseStatement == nil {
+		return
+	}
+	// Reject `else if` — an `if`/`else if`/`else` ladder is a different
+	// rewrite target (it becomes nested ternaries, which the upstream
+	// rule explicitly does not require).
+	if stmt.ElseStatement.Kind == shimast.KindIfStatement {
+		return
+	}
+	if !unicornPreferTernaryIsSingleReturn(stmt.ThenStatement) {
+		return
+	}
+	if !unicornPreferTernaryIsSingleReturn(stmt.ElseStatement) {
+		return
+	}
+	ctx.Report(node, "Use a ternary instead of `if`/`else` whose branches differ only in the returned value.")
+}
+
+// unicornPreferTernaryIsSingleReturn reports whether `branch` is a
+// single `return expr;` — either directly or wrapped in a one-statement
+// block. Returns false for empty returns (`return;`); ternary cannot
+// fold those because both arms have to produce a value.
+func unicornPreferTernaryIsSingleReturn(branch *shimast.Node) bool {
+	if branch == nil {
+		return false
+	}
+	stmt := branch
+	if branch.Kind == shimast.KindBlock {
+		block := branch.AsBlock()
+		if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+			return false
+		}
+		stmt = block.Statements.Nodes[0]
+	}
+	if stmt == nil || stmt.Kind != shimast.KindReturnStatement {
+		return false
+	}
+	ret := stmt.AsReturnStatement()
+	return ret != nil && ret.Expression != nil
+}
+
+func init() {
+	Register(unicornPreferTernary{})
+}

package/linthost/rules_unicorn_prefer_top_level_await.go

@@ -0,0 +1,72 @@
+// unicorn/prefer-top-level-await: ES modules support top-level `await`,
+// which produces a flat synchronous-looking sequence and surfaces
+// rejections through the host. A `.then(cb)` continuation at the module
+// scope re-introduces the callback shape the host could have flattened
+// for free, and silently swallows rejections unless the author wires up
+// an explicit `.catch`.
+//
+// AST-only minimum-viable port: visit `CallExpression` and fire when the
+// callee is `PropertyAccess(_, then)` AND the call sits at the top
+// level of the source file — i.e., walking parents from the call's
+// enclosing statement, the first statement-ancestor's parent is a
+// `SourceFile`. Calls inside a function, class, namespace body, or
+// inside any nested block are excluded; top-level `await` only applies
+// to the module body.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-top-level-await.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferTopLevelAwait struct{}
+
+func (unicornPreferTopLevelAwait) Name() string { return "unicorn/prefer-top-level-await" }
+func (unicornPreferTopLevelAwait) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferTopLevelAwait) 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()) != "then" {
+		return
+	}
+	if !unicornPreferTopLevelAwaitIsTopLevel(node) {
+		return
+	}
+	ctx.Report(node, "Prefer top-level `await` over `.then` chains in ES modules.")
+}
+
+// unicornPreferTopLevelAwaitIsTopLevel walks ancestors and reports
+// whether `node` is positioned in the top-level statement list of a
+// `SourceFile`. The walk crosses parenthesized expressions and
+// expression statements; it stops the moment it sees any function-like,
+// class-body, block, or module-block boundary, which would push the call
+// out of module scope.
+func unicornPreferTopLevelAwaitIsTopLevel(node *shimast.Node) bool {
+	for cur := node.Parent; cur != nil; cur = cur.Parent {
+		switch cur.Kind {
+		case shimast.KindSourceFile:
+			return true
+		case shimast.KindFunctionDeclaration,
+			shimast.KindFunctionExpression,
+			shimast.KindArrowFunction,
+			shimast.KindMethodDeclaration,
+			shimast.KindGetAccessor,
+			shimast.KindSetAccessor,
+			shimast.KindConstructor,
+			shimast.KindClassDeclaration,
+			shimast.KindClassExpression,
+			shimast.KindModuleBlock,
+			shimast.KindBlock:
+			return false
+		}
+	}
+	return false
+}
+
+func init() {
+	Register(unicornPreferTopLevelAwait{})
+}

package/linthost/rules_unicorn_prefer_type_error.go

@@ -0,0 +1,127 @@
+// unicorn/prefer-type-error: a guard whose condition is a runtime
+// `typeof` / `instanceof` check throws to signal "wrong type", not
+// "wrong value". JavaScript's `TypeError` exists precisely for that
+// distinction, and tooling (e.g. assertion libraries) treats the two
+// error classes differently. The rule asks throwers to switch from
+// `Error` to `TypeError` whenever the surrounding check is a type
+// check.
+//
+// AST-only: visit every `IfStatement`, require its condition (after
+// `stripParens`, optionally unwrapping a `!` prefix) to be a runtime
+// type check — either a `KindTypeOfExpression`, a `KindBinaryExpression`
+// with the `instanceof` operator, or a `==` / `===` / `!=` / `!==`
+// comparison where one side is a `typeof` expression. The then-branch
+// must be a single `KindThrowStatement` of `new Error(...)`. Fire on
+// the throw.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-type-error.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferTypeError struct{}
+
+func (unicornPreferTypeError) Name() string { return "unicorn/prefer-type-error" }
+func (unicornPreferTypeError) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindIfStatement}
+}
+func (unicornPreferTypeError) Check(ctx *Context, node *shimast.Node) {
+	stmt := node.AsIfStatement()
+	if stmt == nil || stmt.Expression == nil || stmt.ThenStatement == nil {
+		return
+	}
+	cond := stripParens(stmt.Expression)
+	if cond == nil {
+		return
+	}
+	// Accept either the bare type check (`typeof x !== "number"`) or a
+	// negation of one (`!(x instanceof Foo)`).
+	if cond.Kind == shimast.KindPrefixUnaryExpression {
+		prefix := cond.AsPrefixUnaryExpression()
+		if prefix == nil || prefix.Operator != shimast.KindExclamationToken {
+			return
+		}
+		cond = stripParens(prefix.Operand)
+	}
+	if !unicornPreferTypeErrorIsTypeCheck(cond) {
+		return
+	}
+	throw := unicornPreferTypeErrorSingleThrow(stmt.ThenStatement)
+	if throw == nil {
+		return
+	}
+	throwStmt := throw.AsThrowStatement()
+	if throwStmt == nil {
+		return
+	}
+	expr := stripParens(throwStmt.Expression)
+	if expr == nil || expr.Kind != shimast.KindNewExpression {
+		return
+	}
+	ne := expr.AsNewExpression()
+	if ne == nil || identifierText(ne.Expression) != "Error" {
+		return
+	}
+	ctx.Report(throw, "Throw `TypeError` (not `Error`) when the surrounding check is a runtime type check.")
+}
+
+// unicornPreferTypeErrorIsTypeCheck reports whether `node` is a
+// `typeof x` expression or `x instanceof Y` BinaryExpression. Both
+// shapes encode a runtime type test, which is what the rule keys off.
+func unicornPreferTypeErrorIsTypeCheck(node *shimast.Node) bool {
+	if node == nil {
+		return false
+	}
+	switch node.Kind {
+	case shimast.KindTypeOfExpression:
+		return true
+	case shimast.KindBinaryExpression:
+		bin := node.AsBinaryExpression()
+		if bin == nil || bin.OperatorToken == nil {
+			return false
+		}
+		if bin.OperatorToken.Kind == shimast.KindInstanceOfKeyword {
+			return true
+		}
+		// `typeof x !== "string"` style — covers the common idiom.
+		switch bin.OperatorToken.Kind {
+		case shimast.KindEqualsEqualsEqualsToken,
+			shimast.KindEqualsEqualsToken,
+			shimast.KindExclamationEqualsEqualsToken,
+			shimast.KindExclamationEqualsToken:
+			left := stripParens(bin.Left)
+			right := stripParens(bin.Right)
+			return (left != nil && left.Kind == shimast.KindTypeOfExpression) ||
+				(right != nil && right.Kind == shimast.KindTypeOfExpression)
+		}
+	}
+	return false
+}
+
+// unicornPreferTypeErrorSingleThrow returns the single `throw`
+// statement inside `branch` — accepting either a bare ThrowStatement
+// or a Block wrapping exactly one ThrowStatement. Returns nil for any
+// other shape.
+func unicornPreferTypeErrorSingleThrow(branch *shimast.Node) *shimast.Node {
+	if branch == nil {
+		return nil
+	}
+	if branch.Kind == shimast.KindThrowStatement {
+		return branch
+	}
+	if branch.Kind != shimast.KindBlock {
+		return nil
+	}
+	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.KindThrowStatement {
+		return nil
+	}
+	return stmt
+}
+
+func init() {
+	Register(unicornPreferTypeError{})
+}