@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_tsdoc.go

@@ -0,0 +1,136 @@
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// tsdocSyntax validates a conservative subset of eslint-plugin-tsdoc's
+// `tsdoc/syntax` rule. It intentionally starts with structural diagnostics
+// that can be checked from source text alone: malformed top-level block tags
+// and malformed or unclosed inline tags.
+type tsdocSyntax struct{}
+
+func (tsdocSyntax) Name() string           { return "jsdoc/tsdoc-syntax" }
+func (tsdocSyntax) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+
+func (tsdocSyntax) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.File == nil {
+    return
+  }
+  src := ctx.File.Text()
+  for _, block := range findJSDocBlocks(src) {
+    checkTSDocBlockTags(ctx, src, block)
+    checkTSDocInlineTags(ctx, src, block)
+  }
+}
+
+func checkTSDocBlockTags(ctx *Context, src string, block jsdocBlock) {
+  walkJSDocLines(src, block, func(contentStart, lineEnd int, inFence bool) {
+    if inFence || contentStart >= lineEnd || src[contentStart] != '@' {
+      return
+    }
+    tagStart := contentStart + 1
+    if tagStart >= lineEnd || !isTSDocTagStart(src[tagStart]) {
+      ctx.ReportRange(contentStart, minInt(lineEnd, contentStart+2), "Malformed TSDoc block tag.")
+    }
+  })
+}
+
+func checkTSDocInlineTags(ctx *Context, src string, block jsdocBlock) {
+  walkJSDocLines(src, block, func(contentStart, lineEnd int, inFence bool) {
+    if inFence {
+      return
+    }
+    for i := contentStart; i+1 < lineEnd; i++ {
+      if src[i] != '{' || src[i+1] != '@' {
+        continue
+      }
+      tagStart := i + 2
+      if tagStart >= lineEnd || !isTSDocTagStart(src[tagStart]) {
+        ctx.ReportRange(i, minInt(lineEnd, i+2), "Malformed TSDoc inline tag.")
+        continue
+      }
+      tagEnd := tagStart + 1
+      for tagEnd < lineEnd && isTSDocTagContinue(src[tagEnd]) {
+        tagEnd++
+      }
+      close := findByteInRange(src, '}', tagEnd, block.bodyEnd)
+      if close < 0 {
+        ctx.ReportRange(i, tagEnd, "Unclosed TSDoc inline tag.")
+        i = tagEnd - 1
+        continue
+      }
+      i = close
+    }
+  })
+}
+
+func walkJSDocLines(src string, block jsdocBlock, visit func(contentStart, lineEnd int, inFence bool)) {
+  inFence := false
+  for lineStart := block.bodyStart; lineStart < block.bodyEnd; {
+    lineEnd := lineStart
+    for lineEnd < block.bodyEnd && src[lineEnd] != '\n' {
+      lineEnd++
+    }
+    contentStart := tsdocLineContentStart(src, lineStart, lineEnd)
+    visit(contentStart, trimLineEnd(src, lineEnd), inFence)
+    if startsWithFenceMarker(src, contentStart, trimLineEnd(src, lineEnd)) {
+      inFence = !inFence
+    }
+    if lineEnd >= block.bodyEnd {
+      break
+    }
+    lineStart = lineEnd + 1
+  }
+}
+
+func tsdocLineContentStart(src string, lineStart, lineEnd int) int {
+  i := lineStart
+  for i < lineEnd && (src[i] == ' ' || src[i] == '\t' || src[i] == '\r') {
+    i++
+  }
+  if i < lineEnd && src[i] == '*' {
+    i++
+    if i < lineEnd && src[i] == ' ' {
+      i++
+    }
+  }
+  return i
+}
+
+func trimLineEnd(src string, lineEnd int) int {
+  for lineEnd > 0 && src[lineEnd-1] == '\r' {
+    lineEnd--
+  }
+  return lineEnd
+}
+
+func startsWithFenceMarker(src string, start, end int) bool {
+  return end-start >= 3 && src[start] == '`' && src[start+1] == '`' && src[start+2] == '`'
+}
+
+func findByteInRange(src string, target byte, start, end int) int {
+  for i := start; i < end; i++ {
+    if src[i] == target {
+      return i
+    }
+  }
+  return -1
+}
+
+func isTSDocTagStart(b byte) bool {
+  return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}
+
+func isTSDocTagContinue(b byte) bool {
+  return isTSDocTagStart(b) || (b >= '0' && b <= '9') || b == '-'
+}
+
+func minInt(a, b int) int {
+  if a < b {
+    return a
+  }
+  return b
+}
+
+func init() {
+  Register(tsdocSyntax{})
+}

package/linthost/rules_unicorn_better_regex.go

@@ -0,0 +1,27 @@
+// unicorn/better-regex: the upstream rule rewrites regex literals into
+// the shortest equivalent form (e.g. `[0-9]` -> `\d`, `[^\W\D]` -> `\d`,
+// dedupes character classes, collapses redundant quantifiers). That
+// rewrite requires a full regex parser with character-class semantics —
+// far beyond the AST-only scope of this slice — so the rule is
+// registered as a no-op stub to keep `TestTypedKeysMatchRegisteredRules`
+// honest with the typed `ITtscLintUnicornRules` surface.
+//
+// Replace this stub with a real implementation when a regex AST helper
+// lands; the matching fixture under
+// `tests/test-lint/src/cases/unicorn-better-regex.ts` carries the
+// `@ttsc-corpus-skip` directive so the corpus test suite walks past it.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/better-regex.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornBetterRegex struct{}
+
+func (unicornBetterRegex) Name() string           { return "unicorn/better-regex" }
+func (unicornBetterRegex) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornBetterRegex) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+  Register(unicornBetterRegex{})
+}

package/linthost/rules_unicorn_catch_error_name.go

@@ -0,0 +1,46 @@
+// unicorn/catch-error-name: a `catch (err)` clause whose binding is
+// anything other than `error` violates the project convention. The
+// stylistic point is that readers should see `catch (error)` and
+// immediately know the binding is the thrown value — bespoke names
+// like `e`, `err`, or `exception` create one-character variance for
+// no semantic gain.
+//
+// AST-only: visit each `CatchClause`, skip clauses with no binding
+// (optional catch-binding) and clauses whose binding is a destructuring
+// pattern (out of scope — the rule cannot rename a pattern in place).
+// When the binding identifier text is not `error`, report on the
+// identifier node so the diagnostic underlines the offending name.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/catch-error-name.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornCatchErrorName struct{}
+
+func (unicornCatchErrorName) Name() string { return "unicorn/catch-error-name" }
+func (unicornCatchErrorName) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCatchClause}
+}
+func (unicornCatchErrorName) Check(ctx *Context, node *shimast.Node) {
+  catch := node.AsCatchClause()
+  if catch == nil || catch.VariableDeclaration == nil {
+    return
+  }
+  binding := catch.VariableDeclaration.Name()
+  if binding == nil {
+    return
+  }
+  // Destructuring (object/array binding pattern) is out of scope.
+  if binding.Kind != shimast.KindIdentifier {
+    return
+  }
+  name := identifierText(binding)
+  if name == "" || name == "error" {
+    return
+  }
+  ctx.Report(binding, "The catch parameter should be named `error`.")
+}
+
+func init() {
+  Register(unicornCatchErrorName{})
+}

package/linthost/rules_unicorn_consistent_assert.go

@@ -0,0 +1,47 @@
+// unicorn/consistent-assert: `assert.equal` and `assert.notEqual` perform
+// loose equality (`==` / `!=`) at the runtime layer. The Node `assert`
+// module ships strict counterparts — `assert.strictEqual` and
+// `assert.notStrictEqual` — that read identically at the call site but
+// hold the stronger invariant. The rule pins the strict variants so
+// equality assertions don't silently accept type coercions.
+//
+// AST-only: visit each `CallExpression`. Match a callee of the shape
+// `assert.equal` or `assert.notEqual` (a `PropertyAccessExpression`
+// whose object identifier is `assert` and method name is one of the
+// loose-equality pair). The diagnostic anchors on the call so editors
+// can offer a strict-variant fix at the same position.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-assert.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentAssert struct{}
+
+func (unicornConsistentAssert) Name() string { return "unicorn/consistent-assert" }
+func (unicornConsistentAssert) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornConsistentAssert) 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 || access.Expression == nil {
+    return
+  }
+  if identifierText(access.Expression) != "assert" {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "equal", "notEqual":
+  default:
+    return
+  }
+  ctx.Report(node, "Use the strict variant — `assert.strictEqual` / `assert.notStrictEqual`.")
+}
+
+func init() {
+  Register(unicornConsistentAssert{})
+}

package/linthost/rules_unicorn_consistent_date_clone.go

@@ -0,0 +1,54 @@
+// unicorn/consistent-date-clone: the `Date` constructor copies a date
+// directly when handed another `Date` instance, so the common
+// `new Date(other.getTime())` shape adds a redundant `getTime()` hop
+// that yields the same instant. The shorter `new Date(other)` form is
+// the canonical clone.
+//
+// AST-only: visit each `NewExpression` whose callee identifier is
+// `Date` and whose single argument is `<receiver>.getTime()` with no
+// arguments. The receiver itself is opaque — only the call shape
+// matters because any `Date`-valued expression yields the same clone
+// when passed directly. The diagnostic anchors on the new-expression.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-date-clone.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentDateClone struct{}
+
+func (unicornConsistentDateClone) Name() string {
+  return "unicorn/consistent-date-clone"
+}
+func (unicornConsistentDateClone) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNewExpression}
+}
+func (unicornConsistentDateClone) Check(ctx *Context, node *shimast.Node) {
+  ne := node.AsNewExpression()
+  if ne == nil || identifierText(ne.Expression) != "Date" {
+    return
+  }
+  if ne.Arguments == nil || len(ne.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(ne.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := arg.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "getTime" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) != 0 {
+    return
+  }
+  ctx.Report(node, "Pass the `Date` directly to `new Date(...)` — `getTime()` is redundant.")
+}
+
+func init() {
+  Register(unicornConsistentDateClone{})
+}

package/linthost/rules_unicorn_consistent_destructuring.go

@@ -0,0 +1,25 @@
+// MVP: registers the rule so the typed-key parity test passes; the
+// upstream behavior needs scope analysis (track each destructured
+// binding through subsequent member-access sites in the same scope),
+// which is out of scope for this AST-only port.
+//
+// unicorn/consistent-destructuring:
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-destructuring.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentDestructuring struct{}
+
+func (unicornConsistentDestructuring) Name() string {
+  return "unicorn/consistent-destructuring"
+}
+func (unicornConsistentDestructuring) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornConsistentDestructuring) Check(ctx *Context, node *shimast.Node) {
+}
+
+func init() {
+  Register(unicornConsistentDestructuring{})
+}

package/linthost/rules_unicorn_consistent_empty_array_spread.go

@@ -0,0 +1,62 @@
+// unicorn/consistent-empty-array-spread: when an array literal contains
+// a spread of a ternary, both branches should be arrays so the runtime
+// shape of the parent literal stays uniform. The lopsided form
+// `[1, ...(cond ? [x] : 2)]` mixes "spread an array" and "spread a
+// non-array" — only one branch yields the structural shape the reader
+// expects.
+//
+// AST-only: visit each `ArrayLiteralExpression`. For every element
+// that is a `SpreadElement` wrapping a `ConditionalExpression`, fire
+// when exactly one of the two branches is itself an array literal
+// (the other branch is anything else). The diagnostic anchors on the
+// spread so the editor highlights both the `...` and the ternary.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-empty-array-spread.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentEmptyArraySpread struct{}
+
+func (unicornConsistentEmptyArraySpread) Name() string {
+  return "unicorn/consistent-empty-array-spread"
+}
+func (unicornConsistentEmptyArraySpread) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindArrayLiteralExpression}
+}
+func (unicornConsistentEmptyArraySpread) Check(ctx *Context, node *shimast.Node) {
+  arr := node.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil {
+    return
+  }
+  for _, el := range arr.Elements.Nodes {
+    if el == nil || el.Kind != shimast.KindSpreadElement {
+      continue
+    }
+    spread := el.AsSpreadElement()
+    if spread == nil {
+      continue
+    }
+    inner := stripParens(spread.Expression)
+    if inner == nil || inner.Kind != shimast.KindConditionalExpression {
+      continue
+    }
+    cond := inner.AsConditionalExpression()
+    if cond == nil {
+      continue
+    }
+    whenTrue := stripParens(cond.WhenTrue)
+    whenFalse := stripParens(cond.WhenFalse)
+    if whenTrue == nil || whenFalse == nil {
+      continue
+    }
+    trueIsArr := whenTrue.Kind == shimast.KindArrayLiteralExpression
+    falseIsArr := whenFalse.Kind == shimast.KindArrayLiteralExpression
+    if trueIsArr != falseIsArr {
+      ctx.Report(el, "When spreading a ternary in an array literal, both branches should be arrays.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornConsistentEmptyArraySpread{})
+}

package/linthost/rules_unicorn_consistent_existence_index_check.go

@@ -0,0 +1,80 @@
+// unicorn/consistent-existence-index-check: the same index-presence
+// test has two equivalent shapes — `arr.indexOf(x) === -1` (and the
+// `!== -1` complement) versus `arr.indexOf(x) < 0` / `>= 0`. Either
+// works at runtime, but a project should pick one. The canonical form
+// pinned here is the explicit `=== -1` / `!== -1`; the magnitude
+// comparison reads as math rather than as a presence check.
+//
+// AST-only: visit each `BinaryExpression`. Fire when the operator is
+// `<` or `>=`, the LEFT operand is a `CallExpression(PropertyAccess(_,
+// methodName))` whose method name is one of the index-returning Array
+// prototype methods, AND the right operand is a `0` literal. Only the
+// canonical orientation (`indexOf(x) < 0` / `indexOf(x) >= 0`) is
+// flagged; the swapped form (`0 < indexOf(x)`) has different
+// semantics ("found at index >= 1") and is intentionally not
+// recognized. The `=== -1` / `!== -1` orientation is the desired form,
+// so it does not fire.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-existence-index-check.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornConsistentExistenceIndexCheckMethods = map[string]struct{}{
+  "indexOf":       {},
+  "findIndex":     {},
+  "lastIndexOf":   {},
+  "findLastIndex": {},
+}
+
+type unicornConsistentExistenceIndexCheck struct{}
+
+func (unicornConsistentExistenceIndexCheck) Name() string {
+  return "unicorn/consistent-existence-index-check"
+}
+func (unicornConsistentExistenceIndexCheck) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornConsistentExistenceIndexCheck) 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.KindLessThanToken, shimast.KindGreaterThanEqualsToken:
+  default:
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if unicornConsistentExistenceIndexCheckMatch(left, right) {
+    ctx.Report(node, "Use a consistent existence-check form for `indexOf` / `findIndex` — prefer `=== -1` / `!== -1` over magnitude comparisons.")
+  }
+}
+
+func unicornConsistentExistenceIndexCheckMatch(callSide, literalSide *shimast.Node) bool {
+  if callSide == nil || literalSide == nil {
+    return false
+  }
+  if literalSide.Kind != shimast.KindNumericLiteral ||
+    numericLiteralText(literalSide) != "0" {
+    return false
+  }
+  if callSide.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := callSide.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return false
+  }
+  _, ok := unicornConsistentExistenceIndexCheckMethods[identifierText(access.Name())]
+  return ok
+}
+
+func init() {
+  Register(unicornConsistentExistenceIndexCheck{})
+}

package/linthost/rules_unicorn_consistent_function_scoping.go

@@ -0,0 +1,25 @@
+// MVP: registers the rule so the typed-key parity test passes; the
+// upstream behavior needs scope analysis (determine which free
+// variables a nested function references in the enclosing scope), which
+// is out of scope for this AST-only port.
+//
+// unicorn/consistent-function-scoping:
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-function-scoping.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentFunctionScoping struct{}
+
+func (unicornConsistentFunctionScoping) Name() string {
+  return "unicorn/consistent-function-scoping"
+}
+func (unicornConsistentFunctionScoping) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornConsistentFunctionScoping) Check(ctx *Context, node *shimast.Node) {
+}
+
+func init() {
+  Register(unicornConsistentFunctionScoping{})
+}

package/linthost/rules_unicorn_consistent_template_literal_escape.go

@@ -0,0 +1,25 @@
+// MVP: registers the rule so the typed-key parity test passes; the
+// upstream behavior needs raw-source escape-sequence analysis (the two
+// equivalent forms `\${` and `$\{` are erased by the parser into the
+// same token text), which is out of scope for this AST-only port.
+//
+// unicorn/consistent-template-literal-escape:
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-template-literal-escape.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornConsistentTemplateLiteralEscape struct{}
+
+func (unicornConsistentTemplateLiteralEscape) Name() string {
+  return "unicorn/consistent-template-literal-escape"
+}
+func (unicornConsistentTemplateLiteralEscape) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSourceFile}
+}
+func (unicornConsistentTemplateLiteralEscape) Check(ctx *Context, node *shimast.Node) {
+}
+
+func init() {
+  Register(unicornConsistentTemplateLiteralEscape{})
+}

package/linthost/rules_unicorn_custom_error_definition.go

@@ -0,0 +1,138 @@
+// unicorn/custom-error-definition: a class that extends a built-in
+// `Error` constructor inherits the `message` and `stack` plumbing but
+// not a sensible `name`. The canonical custom-error shape calls
+// `super(message)` so the inherited fields are initialized AND sets
+// `this.name` to the subclass identifier so engines and loggers can
+// distinguish it from generic `Error` instances.
+//
+// AST-only: visit each `ClassDeclaration` / `ClassExpression`. Match
+// the `extends <Identifier>` clause against the eight built-in Error
+// constructors. When a constructor exists, fire if its body contains
+// no `super(...)` call — the conservative MVP. Anything subtler (does
+// the super call forward `message`? is `this.name` ever assigned?) is
+// out of scope for the AST-only port.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/custom-error-definition.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornCustomErrorDefinitionBaseNames = map[string]struct{}{
+  "Error":          {},
+  "EvalError":      {},
+  "RangeError":     {},
+  "ReferenceError": {},
+  "SyntaxError":    {},
+  "TypeError":      {},
+  "URIError":       {},
+  "AggregateError": {},
+}
+
+type unicornCustomErrorDefinition struct{}
+
+func (unicornCustomErrorDefinition) Name() string {
+  return "unicorn/custom-error-definition"
+}
+func (unicornCustomErrorDefinition) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
+}
+func (unicornCustomErrorDefinition) Check(ctx *Context, node *shimast.Node) {
+  if !unicornCustomErrorDefinitionExtendsError(node) {
+    return
+  }
+  members := classMembers(node)
+  for _, member := range members {
+    if member == nil || member.Kind != shimast.KindConstructor {
+      continue
+    }
+    ctor := member.AsConstructorDeclaration()
+    if ctor == nil || ctor.Body == nil {
+      continue
+    }
+    if !unicornCustomErrorDefinitionBodyCallsSuper(ctor.Body) {
+      ctx.Report(node, "A custom `Error` subclass should call `super(message)` and set `this.name`.")
+      return
+    }
+  }
+}
+
+// unicornCustomErrorDefinitionExtendsError reports whether `class` has
+// an `extends <Identifier>` heritage clause whose target identifier is
+// one of the built-in Error constructors.
+func unicornCustomErrorDefinitionExtendsError(class *shimast.Node) bool {
+  var clauses []*shimast.Node
+  switch class.Kind {
+  case shimast.KindClassDeclaration:
+    decl := class.AsClassDeclaration()
+    if decl == nil || decl.HeritageClauses == nil {
+      return false
+    }
+    clauses = decl.HeritageClauses.Nodes
+  case shimast.KindClassExpression:
+    expr := class.AsClassExpression()
+    if expr == nil || expr.HeritageClauses == nil {
+      return false
+    }
+    clauses = expr.HeritageClauses.Nodes
+  default:
+    return false
+  }
+  for _, clause := range clauses {
+    if clause == nil {
+      continue
+    }
+    hc := clause.AsHeritageClause()
+    if hc == nil || hc.Token != shimast.KindExtendsKeyword || hc.Types == nil {
+      continue
+    }
+    for _, ty := range hc.Types.Nodes {
+      if ty == nil {
+        continue
+      }
+      expr := ty.AsExpressionWithTypeArguments()
+      if expr == nil {
+        continue
+      }
+      name := identifierText(expr.Expression)
+      if _, ok := unicornCustomErrorDefinitionBaseNames[name]; ok {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+// unicornCustomErrorDefinitionBodyCallsSuper walks the constructor body
+// and reports whether any `CallExpression` whose callee is the `super`
+// keyword exists at any depth. Nested function-like scopes are skipped
+// — a `super(...)` inside a nested arrow does not initialize `Error`'s
+// prototype state.
+func unicornCustomErrorDefinitionBodyCallsSuper(body *shimast.Node) bool {
+  found := false
+  var walk func(*shimast.Node)
+  walk = func(n *shimast.Node) {
+    if n == nil || found {
+      return
+    }
+    if n != body && isFunctionLikeKind(n) {
+      return
+    }
+    if n.Kind == shimast.KindCallExpression {
+      call := n.AsCallExpression()
+      if call != nil && call.Expression != nil &&
+        call.Expression.Kind == shimast.KindSuperKeyword {
+        found = true
+        return
+      }
+    }
+    n.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(body)
+  return found
+}
+
+func init() {
+  Register(unicornCustomErrorDefinition{})
+}