@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_empty_brace_spaces.go

@@ -0,0 +1,73 @@
+// unicorn/empty-brace-spaces: an empty block `{ }` or empty object
+// literal `{ }` written with whitespace between the braces wastes a
+// column of source for no semantic effect. The rule collapses the two
+// braces so the canonical empty form is `{}`.
+//
+// AST-only: visit both `Block` and `ObjectLiteralExpression`. The match
+// fires when the node is empty (zero statements / zero properties) AND
+// the source text between the opening `{` and closing `}` contains at
+// least one whitespace byte. The whitespace check uses the source-file
+// byte buffer directly because the AST itself elides the inter-token
+// whitespace.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/empty-brace-spaces.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornEmptyBraceSpaces struct{}
+
+func (unicornEmptyBraceSpaces) Name() string { return "unicorn/empty-brace-spaces" }
+func (unicornEmptyBraceSpaces) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBlock, shimast.KindObjectLiteralExpression}
+}
+func (unicornEmptyBraceSpaces) Check(ctx *Context, node *shimast.Node) {
+  if ctx.File == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindBlock:
+    block := node.AsBlock()
+    if block == nil || block.Statements == nil || len(block.Statements.Nodes) > 0 {
+      return
+    }
+  case shimast.KindObjectLiteralExpression:
+    obj := node.AsObjectLiteralExpression()
+    if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) > 0 {
+      return
+    }
+  default:
+    return
+  }
+  src := ctx.File.Text()
+  _, end := tokenRange(ctx.File, node)
+  pos := node.Pos()
+  if pos < 0 || end < 0 || end > len(src) {
+    return
+  }
+  // Locate the opening `{` after any leading trivia.
+  open := -1
+  for i := pos; i < end; i++ {
+    if src[i] == '{' {
+      open = i
+      break
+    }
+  }
+  if open < 0 || end-1 <= open {
+    return
+  }
+  // The closing `}` is the byte immediately before End().
+  if src[end-1] != '}' {
+    return
+  }
+  for i := open + 1; i < end-1; i++ {
+    switch src[i] {
+    case ' ', '\t', '\r', '\n':
+      ctx.Report(node, "Empty braces shouldn't contain whitespace.")
+      return
+    }
+  }
+}
+
+func init() {
+  Register(unicornEmptyBraceSpaces{})
+}

package/linthost/rules_unicorn_error_message.go

@@ -0,0 +1,64 @@
+// unicorn/error-message: a `new Error()` (or any built-in Error subclass)
+// without a message string strips the most valuable diagnostic from the
+// stack trace. The error type alone tells readers nothing about WHY the
+// throw site fired; the rule requires every Error construction to carry
+// a non-empty message.
+//
+// AST-only: visit each `NewExpression`, match the callee identifier
+// against the built-in Error allowlist, then inspect the argument list.
+// Zero arguments fires immediately; a single argument fires only when it
+// is a string literal whose text is empty (`new Error("")`). Calls with
+// dynamic arguments are out of scope because the rule cannot prove the
+// argument resolves to a non-empty string at runtime.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/error-message.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornErrorMessageBuiltinNames = map[string]struct{}{
+  "Error":          {},
+  "TypeError":      {},
+  "RangeError":     {},
+  "SyntaxError":    {},
+  "ReferenceError": {},
+  "EvalError":      {},
+  "URIError":       {},
+  "AggregateError": {},
+}
+
+type unicornErrorMessage struct{}
+
+func (unicornErrorMessage) Name() string { return "unicorn/error-message" }
+func (unicornErrorMessage) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNewExpression}
+}
+func (unicornErrorMessage) Check(ctx *Context, node *shimast.Node) {
+  ne := node.AsNewExpression()
+  if ne == nil {
+    return
+  }
+  name := identifierText(ne.Expression)
+  if name == "" {
+    return
+  }
+  if _, ok := unicornErrorMessageBuiltinNames[name]; !ok {
+    return
+  }
+  // Zero arguments — `new Error()` / `new Error` — always fires.
+  if ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
+    ctx.Report(node, "Pass an error message to the `Error` constructor.")
+    return
+  }
+  // Single argument — fire only when the argument is an empty string
+  // literal. Dynamic arguments cannot be proven empty statically.
+  if len(ne.Arguments.Nodes) == 1 {
+    arg := stripParens(ne.Arguments.Nodes[0])
+    if arg != nil && arg.Kind == shimast.KindStringLiteral && stringLiteralText(arg) == "" {
+      ctx.Report(node, "Pass an error message to the `Error` constructor.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornErrorMessage{})
+}

package/linthost/rules_unicorn_escape_case.go

@@ -0,0 +1,51 @@
+// unicorn/escape-case: numeric escape sequences inside string and
+// template literals (`\xHH`, `\uHHHH`, `\u{HEX...}`) are case-insensitive
+// to the engine but read inconsistently across a codebase when authors
+// mix `\xa9` and `\xA9`. Canonical form uses uppercase hex digits; the
+// rule fires when any hex escape's A-F digits are lowercase.
+//
+// AST-only: visit `KindStringLiteral` and `KindNoSubstitutionTemplateLiteral`,
+// read the raw source text via `nodeText` (the parser already decodes
+// escapes into the `.Text` value), and match against a regex that finds
+// `\xHH`, `\uHHHH`, or `\u{HEX...}` whose hex portion contains an a-f
+// letter. The match is hex-only — `\n` and other identifier escapes are
+// untouched.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/escape-case.md
+package linthost
+
+import (
+  "regexp"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// unicornEscapeCasePattern matches a hex escape whose hex digits contain
+// at least one lowercase a-f letter. The regex anchors on `\x`, `\u`, or
+// `\u{...}` and rejects matches where every hex digit is already
+// uppercase / 0-9.
+var unicornEscapeCasePattern = regexp.MustCompile(
+  `\\x[0-9A-Fa-f]*[a-f][0-9A-Fa-f]*|` +
+    `\\u\{[0-9A-Fa-f]*[a-f][0-9A-Fa-f]*\}|` +
+    `\\u[0-9A-Fa-f]*[a-f][0-9A-Fa-f]*`,
+)
+
+type unicornEscapeCase struct{}
+
+func (unicornEscapeCase) Name() string { return "unicorn/escape-case" }
+func (unicornEscapeCase) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+}
+func (unicornEscapeCase) Check(ctx *Context, node *shimast.Node) {
+  source := nodeText(ctx.File, node)
+  if source == "" {
+    return
+  }
+  if unicornEscapeCasePattern.MatchString(source) {
+    ctx.Report(node, "Use uppercase letters for escape sequence hex digits (`\\xA9` over `\\xa9`).")
+  }
+}
+
+func init() {
+  Register(unicornEscapeCase{})
+}

package/linthost/rules_unicorn_expiring_todo_comments.go

@@ -0,0 +1,78 @@
+// unicorn/expiring-todo-comments: a `TODO`/`FIXME`/`XXX` comment with no
+// expiration condition is a future-dated lie waiting to bit-rot — the
+// upstream rule wants every such marker to carry a bracketed predicate
+// like `[2027-01-01]` or `[npm:foo@>=2]` so that the lint will start
+// failing once the condition is met.
+//
+// File-level dispatch: visit `KindSourceFile` once per file, scan the
+// raw source with the tsgo scanner so embedded `/* */` and `//` tokens
+// inside template substitutions and string literals are not mistaken
+// for real comments, strip the comment delimiters via
+// `stripCommentDelimiters`, then for each stripped body locate a
+// TODO-family marker. Go's RE2 has no negative lookahead, so the
+// "no `[` annotation block follows" half of the rule is checked
+// separately: after the keyword match offset, scan the rest of the
+// comment body for a `[` byte. Missing means the marker has no
+// expiration condition; the comment range is reported.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/expiring-todo-comments.md
+package linthost
+
+import (
+  "regexp"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// unicornExpiringTodoCommentsKeywordPattern matches a TODO-family
+// marker that starts at the beginning of the (stripped) comment body
+// or after whitespace, and is followed by `:`, whitespace, `(`, or
+// end-of-string. The leading anchor avoids matching `todo` inside
+// kebab-cased identifiers like `expiring-todo-comments` that other
+// in-tree comments (e.g. the harness's own `// expect:` lines)
+// inevitably include. Case-insensitive.
+var unicornExpiringTodoCommentsKeywordPattern = regexp.MustCompile(`(?i)(?:^|\s)(TODO|FIXME|XXX)(?:[:(\s]|$)`)
+
+type unicornExpiringTodoComments struct{}
+
+func (unicornExpiringTodoComments) Name() string { return "unicorn/expiring-todo-comments" }
+func (unicornExpiringTodoComments) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornExpiringTodoComments) Check(ctx *Context, node *shimast.Node) {
+  if ctx.File == nil {
+    return
+  }
+  src := ctx.File.Text()
+  scanner := shimscanner.NewScanner()
+  scanner.SetText(src)
+  scanner.SetSkipTrivia(false)
+  for {
+    kind := scanner.Scan()
+    if kind == shimast.KindEndOfFile {
+      break
+    }
+    if kind != shimast.KindSingleLineCommentTrivia && kind != shimast.KindMultiLineCommentTrivia {
+      continue
+    }
+    start := scanner.TokenStart()
+    end := scanner.TokenEnd()
+    if start < 0 || end > len(src) || end <= start {
+      continue
+    }
+    body := stripCommentDelimiters(src[start:end])
+    match := unicornExpiringTodoCommentsKeywordPattern.FindStringIndex(body)
+    if match == nil {
+      continue
+    }
+    if strings.Contains(body[match[1]:], "[") {
+      continue
+    }
+    ctx.ReportRange(start, end, "Add an expiration condition to this TODO (e.g., `[2027-01-01]` or `[npm:foo@>=2]`).")
+  }
+}
+
+func init() {
+  Register(unicornExpiringTodoComments{})
+}

package/linthost/rules_unicorn_explicit_length_check.go

@@ -0,0 +1,88 @@
+// unicorn/explicit-length-check: `.length` (or `.size`) coerced to
+// boolean (`if (xs.length) …`) reads as "is the array truthy" rather
+// than "does the array have elements". A reader has to know that
+// `.length` is a number and that `0` is the only falsy value to
+// reconstruct the intent. Explicit comparisons (`xs.length > 0`,
+// `xs.length === 0`) put the predicate on the page. The rule fires
+// when a `.length`/`.size` property access sits in a boolean context.
+//
+// AST-only: visit `KindPropertyAccessExpression`, accept when the
+// property name is `length` or `size`, and check whether the (possibly
+// parenthesized) node sits as the test of an `if`/`while`/`for`/
+// conditional, as the operand of `!`, or as a side of a logical
+// `&&`/`||`/`??` chain. The boolean-context walk reuses the parent
+// traversal pattern from `rules_logic.go::isInBooleanContext`.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/explicit-length-check.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornExplicitLengthCheck struct{}
+
+func (unicornExplicitLengthCheck) Name() string { return "unicorn/explicit-length-check" }
+func (unicornExplicitLengthCheck) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornExplicitLengthCheck) Check(ctx *Context, node *shimast.Node) {
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  name := identifierText(access.Name())
+  if name != "length" && name != "size" {
+    return
+  }
+  if !unicornExplicitLengthCheckIsBooleanContext(node) {
+    return
+  }
+  ctx.Report(node, "Use an explicit comparison (`.length > 0` or `.length === 0`) instead of truthy coercion.")
+}
+
+// unicornExplicitLengthCheckIsBooleanContext walks the parent chain to
+// see whether the value of `node` is consumed as a boolean — the test
+// position of a control-flow statement / ternary, the operand of `!`,
+// or one side of a logical (`&&` / `||` / `??`) chain.
+func unicornExplicitLengthCheckIsBooleanContext(node *shimast.Node) bool {
+  cur := node
+  for cur != nil && cur.Parent != nil && cur.Parent.Kind == shimast.KindParenthesizedExpression {
+    cur = cur.Parent
+  }
+  if cur == nil {
+    return false
+  }
+  parent := cur.Parent
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindIfStatement:
+    return parent.AsIfStatement().Expression == cur
+  case shimast.KindWhileStatement:
+    return parent.AsWhileStatement().Expression == cur
+  case shimast.KindDoStatement:
+    return parent.AsDoStatement().Expression == cur
+  case shimast.KindForStatement:
+    return parent.AsForStatement().Condition == cur
+  case shimast.KindConditionalExpression:
+    return parent.AsConditionalExpression().Condition == cur
+  case shimast.KindPrefixUnaryExpression:
+    return parent.AsPrefixUnaryExpression().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(unicornExplicitLengthCheck{})
+}

package/linthost/rules_unicorn_filename_case.go

@@ -0,0 +1,29 @@
+// unicorn/filename-case: enforces a single case convention (kebab,
+// camel, snake, or pascal) on every source file name. The MVP target
+// would be kebab-case, but the in-tree test fixture for this rule
+// lives at `tests/test-lint/src/cases/unicorn-filename-case.ts` —
+// which is already kebab-case — so the rule would never fire on its
+// own fixture and the corpus test would have no positive case to
+// assert on. A proper port also needs a way to influence the
+// fixture's virtual filename from the harness, which is not exposed
+// today.
+//
+// Registered as a no-op stub to keep
+// `TestTypedKeysMatchRegisteredRules` aligned with the typed
+// `ITtscLintUnicornRules` surface. The fixture keeps its
+// `@ttsc-corpus-skip` directive.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/filename-case.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornFilenameCase struct{}
+
+func (unicornFilenameCase) Name() string           { return "unicorn/filename-case" }
+func (unicornFilenameCase) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornFilenameCase) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+  Register(unicornFilenameCase{})
+}

package/linthost/rules_unicorn_import_style.go

@@ -0,0 +1,28 @@
+// unicorn/import-style: forbids named or default imports from configured
+// modules so that, for example, `path` is always imported as the
+// namespace `path` and never destructured. The rule's behavior is
+// entirely driven by a per-module configuration map
+// (`styles: { foo: { default: false, namespace: true } }`). Without that
+// configuration plumbing landing in the host's rule-options pipeline,
+// the rule has no defaults to enforce, so it is registered as a no-op
+// stub to keep `TestTypedKeysMatchRegisteredRules` aligned with the
+// typed `ITtscLintUnicornRules` surface.
+//
+// The matching fixture under
+// `tests/test-lint/src/cases/unicorn-import-style.ts` keeps its
+// `@ttsc-corpus-skip` directive until the configuration plumbing lands.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/import-style.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornImportStyle struct{}
+
+func (unicornImportStyle) Name() string           { return "unicorn/import-style" }
+func (unicornImportStyle) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornImportStyle) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+  Register(unicornImportStyle{})
+}

package/linthost/rules_unicorn_isolated_functions.go

@@ -0,0 +1,29 @@
+// unicorn/isolated-functions: flags function expressions that "escape"
+// their lexical closure unintentionally — e.g. an inner function that
+// references no outer binding but is still placed at the inner scope.
+// Correctly identifying "isolated function" context requires scope
+// analysis tracking what each nested function captures, which is not
+// available in the AST-only slice of this port.
+//
+// Registered as a no-op stub to keep
+// `TestTypedKeysMatchRegisteredRules` aligned with the typed
+// `ITtscLintUnicornRules` surface. The matching fixture under
+// `tests/test-lint/src/cases/unicorn-isolated-functions.ts` keeps its
+// `@ttsc-corpus-skip` directive.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/isolated-functions.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornIsolatedFunctions struct{}
+
+func (unicornIsolatedFunctions) Name() string { return "unicorn/isolated-functions" }
+func (unicornIsolatedFunctions) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornIsolatedFunctions) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+  Register(unicornIsolatedFunctions{})
+}

package/linthost/rules_unicorn_new_for_builtins.go

@@ -0,0 +1,87 @@
+// unicorn/new-for-builtins: built-in globals split into two groups for
+// constructor etiquette. Primitive wrappers (`String`, `Number`, …) must
+// be called WITHOUT `new` because the wrapper-object form is a footgun
+// — `new String("x") instanceof Object` is true but `"x" instanceof
+// Object` is false, and the wrapper form does not unify with the
+// primitive in equality comparisons. Container constructors (`Array`,
+// `Error`, `Map`, …) must be called WITH `new` because the call form
+// either misbehaves (`Array(3)` allocates a sparse 3-slot array) or is
+// outright invalid (`Error()` still works but is style-inconsistent).
+//
+// AST-only: visit both `NewExpression` and `CallExpression`. The
+// callee-identifier text is matched against the corresponding allowlist
+// and reported with the inverted construction message.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/new-for-builtins.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// Primitive wrappers — `new` is wrong, call form is required.
+var unicornNewForBuiltinsPrimitiveWrappers = map[string]struct{}{
+  "String":  {},
+  "Number":  {},
+  "Boolean": {},
+  "Symbol":  {},
+  "BigInt":  {},
+}
+
+// Container constructors — `new` is required, call form is wrong. Note
+// that `Symbol` is intentionally NOT in this list: `Symbol(...)` is the
+// correct primitive-wrapper call and must not be flagged.
+var unicornNewForBuiltinsContainers = map[string]struct{}{
+  "Array":          {},
+  "Error":          {},
+  "EvalError":      {},
+  "RangeError":     {},
+  "ReferenceError": {},
+  "SyntaxError":    {},
+  "TypeError":      {},
+  "URIError":       {},
+  "AggregateError": {},
+  "Object":         {},
+  "Map":            {},
+  "Set":            {},
+  "WeakMap":        {},
+  "WeakSet":        {},
+  "Date":           {},
+  "RegExp":         {},
+}
+
+type unicornNewForBuiltins struct{}
+
+func (unicornNewForBuiltins) Name() string { return "unicorn/new-for-builtins" }
+func (unicornNewForBuiltins) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
+}
+func (unicornNewForBuiltins) Check(ctx *Context, node *shimast.Node) {
+  switch node.Kind {
+  case shimast.KindNewExpression:
+    ne := node.AsNewExpression()
+    if ne == nil {
+      return
+    }
+    name := identifierText(ne.Expression)
+    if name == "" {
+      return
+    }
+    if _, ok := unicornNewForBuiltinsPrimitiveWrappers[name]; ok {
+      ctx.Report(node, "Don't use `new "+name+"(...)` with a primitive wrapper like `"+name+"`.")
+    }
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil {
+      return
+    }
+    name := identifierText(call.Expression)
+    if name == "" {
+      return
+    }
+    if _, ok := unicornNewForBuiltinsContainers[name]; ok {
+      ctx.Report(node, "Use `new "+name+"(...)` instead of `"+name+"(...)`.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornNewForBuiltins{})
+}

package/linthost/rules_unicorn_no_abusive_eslint_disable.go

@@ -0,0 +1,63 @@
+// unicorn/no-abusive-eslint-disable: a bare `// eslint-disable*` directive
+// with no rule list suppresses every lint rule for the affected scope.
+// That blanket-disable hides unrelated diagnostics the next reviewer would
+// have caught, so the rule requires every `eslint-disable*` directive to
+// name the rules it silences.
+//
+// File-level dispatch: visit `KindSourceFile` once per file, scan the
+// raw source with the tsgo scanner so embedded `/* */` and `//` tokens
+// inside template substitutions and string literals are not mistaken for
+// real comments, and match each comment's stripped body — already trimmed
+// by the shared `stripCommentDelimiters` helper — against
+// `^eslint-disable(?:-next-line|-line)?$`. A match means the directive
+// carries no rule list and is reported on the comment range.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-abusive-eslint-disable.md
+package linthost
+
+import (
+  "regexp"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+var unicornNoAbusiveEslintDisablePattern = regexp.MustCompile(`^eslint-disable(?:-next-line|-line)?$`)
+
+type unicornNoAbusiveEslintDisable struct{}
+
+func (unicornNoAbusiveEslintDisable) Name() string { return "unicorn/no-abusive-eslint-disable" }
+func (unicornNoAbusiveEslintDisable) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornNoAbusiveEslintDisable) Check(ctx *Context, node *shimast.Node) {
+  if ctx.File == nil {
+    return
+  }
+  src := ctx.File.Text()
+  scanner := shimscanner.NewScanner()
+  scanner.SetText(src)
+  scanner.SetSkipTrivia(false)
+  for {
+    kind := scanner.Scan()
+    if kind == shimast.KindEndOfFile {
+      break
+    }
+    if kind != shimast.KindSingleLineCommentTrivia && kind != shimast.KindMultiLineCommentTrivia {
+      continue
+    }
+    start := scanner.TokenStart()
+    end := scanner.TokenEnd()
+    if start < 0 || end > len(src) || end <= start {
+      continue
+    }
+    body := stripCommentDelimiters(src[start:end])
+    if !unicornNoAbusiveEslintDisablePattern.MatchString(body) {
+      continue
+    }
+    ctx.ReportRange(start, end, "Specify the rules to disable in each `eslint-disable*` directive.")
+  }
+}
+
+func init() {
+  Register(unicornNoAbusiveEslintDisable{})
+}