@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_prefer_number_properties.go

@@ -0,0 +1,88 @@
+// unicorn/prefer-number-properties: the global functions `isNaN`,
+// `isFinite`, `parseFloat`, `parseInt`, and the global constants `NaN`,
+// `Infinity` were aliased onto the `Number` namespace in ES2015. The
+// `Number.*` forms coerce more predictably (`Number.isNaN("abc")` is
+// `false`, while the global `isNaN("abc")` is `true`) and are more
+// discoverable. The rule pushes authors to the namespaced spellings.
+//
+// AST-only: visit each `Identifier`. The text must be one of the six
+// shadowable names. The identifier must be in a value-expression
+// position — not the name part of a property access (`obj.isNaN`),
+// not the key of a property assignment, and not a binding name. Reports
+// on the identifier.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-number-properties.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornPreferNumberPropertiesNames = map[string]struct{}{
+  "isNaN":      {},
+  "isFinite":   {},
+  "parseFloat": {},
+  "parseInt":   {},
+  "NaN":        {},
+  "Infinity":   {},
+}
+
+type unicornPreferNumberProperties struct{}
+
+func (unicornPreferNumberProperties) Name() string {
+  return "unicorn/prefer-number-properties"
+}
+func (unicornPreferNumberProperties) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindIdentifier}
+}
+func (unicornPreferNumberProperties) Check(ctx *Context, node *shimast.Node) {
+  name := identifierText(node)
+  if _, ok := unicornPreferNumberPropertiesNames[name]; !ok {
+    return
+  }
+  parent := node.Parent
+  if parent == nil {
+    return
+  }
+  switch parent.Kind {
+  case shimast.KindPropertyAccessExpression:
+    // `obj.isNaN` — the identifier is the property name, not a
+    // reference to the global. `Number.isNaN(...)` itself also
+    // reaches here and must not be flagged.
+    access := parent.AsPropertyAccessExpression()
+    if access != nil && access.Name() == node {
+      return
+    }
+  case shimast.KindQualifiedName:
+    // Type-position `A.B` — same rationale as PropertyAccess.
+    return
+  case shimast.KindPropertyAssignment,
+    shimast.KindShorthandPropertyAssignment,
+    shimast.KindMethodDeclaration,
+    shimast.KindPropertyDeclaration,
+    shimast.KindEnumMember,
+    shimast.KindPropertySignature,
+    shimast.KindMethodSignature,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor:
+    // Member name slots on object/class shapes.
+    return
+  case shimast.KindParameter,
+    shimast.KindVariableDeclaration,
+    shimast.KindBindingElement,
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindClassDeclaration,
+    shimast.KindClassExpression,
+    shimast.KindImportSpecifier,
+    shimast.KindImportClause,
+    shimast.KindNamespaceImport,
+    shimast.KindExportSpecifier,
+    shimast.KindTypeParameter,
+    shimast.KindLabeledStatement:
+    // Binding / declaration names, not references to the global.
+    return
+  }
+  ctx.Report(node, "Prefer `Number.<X>` over the global `<X>` (e.g. `Number.isNaN`, `Number.parseInt`).")
+}
+
+func init() {
+  Register(unicornPreferNumberProperties{})
+}

package/linthost/rules_unicorn_prefer_object_from_entries.go

@@ -0,0 +1,55 @@
+// unicorn/prefer-object-from-entries: `entries.reduce((acc, [k, v]) =>
+// ({ ...acc, [k]: v }), {})` is the long-hand spelling of
+// `Object.fromEntries(entries)`. The reduce shape allocates a fresh
+// object at every step (O(n^2) total), reads as the operation rather
+// than the intent, and quietly drops to `Object` from whatever type the
+// entry shape implied. `Object.fromEntries` does the same thing in one
+// pass with one allocation and one well-known name.
+//
+// AST-only: visit `KindCallExpression`. Fire when the callee is
+// `PropertyAccess(_, reduce)` AND the call has exactly two arguments AND
+// the second argument is an empty `KindObjectLiteralExpression`. The
+// shape of the reducer is intentionally not inspected: an empty-object
+// seed in a `.reduce` chain is, in practice, the from-entries shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-object-from-entries.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferObjectFromEntries struct{}
+
+func (unicornPreferObjectFromEntries) Name() string {
+  return "unicorn/prefer-object-from-entries"
+}
+func (unicornPreferObjectFromEntries) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferObjectFromEntries) 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 || identifierText(access.Name()) != "reduce" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+    return
+  }
+  seed := stripParens(call.Arguments.Nodes[1])
+  if seed == nil || seed.Kind != shimast.KindObjectLiteralExpression {
+    return
+  }
+  obj := seed.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 0 {
+    return
+  }
+  ctx.Report(node, "Prefer `Object.fromEntries(...)` over `.reduce((acc, ...) => ..., {})` patterns.")
+}
+
+func init() {
+  Register(unicornPreferObjectFromEntries{})
+}

package/linthost/rules_unicorn_prefer_optional_catch_binding.go

@@ -0,0 +1,62 @@
+// unicorn/prefer-optional-catch-binding: ES2019 introduced optional
+// catch bindings (`catch { ... }`) so that catch clauses that never
+// reference the thrown error don't need to declare a binding at all.
+// Holding onto the binding name keeps a dead local variable in source
+// and signals that the catch body still cares about the error when in
+// fact it doesn't.
+//
+// AST-only: visit each `CatchClause`, restrict to the common-case
+// binding names `e` and `error` (true scope analysis would require a
+// resolver), and confirm the body's source text does not contain the
+// binding name as a word-bounded identifier. The previous substring
+// scan was load-bearing-wrong: `strings.Contains(body, "e")` matches
+// nearly any English identifier, hiding the rule entirely; word
+// boundaries (`\bname\b`) correctly distinguish `e` from `error`,
+// `error` from `errorMessage`, etc. False positives on `name` inside
+// string literals or comments are acceptable because the rule is
+// conservative by design.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-optional-catch-binding.md
+package linthost
+
+import (
+  "regexp"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+var unicornPreferOptionalCatchBindingNamePattern = map[string]*regexp.Regexp{
+  "e":     regexp.MustCompile(`\be\b`),
+  "error": regexp.MustCompile(`\berror\b`),
+}
+
+type unicornPreferOptionalCatchBinding struct{}
+
+func (unicornPreferOptionalCatchBinding) Name() string {
+  return "unicorn/prefer-optional-catch-binding"
+}
+func (unicornPreferOptionalCatchBinding) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCatchClause}
+}
+func (unicornPreferOptionalCatchBinding) Check(ctx *Context, node *shimast.Node) {
+  catch := node.AsCatchClause()
+  if catch == nil || catch.VariableDeclaration == nil || catch.Block == nil {
+    return
+  }
+  binding := catch.VariableDeclaration.Name()
+  if binding == nil || binding.Kind != shimast.KindIdentifier {
+    return
+  }
+  name := identifierText(binding)
+  pattern, ok := unicornPreferOptionalCatchBindingNamePattern[name]
+  if !ok {
+    return
+  }
+  if pattern.MatchString(nodeText(ctx.File, catch.Block)) {
+    return
+  }
+  ctx.Report(binding, "Prefer optional catch binding `catch { ... }` when the error is unused.")
+}
+
+func init() {
+  Register(unicornPreferOptionalCatchBinding{})
+}

package/linthost/rules_unicorn_prefer_prototype_methods.go

@@ -0,0 +1,54 @@
+// unicorn/prefer-prototype-methods: `[].slice`, `[].push`,
+// `{}.hasOwnProperty` and similar empty-literal property accesses are
+// shorthand for grabbing a prototype method without typing
+// `Array.prototype.slice` / `Object.prototype.hasOwnProperty`. The
+// shorthand allocates a throwaway literal at every call, hides the
+// intent of borrowing a prototype method, and is slower than the
+// direct prototype lookup.
+//
+// AST-only: visit each `PropertyAccessExpression`, then match the
+// receiver against either an empty `ArrayLiteralExpression` (no
+// elements) or an empty `ObjectLiteralExpression` (no properties).
+// The property name is intentionally not restricted — any borrowed
+// method should switch to the explicit `<Constructor>.prototype.<m>`
+// form.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-prototype-methods.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferPrototypeMethods struct{}
+
+func (unicornPreferPrototypeMethods) Name() string { return "unicorn/prefer-prototype-methods" }
+func (unicornPreferPrototypeMethods) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornPreferPrototypeMethods) Check(ctx *Context, node *shimast.Node) {
+  access := node.AsPropertyAccessExpression()
+  if access == nil || access.Expression == nil {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil {
+    return
+  }
+  switch receiver.Kind {
+  case shimast.KindArrayLiteralExpression:
+    arr := receiver.AsArrayLiteralExpression()
+    if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 0 {
+      return
+    }
+  case shimast.KindObjectLiteralExpression:
+    obj := receiver.AsObjectLiteralExpression()
+    if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 0 {
+      return
+    }
+  default:
+    return
+  }
+  ctx.Report(node, "Use `Array.prototype.<method>` / `Object.prototype.<method>` instead of borrowing via an empty literal.")
+}
+
+func init() {
+  Register(unicornPreferPrototypeMethods{})
+}

package/linthost/rules_unicorn_prefer_query_selector.go

@@ -0,0 +1,56 @@
+// unicorn/prefer-query-selector: `getElementById`,
+// `getElementsByClassName`, and `getElementsByTagName` predate the CSS
+// selector family on `Document` and `Element`. Unifying every lookup on
+// `querySelector` / `querySelectorAll` lets callers compose selectors
+// without juggling three different method signatures and live-collection
+// semantics.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose method identifier is one of the legacy lookup names, and fire
+// when the call has exactly one string-literal argument. The
+// string-literal gate isolates the canonical id/class/tag shape from
+// runtime-built argument expressions that the rule would mis-suggest a
+// selector for.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-query-selector.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornPreferQuerySelectorMethods = map[string]struct{}{
+  "getElementById":         {},
+  "getElementsByClassName": {},
+  "getElementsByTagName":   {},
+}
+
+type unicornPreferQuerySelector struct{}
+
+func (unicornPreferQuerySelector) Name() string { return "unicorn/prefer-query-selector" }
+func (unicornPreferQuerySelector) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferQuerySelector) 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 := unicornPreferQuerySelectorMethods[method]; !ok {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := call.Arguments.Nodes[0]
+  if arg == nil || arg.Kind != shimast.KindStringLiteral {
+    return
+  }
+  ctx.Report(node, "Prefer `querySelector` / `querySelectorAll` over `"+method+"`.")
+}
+
+func init() {
+  Register(unicornPreferQuerySelector{})
+}

package/linthost/rules_unicorn_prefer_reflect_apply.go

@@ -0,0 +1,36 @@
+// unicorn/prefer-reflect-apply: `Function.prototype.apply.call(fn, thisArg, args)`
+// is the long-hand pre-`Reflect.apply` workaround for invoking `apply`
+// when the receiver may have shadowed it. `Reflect.apply(fn, thisArg, args)`
+// expresses the same intent in a single named operation and survives
+// `apply` being deleted from the prototype chain.
+//
+// AST-only and text-driven: visit each `CallExpression` and match the
+// callee against the exact textual chain `Function.prototype.apply.call`.
+// Comparing against the source text is the cleanest conservative
+// recognition; alternate spellings (computed access, intermediate
+// aliases) are intentionally out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-reflect-apply.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferReflectApply struct{}
+
+func (unicornPreferReflectApply) Name() string { return "unicorn/prefer-reflect-apply" }
+func (unicornPreferReflectApply) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferReflectApply) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if nodeText(ctx.File, call.Expression) != "Function.prototype.apply.call" {
+    return
+  }
+  ctx.Report(node, "Prefer `Reflect.apply` over `Function.prototype.apply.call`.")
+}
+
+func init() {
+  Register(unicornPreferReflectApply{})
+}

package/linthost/rules_unicorn_prefer_regexp_test_rule.go

@@ -0,0 +1,80 @@
+// unicorn/prefer-regexp-test: `if ("abc".match(/a/))` and
+// `if (/a/.exec("abc"))` use match-array / null returns to encode a
+// boolean question. `RegExp#test()` returns a boolean directly, avoids
+// allocating the match result, and reads exactly like the question
+// being asked.
+//
+// AST-only and parent-driven: visit each `CallExpression` whose callee
+// is `PropertyAccess(_, match|exec)`, then confirm the call sits in a
+// boolean position — the condition slot of `if`/`?:`, the operand of a
+// unary `!`, or one of the short-circuit binary operators `&&`, `||`,
+// `??`. Matches that aren't in a boolean position may still use the
+// returned array, so they're out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-regexp-test.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferRegexpTest struct{}
+
+func (unicornPreferRegexpTest) Name() string { return "unicorn/prefer-regexp-test" }
+func (unicornPreferRegexpTest) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferRegexpTest) 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 "match", "exec":
+  default:
+    return
+  }
+  if !unicornPreferRegexpTestInBooleanPosition(node) {
+    return
+  }
+  ctx.Report(node, "Prefer `RegExp#test()` over `String#match()` / `RegExp#exec()` in a boolean context.")
+}
+
+// unicornPreferRegexpTestInBooleanPosition reports whether `node` sits in
+// a position that consumes only its truthiness: the condition of an
+// `if` / ternary, the operand of `!`, or one side of `&&` / `||` / `??`.
+func unicornPreferRegexpTestInBooleanPosition(node *shimast.Node) bool {
+  parent := node.Parent
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindIfStatement:
+    ifStmt := parent.AsIfStatement()
+    return ifStmt != nil && ifStmt.Expression == node
+  case shimast.KindConditionalExpression:
+    cond := parent.AsConditionalExpression()
+    return cond != nil && cond.Condition == node
+  case shimast.KindPrefixUnaryExpression:
+    pre := parent.AsPrefixUnaryExpression()
+    return pre != nil && pre.Operator == shimast.KindExclamationToken
+  case shimast.KindBinaryExpression:
+    bin := parent.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return false
+    }
+    switch bin.OperatorToken.Kind {
+    case shimast.KindAmpersandAmpersandToken,
+      shimast.KindBarBarToken,
+      shimast.KindQuestionQuestionToken:
+      return true
+    }
+  }
+  return false
+}
+
+func init() {
+  Register(unicornPreferRegexpTest{})
+}

package/linthost/rules_unicorn_prefer_response_static_json.go

@@ -0,0 +1,53 @@
+// unicorn/prefer-response-static-json: `new Response(JSON.stringify(value), …)`
+// is the manual two-step recipe — stringify then construct — that the
+// platform's `Response.json(value, …)` static factory now performs in
+// one call. The static factory also sets `Content-Type: application/json`
+// automatically; the manual form leaves the header to the author.
+//
+// AST-only: visit each `NewExpression`. Match when the callee identifier
+// is `Response` AND the first argument is a `CallExpression` whose
+// callee is the property chain `JSON.stringify`. Other arguments (init
+// options) are intentionally not inspected — the rule fires regardless
+// of headers/status because the simpler factory handles both shapes.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-response-static-json.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferResponseStaticJson struct{}
+
+func (unicornPreferResponseStaticJson) Name() string {
+  return "unicorn/prefer-response-static-json"
+}
+func (unicornPreferResponseStaticJson) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNewExpression}
+}
+func (unicornPreferResponseStaticJson) Check(ctx *Context, node *shimast.Node) {
+  ne := node.AsNewExpression()
+  if ne == nil || identifierText(ne.Expression) != "Response" {
+    return
+  }
+  if ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
+    return
+  }
+  first := stripParens(ne.Arguments.Nodes[0])
+  if first == nil || first.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := first.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil ||
+    identifierText(access.Expression) != "JSON" ||
+    identifierText(access.Name()) != "stringify" {
+    return
+  }
+  ctx.Report(node, "Prefer `Response.json(value)` over `new Response(JSON.stringify(value), ...)`.")
+}
+
+func init() {
+  Register(unicornPreferResponseStaticJson{})
+}

package/linthost/rules_unicorn_prefer_set_has.go

@@ -0,0 +1,42 @@
+// unicorn/prefer-set-has: `[a, b, c].includes(x)` is `O(n)` per lookup,
+// while `new Set([a, b, c]).has(x)` is `O(1)` after a single `O(n)`
+// construction. For repeated membership lookups against a fixed
+// collection the `Set` form is meaningfully faster and clearer about
+// intent.
+//
+// AST-only minimum-viable port: only the literal-array-receiver shape
+// (`[…].includes(x)`) is reported. The upstream rule also reasons
+// about typed variable receivers, which requires type-flow analysis
+// out of scope for this slice; expanding to typed receivers is a
+// follow-up.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-set-has.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSetHas struct{}
+
+func (unicornPreferSetHas) Name() string { return "unicorn/prefer-set-has" }
+func (unicornPreferSetHas) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferSetHas) 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()) != "includes" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  ctx.Report(node, "Prefer `Set#has()` over `Array#includes()` for repeated membership lookups against a constant collection.")
+}
+
+func init() {
+  Register(unicornPreferSetHas{})
+}

package/linthost/rules_unicorn_prefer_set_size.go

@@ -0,0 +1,48 @@
+// unicorn/prefer-set-size: `[...set].length` materializes the entire Set
+// into a throwaway array just to read its element count. `Set#size` is a
+// constant-time property that returns the same value without the
+// allocation, and reads more naturally for the intent the code expresses.
+//
+// AST-only: visit each `PropertyAccessExpression`, match when the
+// accessed property is named `length` AND the receiver is an
+// array-literal expression whose only element is a SpreadElement (i.e.
+// `[...x]`). The contents of the spread are not inspected — the
+// syntactic shape `[...x].length` is the signal regardless of whether
+// the spread source is statically a Set.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-set-size.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSetSize struct{}
+
+func (unicornPreferSetSize) Name() string { return "unicorn/prefer-set-size" }
+func (unicornPreferSetSize) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornPreferSetSize) Check(ctx *Context, node *shimast.Node) {
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "length" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  arr := receiver.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
+    return
+  }
+  only := arr.Elements.Nodes[0]
+  if only == nil || only.Kind != shimast.KindSpreadElement {
+    return
+  }
+  ctx.Report(node, "Prefer `Set#size` over `[...set].length`.")
+}
+
+func init() {
+  Register(unicornPreferSetSize{})
+}

package/linthost/rules_unicorn_prefer_simple_condition_first.go

@@ -0,0 +1,34 @@
+// unicorn/prefer-simple-condition-first: when a `&&`/`||` chain mixes
+// a "simple" operand (a bare identifier, a small literal comparison)
+// with a "complex" one (a function call, a property chain), short-
+// circuit evaluation reads more naturally if the simple operand sits
+// to the left — the cheap test is the gate, the expensive test runs
+// only if the gate passes.
+//
+// Escape-hatch / no-op port: ranking arbitrary expressions by
+// "simpleness" requires a stable complexity heuristic the upstream rule
+// embeds across hundreds of lines (literal counts, identifier depth,
+// call-chain weight, parenthesization). Without a faithful port of that
+// heuristic the rule would either over-fire on equally-weighted operands
+// or under-fire on the cases it is meant to catch; either way users get
+// confusing diagnostics. Registered so the typed-key/Go-registry parity
+// check passes and so users can configure the rule, but it intentionally
+// reports nothing until the heuristic lands in a follow-up.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-simple-condition-first.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSimpleConditionFirst struct{}
+
+func (unicornPreferSimpleConditionFirst) Name() string {
+  return "unicorn/prefer-simple-condition-first"
+}
+func (unicornPreferSimpleConditionFirst) Visits() []shimast.Kind { return nil }
+func (unicornPreferSimpleConditionFirst) Check(_ *Context, _ *shimast.Node) {
+  // Intentionally empty — see file header for the escape-hatch rationale.
+}
+
+func init() {
+  Register(unicornPreferSimpleConditionFirst{})
+}