@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_no_document_cookie.go

@@ -0,0 +1,41 @@
+// unicorn/no-document-cookie: writing to (or reading) `document.cookie`
+// directly mixes name/value parsing, serialization, attribute handling,
+// and quoting concerns into one mutable string. The replacement is the
+// async Cookie Store API (`cookieStore.set`/`cookieStore.get`) or a
+// dedicated cookie wrapper — both surface attribute fields as data
+// instead of string-encoded options.
+//
+// AST-only and identifier-text-driven: any `PropertyAccessExpression`
+// whose receiver identifier is `document` and whose property name is
+// `cookie` matches, so the same visit handles both the read
+// (`document.cookie`) and the assignment LHS (`document.cookie = "..."`).
+// Shadowed `document` bindings and computed/optional access are out of
+// scope, mirroring `unicorn/no-process-exit`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-document-cookie.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoDocumentCookie struct{}
+
+func (unicornNoDocumentCookie) Name() string { return "unicorn/no-document-cookie" }
+func (unicornNoDocumentCookie) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornNoDocumentCookie) Check(ctx *Context, node *shimast.Node) {
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Expression) != "document" {
+    return
+  }
+  if identifierText(access.Name()) != "cookie" {
+    return
+  }
+  ctx.Report(node, "Don't use `document.cookie` directly; use the Cookie Store API or a wrapper.")
+}
+
+func init() {
+  Register(unicornNoDocumentCookie{})
+}

package/linthost/rules_unicorn_no_empty_file.go

@@ -0,0 +1,44 @@
+// unicorn/no-empty-file: a source file with no executable contribution
+// — every statement is a bare `;` empty-statement (or there are no
+// statements at all) — usually exists by accident: a placeholder kept
+// around past its purpose, a generator output for a missing input, or
+// a copy of a file whose body was deleted. The rule flags these so the
+// file is either filled with content or removed.
+//
+// SourceFile dispatch: the engine fires `KindSourceFile` visits once
+// per file at the file root (see engine.runFile). For visibility into
+// where the diagnostic lands when reporters render `path:line:col`, the
+// rule reports on the first statement node when one exists (so the
+// pointer matches the file's source line); when the file truly has no
+// statements at all it falls back to `ReportRange(0, 0, …)` so the
+// diagnostic still surfaces.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-empty-file.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoEmptyFile struct{}
+
+func (unicornNoEmptyFile) Name() string           { return "unicorn/no-empty-file" }
+func (unicornNoEmptyFile) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornNoEmptyFile) Check(ctx *Context, node *shimast.Node) {
+  if ctx.File == nil {
+    return
+  }
+  statements := ctx.File.Statements
+  const message = "Empty files are not allowed."
+  if statements == nil || len(statements.Nodes) == 0 {
+    ctx.ReportRange(0, 0, message)
+    return
+  }
+  for _, stmt := range statements.Nodes {
+    if stmt == nil || stmt.Kind != shimast.KindEmptyStatement {
+      return
+    }
+  }
+  ctx.Report(statements.Nodes[0], message)
+}
+
+func init() {
+  Register(unicornNoEmptyFile{})
+}

package/linthost/rules_unicorn_no_for_loop.go

@@ -0,0 +1,102 @@
+// unicorn/no-for-loop: the classic `for (let i = 0; i < arr.length; i++)`
+// pattern is an index-based array walk that has a direct `for…of`
+// translation. The index variable, the length re-read, and the manual
+// increment are all incidental bookkeeping the language now expresses
+// with one keyword.
+//
+// AST-only and syntactic: dispatch on `ForStatement` and match the
+// three classic shapes — `let i = 0` initializer, `i < X.length`
+// condition (the RHS must be a `.length` access; bare counters
+// `i < n` are not flagged because the suggested `for…of` rewrite does
+// not apply), and `i++` incrementor. The length operand is not
+// required to resolve to an array at the type level; the syntactic
+// shape is the signal the rule wants to discourage.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-for-loop.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoForLoop struct{}
+
+func (unicornNoForLoop) Name() string           { return "unicorn/no-for-loop" }
+func (unicornNoForLoop) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindForStatement} }
+func (unicornNoForLoop) Check(ctx *Context, node *shimast.Node) {
+  stmt := node.AsForStatement()
+  if stmt == nil || stmt.Initializer == nil || stmt.Condition == nil || stmt.Incrementor == nil {
+    return
+  }
+  indexName := indexInitializerName(stmt.Initializer)
+  if indexName == "" {
+    return
+  }
+  if !isLessThanCondition(stmt.Condition, indexName) {
+    return
+  }
+  if !isPostfixIncrementOf(stmt.Incrementor, indexName) {
+    return
+  }
+  ctx.Report(node, "Use `for…of` over an index-based `for` loop over an array.")
+}
+
+// indexInitializerName returns the variable name of a `let i = 0`
+// initializer, or "" when the initializer is anything else.
+func indexInitializerName(init *shimast.Node) string {
+  if init == nil || init.Kind != shimast.KindVariableDeclarationList {
+    return ""
+  }
+  list := init.AsVariableDeclarationList()
+  if list == nil || list.Declarations == nil || len(list.Declarations.Nodes) != 1 {
+    return ""
+  }
+  decl := list.Declarations.Nodes[0].AsVariableDeclaration()
+  if decl == nil || decl.Initializer == nil {
+    return ""
+  }
+  if numericLiteralText(stripParens(decl.Initializer)) != "0" {
+    return ""
+  }
+  return identifierText(decl.Name())
+}
+
+// isLessThanCondition reports whether `cond` has the shape
+// `<name> < <something>.length`. The right-hand operand must be a
+// property access ending in `length`; bare counter loops such as
+// `for (let i = 0; i < n; i++)` are NOT flagged because the rule's
+// suggested rewrite (`for…of`) only applies to array iteration.
+func isLessThanCondition(cond *shimast.Node, name string) bool {
+  node := stripParens(cond)
+  if node == nil || node.Kind != shimast.KindBinaryExpression {
+    return false
+  }
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil ||
+    bin.OperatorToken.Kind != shimast.KindLessThanToken {
+    return false
+  }
+  if identifierText(stripParens(bin.Left)) != name {
+    return false
+  }
+  right := stripParens(bin.Right)
+  if right == nil || right.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := right.AsPropertyAccessExpression()
+  return access != nil && identifierText(access.Name()) == "length"
+}
+
+// isPostfixIncrementOf reports whether `inc` has the shape `<name>++`.
+func isPostfixIncrementOf(inc *shimast.Node, name string) bool {
+  node := stripParens(inc)
+  if node == nil || node.Kind != shimast.KindPostfixUnaryExpression {
+    return false
+  }
+  post := node.AsPostfixUnaryExpression()
+  if post == nil || post.Operator != shimast.KindPlusPlusToken {
+    return false
+  }
+  return identifierText(post.Operand) == name
+}
+
+func init() {
+  Register(unicornNoForLoop{})
+}

package/linthost/rules_unicorn_no_hex_escape.go

@@ -0,0 +1,42 @@
+// unicorn/no-hex-escape: `\xHH` escapes inside string and template
+// literals are legal but they read worse than the equivalent
+// `\u00HH` Unicode escape — there's only one way to write a Unicode
+// escape, while a hex escape silently widens to a Unicode escape at
+// runtime anyway. The rule nudges authors toward the Unicode form.
+//
+// AST-only: visit `KindStringLiteral` and `KindNoSubstitutionTemplateLiteral`,
+// read the raw source text via `nodeText` (the parser already decodes
+// escapes into the `.Text` value, so a normal accessor would see `©`
+// instead of `\xA9`), and fire when the source contains a `\xHH`
+// occurrence where HH is two hex digits.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-hex-escape.md
+package linthost
+
+import (
+  "regexp"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+var unicornNoHexEscapePattern = regexp.MustCompile(`\\x[0-9A-Fa-f]{2}`)
+
+type unicornNoHexEscape struct{}
+
+func (unicornNoHexEscape) Name() string { return "unicorn/no-hex-escape" }
+func (unicornNoHexEscape) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+}
+func (unicornNoHexEscape) Check(ctx *Context, node *shimast.Node) {
+  source := nodeText(ctx.File, node)
+  if source == "" {
+    return
+  }
+  if unicornNoHexEscapePattern.MatchString(source) {
+    ctx.Report(node, "Prefer Unicode escapes (`\\uXXXX`) over hex escapes (`\\xHH`).")
+  }
+}
+
+func init() {
+  Register(unicornNoHexEscape{})
+}

package/linthost/rules_unicorn_no_immediate_mutation.go

@@ -0,0 +1,90 @@
+// unicorn/no-immediate-mutation: mutating an expression on the same
+// statement that produces it — e.g. `[1, 2, 3].push(4)` or
+// `arr.map(...).sort()` — discards the mutator's return value (which is
+// either the new length or `void`) and obscures whether the author
+// wanted the array, the count, or the side effect. The rule splits the
+// two operations: construct first, then mutate (or use the non-mutating
+// counterpart).
+//
+// AST-only: visit each `CallExpression`. Match when the callee is a
+// `PropertyAccessExpression(receiver, name)` where `name` is one of the
+// mutating array methods AND the receiver (after `stripParens`) is
+// either an `ArrayLiteralExpression` or another call expression whose
+// callee is a non-mutating array method that produces a fresh array.
+// Fire on the outer call.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-immediate-mutation.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoImmediateMutationMethods = map[string]struct{}{
+  "push":       {},
+  "pop":        {},
+  "shift":      {},
+  "unshift":    {},
+  "splice":     {},
+  "sort":       {},
+  "reverse":    {},
+  "copyWithin": {},
+  "fill":       {},
+}
+
+var unicornNoImmediateMutationFreshMethods = map[string]struct{}{
+  "map":     {},
+  "filter":  {},
+  "slice":   {},
+  "concat":  {},
+  "flat":    {},
+  "flatMap": {},
+}
+
+type unicornNoImmediateMutation struct{}
+
+func (unicornNoImmediateMutation) Name() string { return "unicorn/no-immediate-mutation" }
+func (unicornNoImmediateMutation) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoImmediateMutation) 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 {
+    return
+  }
+  method := identifierText(access.Name())
+  if _, ok := unicornNoImmediateMutationMethods[method]; !ok {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil {
+    return
+  }
+  if receiver.Kind == shimast.KindArrayLiteralExpression {
+    ctx.Report(node, "Don't mutate a freshly built array — separate the construction and the mutation, or use a non-mutating method.")
+    return
+  }
+  if receiver.Kind == shimast.KindCallExpression {
+    inner := receiver.AsCallExpression()
+    if inner == nil || inner.Expression == nil ||
+      inner.Expression.Kind != shimast.KindPropertyAccessExpression {
+      return
+    }
+    innerAccess := inner.Expression.AsPropertyAccessExpression()
+    if innerAccess == nil {
+      return
+    }
+    innerName := identifierText(innerAccess.Name())
+    if _, ok := unicornNoImmediateMutationFreshMethods[innerName]; ok {
+      ctx.Report(node, "Don't mutate a freshly built array — separate the construction and the mutation, or use a non-mutating method.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornNoImmediateMutation{})
+}

package/linthost/rules_unicorn_no_instanceof_builtins.go

@@ -0,0 +1,66 @@
+// unicorn/no-instanceof-builtins: `x instanceof Array` (and the other
+// built-in container constructors) is broken across realms and for
+// user-defined subclasses. The cross-realm hazard is well known —
+// `Array` in an iframe is a different constructor than the host
+// `Array`, so a cross-realm value fails the check despite being an
+// array; the subclass hazard is subtler — `instanceof` walks the
+// prototype chain, so a `MyError extends Error` still passes
+// `x instanceof Error` and obscures the actual type.
+//
+// AST-only: visit each `BinaryExpression` whose operator token is
+// `instanceof`. The right-hand operand must be a bare identifier whose
+// text appears in the built-in allowlist. Property-access or computed
+// right-hand operands are out of scope because they cannot be matched
+// syntactically against the global names.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-instanceof-builtins.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoInstanceofBuiltinsNames = map[string]struct{}{
+  "Array":          {},
+  "Error":          {},
+  "EvalError":      {},
+  "RangeError":     {},
+  "ReferenceError": {},
+  "SyntaxError":    {},
+  "TypeError":      {},
+  "URIError":       {},
+  "AggregateError": {},
+  "Map":            {},
+  "Set":            {},
+  "WeakMap":        {},
+  "WeakSet":        {},
+  "Date":           {},
+  "RegExp":         {},
+  "Promise":        {},
+  "Function":       {},
+}
+
+type unicornNoInstanceofBuiltins struct{}
+
+func (unicornNoInstanceofBuiltins) Name() string { return "unicorn/no-instanceof-builtins" }
+func (unicornNoInstanceofBuiltins) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornNoInstanceofBuiltins) Check(ctx *Context, node *shimast.Node) {
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Right == nil {
+    return
+  }
+  if bin.OperatorToken.Kind != shimast.KindInstanceOfKeyword {
+    return
+  }
+  name := identifierText(bin.Right)
+  if name == "" {
+    return
+  }
+  if _, ok := unicornNoInstanceofBuiltinsNames[name]; !ok {
+    return
+  }
+  ctx.Report(node, "Don't use `instanceof <Builtin>` — it breaks across realms and for subclasses. Use a type predicate or duck-typing instead.")
+}
+
+func init() {
+  Register(unicornNoInstanceofBuiltins{})
+}

package/linthost/rules_unicorn_no_invalid_fetch_options.go

@@ -0,0 +1,79 @@
+// unicorn/no-invalid-fetch-options: passing a `body` together with a
+// `GET` or `HEAD` `fetch()` call throws at runtime because the spec
+// forbids a request body for those methods. The rule catches the
+// mismatch at parse time so the throw never reaches production.
+//
+// AST-only: visit each `CallExpression`, match when the callee is a
+// bare `fetch` identifier and the second argument is an object literal
+// containing both a string-literal `method` of `GET` / `HEAD`
+// (case-insensitive) AND a `body` property of any shape. Report on the
+// call so the diagnostic lands at the offending site.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-invalid-fetch-options.md
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornNoInvalidFetchOptions struct{}
+
+func (unicornNoInvalidFetchOptions) Name() string { return "unicorn/no-invalid-fetch-options" }
+func (unicornNoInvalidFetchOptions) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoInvalidFetchOptions) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil {
+    return
+  }
+  if identifierText(call.Expression) != "fetch" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
+    return
+  }
+  init := stripParens(call.Arguments.Nodes[1])
+  if init == nil || init.Kind != shimast.KindObjectLiteralExpression {
+    return
+  }
+  obj := init.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil {
+    return
+  }
+  hasBody := false
+  methodIsBodyless := false
+  for _, prop := range obj.Properties.Nodes {
+    if prop == nil || prop.Kind != shimast.KindPropertyAssignment {
+      continue
+    }
+    assignment := prop.AsPropertyAssignment()
+    if assignment == nil || assignment.Name() == nil {
+      continue
+    }
+    key := identifierText(assignment.Name())
+    if key == "" && assignment.Name().Kind == shimast.KindStringLiteral {
+      key = stringLiteralText(assignment.Name())
+    }
+    switch key {
+    case "body":
+      hasBody = true
+    case "method":
+      value := stripParens(assignment.Initializer)
+      if value != nil && value.Kind == shimast.KindStringLiteral {
+        m := strings.ToLower(stringLiteralText(value))
+        if m == "get" || m == "head" {
+          methodIsBodyless = true
+        }
+      }
+    }
+  }
+  if hasBody && methodIsBodyless {
+    ctx.Report(node, "Don't pass `body` with GET/HEAD `fetch` — it throws at runtime.")
+  }
+}
+
+func init() {
+  Register(unicornNoInvalidFetchOptions{})
+}

package/linthost/rules_unicorn_no_invalid_remove_event_listener.go

@@ -0,0 +1,51 @@
+// unicorn/no-invalid-remove-event-listener: passing a fresh function
+// literal to `removeEventListener` is a no-op because event-target
+// internals match listeners by reference identity. The handler that was
+// originally registered still fires; the call silently does nothing.
+//
+// AST-only: visit each `CallExpression`, match when the callee is a
+// `PropertyAccessExpression(_, removeEventListener)` and the second
+// argument (after stripping parens) is a fresh arrow function or
+// function expression. Fire on the call so the diagnostic lands at the
+// no-op site.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-invalid-remove-event-listener.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoInvalidRemoveEventListener struct{}
+
+func (unicornNoInvalidRemoveEventListener) Name() string {
+  return "unicorn/no-invalid-remove-event-listener"
+}
+func (unicornNoInvalidRemoveEventListener) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoInvalidRemoveEventListener) 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()) != "removeEventListener" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
+    return
+  }
+  handler := stripParens(call.Arguments.Nodes[1])
+  if handler == nil {
+    return
+  }
+  switch handler.Kind {
+  case shimast.KindArrowFunction, shimast.KindFunctionExpression:
+    ctx.Report(node, "Calling `removeEventListener` with a fresh function reference removes nothing — store and reuse the handler.")
+  }
+}
+
+func init() {
+  Register(unicornNoInvalidRemoveEventListener{})
+}

package/linthost/rules_unicorn_no_keyword_prefix.go

@@ -0,0 +1,101 @@
+// unicorn/no-keyword-prefix: identifiers like `newFoo` or `classBar`
+// embed a reserved word at the prefix position so the reader has to
+// re-parse the identifier each time. The rule discourages the prefix in
+// declarations so the codebase converges on names whose first segment
+// is not a JavaScript keyword.
+//
+// AST-only: visit every `Identifier` and fire only on declaration
+// positions (parameter, variable, function, class, method, accessor,
+// property, binding-element names). Reads of an already-named binding
+// are NOT flagged — the diagnostic is anchored on the declaration so
+// the rename happens once. Uses the same value-position-gate logic as
+// `prefer-global-this`, inverted: this rule needs the identifier to be
+// in a *name* slot, not a value-expression slot.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-keyword-prefix.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoKeywordPrefix struct{}
+
+func (unicornNoKeywordPrefix) Name() string { return "unicorn/no-keyword-prefix" }
+func (unicornNoKeywordPrefix) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindIdentifier}
+}
+func (unicornNoKeywordPrefix) Check(ctx *Context, node *shimast.Node) {
+  name := identifierText(node)
+  if !hasKeywordPrefix(name) {
+    return
+  }
+  if !isUnicornDeclarationPositionIdentifier(node) {
+    return
+  }
+  ctx.Report(node, "Don't prefix identifiers with a reserved word (`new` / `class`).")
+}
+
+// hasKeywordPrefix reports whether `name` starts with `new` or `class`
+// followed by an uppercase ASCII letter. The case-sensitive prefix +
+// the uppercase next letter together pin the camelCase pattern the rule
+// targets (`newFoo`, `classBar`); plain words like `news` or `classic`
+// share the prefix bytes but not the camelCase break and are out of
+// scope.
+func hasKeywordPrefix(name string) bool {
+  for _, prefix := range []string{"new", "class"} {
+    if len(name) <= len(prefix) {
+      continue
+    }
+    if name[:len(prefix)] != prefix {
+      continue
+    }
+    next := name[len(prefix)]
+    if next >= 'A' && next <= 'Z' {
+      return true
+    }
+  }
+  return false
+}
+
+// isUnicornDeclarationPositionIdentifier reports whether `node` (a bare
+// Identifier) appears as a *name* slot of a declaration, i.e. the slot
+// reserved by the language for introducing a new binding. Reads,
+// property keys on accesses, type references, and labels are filtered
+// out so the rule only fires on declarations.
+func isUnicornDeclarationPositionIdentifier(node *shimast.Node) bool {
+  if node == nil || node.Kind != shimast.KindIdentifier || node.Parent == nil {
+    return false
+  }
+  parent := node.Parent
+  switch parent.Kind {
+  case shimast.KindVariableDeclaration:
+    decl := parent.AsVariableDeclaration()
+    return decl != nil && decl.Name() == node
+  case shimast.KindBindingElement:
+    elem := parent.AsBindingElement()
+    return elem != nil && elem.Name() == node
+  case shimast.KindParameter:
+    param := parent.AsParameterDeclaration()
+    return param != nil && param.Name() == node
+  case shimast.KindFunctionDeclaration:
+    fn := parent.AsFunctionDeclaration()
+    return fn != nil && fn.Name() == node
+  case shimast.KindFunctionExpression:
+    fn := parent.AsFunctionExpression()
+    return fn != nil && fn.Name() == node
+  case shimast.KindClassDeclaration:
+    cls := parent.AsClassDeclaration()
+    return cls != nil && cls.Name() == node
+  case shimast.KindClassExpression:
+    cls := parent.AsClassExpression()
+    return cls != nil && cls.Name() == node
+  case shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+    shimast.KindPropertyDeclaration:
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(unicornNoKeywordPrefix{})
+}

package/linthost/rules_unicorn_no_lonely_if.go

@@ -0,0 +1,44 @@
+// unicorn/no-lonely-if: `else { if (cond) { … } }` collapses to
+// `else if (cond) { … }`. Wrapping a single `if` in an `else` block
+// adds an extra brace pair and an extra indentation level without
+// changing semantics, so the rule flags it as redundant punctuation.
+//
+// AST-only and parent-walking: visit every `IfStatement`, then check
+// whether its parent is a `Block` containing exactly this one
+// statement AND that block is the `ElseStatement` of an outer
+// `IfStatement`. Mirrors the core `no-lonely-if` rule shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-lonely-if.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoLonelyIf struct{}
+
+func (unicornNoLonelyIf) Name() string           { return "unicorn/no-lonely-if" }
+func (unicornNoLonelyIf) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindIfStatement} }
+func (unicornNoLonelyIf) Check(ctx *Context, node *shimast.Node) {
+  parent := node.Parent
+  if parent == nil || parent.Kind != shimast.KindBlock {
+    return
+  }
+  block := parent.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  if len(block.Statements.Nodes) != 1 {
+    return
+  }
+  grand := parent.Parent
+  if grand == nil || grand.Kind != shimast.KindIfStatement {
+    return
+  }
+  gif := grand.AsIfStatement()
+  if gif == nil || gif.ElseStatement != parent {
+    return
+  }
+  ctx.Report(node, "Use `else if` instead of an `if` as the only statement inside an `else` block.")
+}
+
+func init() {
+  Register(unicornNoLonelyIf{})
+}