@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_no_magic_array_flat_depth.go

@@ -0,0 +1,51 @@
+// unicorn/no-magic-array-flat-depth: `Array#flat(depth)` accepts a numeric
+// argument that controls how many nested levels are flattened. Magic
+// numbers like `.flat(2)` or `.flat(3)` make the call hard to scan —
+// readers must mentally model the input shape to decide whether the
+// depth is correct. The rule allows `1` (the default depth, common
+// enough to read at a glance) and `Infinity` (an explicit named value)
+// but flags every other numeric literal so authors switch to either
+// `Infinity` or a named constant.
+//
+// AST-only: dispatch on `KindCallExpression`, require a property-access
+// callee whose method identifier is `flat`, exactly one argument, and
+// that argument to be `KindNumericLiteral` with text other than "1".
+// `Infinity` is parsed as an Identifier, not a NumericLiteral, so the
+// kind check alone exempts it without a separate value branch.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-magic-array-flat-depth.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoMagicArrayFlatDepth struct{}
+
+func (unicornNoMagicArrayFlatDepth) Name() string { return "unicorn/no-magic-array-flat-depth" }
+func (unicornNoMagicArrayFlatDepth) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoMagicArrayFlatDepth) 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()) != "flat" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  if numericLiteralText(arg) == "1" {
+    return
+  }
+  ctx.Report(node, "Don't use a magic-number depth in `Array#flat()` — use `Infinity` or a named constant.")
+}
+
+func init() {
+  Register(unicornNoMagicArrayFlatDepth{})
+}

package/linthost/rules_unicorn_no_named_default.go

@@ -0,0 +1,54 @@
+// unicorn/no-named-default: a named-import specifier that re-aliases the
+// module's default export (`import { default as Foo } from "mod"`) does
+// the same job as the dedicated default-import form `import Foo from "mod"`
+// but obscures the intent — reviewers reading the named-import list have
+// to notice the `default as` prefix to realize the binding is the
+// module's default, not a named export named "default". The rule flags
+// every such specifier so authors use the default-import syntax instead.
+//
+// AST-only: dispatch on `KindImportDeclaration`, descend through the
+// import clause's NamedImports list, and fire on each specifier whose
+// `PropertyName` is an identifier named "default". The default-import
+// case (`clause.Name()`) and namespace imports (`* as`) are not
+// affected; the property-name check matches both `import { default as X }`
+// and the deprecated string form `import { "default" as X }`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-named-default.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNamedDefault struct{}
+
+func (unicornNoNamedDefault) Name() string { return "unicorn/no-named-default" }
+func (unicornNoNamedDefault) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindImportDeclaration}
+}
+func (unicornNoNamedDefault) Check(ctx *Context, node *shimast.Node) {
+  decl := node.AsImportDeclaration()
+  if decl == nil || decl.ImportClause == nil {
+    return
+  }
+  clause := decl.ImportClause.AsImportClause()
+  if clause == nil || clause.NamedBindings == nil ||
+    clause.NamedBindings.Kind != shimast.KindNamedImports {
+    return
+  }
+  named := clause.NamedBindings.AsNamedImports()
+  if named == nil || named.Elements == nil {
+    return
+  }
+  for _, spec := range named.Elements.Nodes {
+    s := spec.AsImportSpecifier()
+    if s == nil || s.PropertyName == nil {
+      continue
+    }
+    if moduleExportNameText(s.PropertyName) != "default" {
+      continue
+    }
+    ctx.Report(spec, "Don't import a default export under a named alias — use `import X from \"...\"` instead.")
+  }
+}
+
+func init() {
+  Register(unicornNoNamedDefault{})
+}

package/linthost/rules_unicorn_no_negated_condition.go

@@ -0,0 +1,85 @@
+// unicorn/no-negated-condition: a negated condition with an `else`
+// branch forces the reader to mentally invert the test before they can
+// pair branches with outcomes. Swapping the two branches and dropping
+// the negation reads in source order. The rule fires on `if` / `else`
+// pairs and on ternaries where both branches are present.
+//
+// AST-only: visit `KindIfStatement` and `KindConditionalExpression`.
+// Match when the condition (after `stripParens`) is either a `!`
+// prefix-unary expression or a `!=` / `!==` binary expression AND the
+// other branch is also present. Fire on the if / ternary node.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-negated-condition.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNegatedCondition struct{}
+
+func (unicornNoNegatedCondition) Name() string { return "unicorn/no-negated-condition" }
+func (unicornNoNegatedCondition) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindIfStatement, shimast.KindConditionalExpression}
+}
+func (unicornNoNegatedCondition) Check(ctx *Context, node *shimast.Node) {
+  var condition *shimast.Node
+  switch node.Kind {
+  case shimast.KindIfStatement:
+    stmt := node.AsIfStatement()
+    if stmt == nil || stmt.ElseStatement == nil {
+      return
+    }
+    // An `else if` chain (else is itself an IfStatement) reads
+    // fine after inversion only when the else has its own else;
+    // otherwise inverting reshapes the chain. Keep the rule
+    // conservative and only fire when else is a Block.
+    if stmt.ElseStatement.Kind == shimast.KindIfStatement {
+      return
+    }
+    condition = stmt.Expression
+  case shimast.KindConditionalExpression:
+    cond := node.AsConditionalExpression()
+    if cond == nil || cond.WhenTrue == nil || cond.WhenFalse == nil {
+      return
+    }
+    condition = cond.Condition
+  }
+  if condition == nil {
+    return
+  }
+  condition = stripParens(condition)
+  if condition == nil {
+    return
+  }
+  if !unicornNoNegatedConditionIsNegated(condition) {
+    return
+  }
+  ctx.Report(node, "Avoid negated conditions in `if` / `else` and ternaries when the positive form is shorter.")
+}
+
+// unicornNoNegatedConditionIsNegated reports whether `node` is a `!`
+// prefix-unary expression or a `!=` / `!==` binary expression — the
+// two shapes the rule treats as "negated".
+func unicornNoNegatedConditionIsNegated(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindPrefixUnaryExpression:
+    prefix := node.AsPrefixUnaryExpression()
+    return prefix != nil && prefix.Operator == shimast.KindExclamationToken
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return false
+    }
+    switch bin.OperatorToken.Kind {
+    case shimast.KindExclamationEqualsToken,
+      shimast.KindExclamationEqualsEqualsToken:
+      return true
+    }
+  }
+  return false
+}
+
+func init() {
+  Register(unicornNoNegatedCondition{})
+}

package/linthost/rules_unicorn_no_negation_in_equality_check.go

@@ -0,0 +1,50 @@
+// unicorn/no-negation-in-equality-check: `!a === b` parses as
+// `(!a) === b`, comparing the *boolean* `!a` against `b`. Readers
+// almost always expect `!(a === b)` instead, so the rule rejects the
+// `!a === b` / `!a !== b` shape and asks the author to either switch
+// the comparison operator (`a !== b`) or wrap the negation in parens.
+//
+// AST-only: visit each `BinaryExpression`, match the operator against
+// the four equality tokens, and check whether the LEFT operand is a
+// `!` prefix-unary expression. Parens are the documented escape hatch
+// (`(!a) === b`), so the check does NOT strip them. Fire on the binary
+// expression so the report covers the full ambiguous shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-negation-in-equality-check.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNegationInEqualityCheck struct{}
+
+func (unicornNoNegationInEqualityCheck) Name() string {
+  return "unicorn/no-negation-in-equality-check"
+}
+func (unicornNoNegationInEqualityCheck) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornNoNegationInEqualityCheck) Check(ctx *Context, node *shimast.Node) {
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindEqualsEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken:
+  default:
+    return
+  }
+  if bin.Left.Kind != shimast.KindPrefixUnaryExpression {
+    return
+  }
+  prefix := bin.Left.AsPrefixUnaryExpression()
+  if prefix == nil || prefix.Operator != shimast.KindExclamationToken {
+    return
+  }
+  ctx.Report(node, "Don't negate the left operand of an equality check — use `!==` directly, or wrap in parens.")
+}
+
+func init() {
+  Register(unicornNoNegationInEqualityCheck{})
+}

package/linthost/rules_unicorn_no_nested_ternary.go

@@ -0,0 +1,43 @@
+// unicorn/no-nested-ternary: `a ? b : c ? d : e` packs two decision
+// points into one expression and forces the reader to track operator
+// precedence to know which branch each value belongs to. Unlike the
+// core ESLint rule of the same name, the unicorn variant fires on every
+// nested level rather than only the outermost — each inner conditional
+// is its own offense and is reported in place.
+//
+// AST-only: visit every `ConditionalExpression` and report on it when
+// its parent is also a `ConditionalExpression`. `stripParens` makes the
+// match insensitive to grouping parens.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-nested-ternary.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNestedTernary struct{}
+
+func (unicornNoNestedTernary) Name() string { return "unicorn/no-nested-ternary" }
+func (unicornNoNestedTernary) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindConditionalExpression}
+}
+func (unicornNoNestedTernary) Check(ctx *Context, node *shimast.Node) {
+  cond := node.AsConditionalExpression()
+  if cond == nil {
+    return
+  }
+  if hasUnicornNestedConditional(cond.WhenTrue) {
+    ctx.Report(stripParens(cond.WhenTrue), "Do not nest ternary expressions.")
+    return
+  }
+  if hasUnicornNestedConditional(cond.WhenFalse) {
+    ctx.Report(stripParens(cond.WhenFalse), "Do not nest ternary expressions.")
+  }
+}
+
+func hasUnicornNestedConditional(node *shimast.Node) bool {
+  expr := stripParens(node)
+  return expr != nil && expr.Kind == shimast.KindConditionalExpression
+}
+
+func init() {
+  Register(unicornNoNestedTernary{})
+}

package/linthost/rules_unicorn_no_new_array.go

@@ -0,0 +1,30 @@
+// unicorn/no-new-array: `new Array(n)` is a sharp edge — with a single
+// numeric argument it allocates a sparse array of length `n`, with
+// anything else it constructs from the arguments. The two readings
+// share one syntax, so the same expression silently switches meaning
+// when its input shape changes. The replacement is an array literal,
+// `Array.from`, or `Array.of`.
+//
+// AST-only and identifier-text-driven: any `NewExpression` whose callee
+// is an `Identifier` named `Array` fires. Shadowed `Array` bindings,
+// argument count, and argument types are not part of the match,
+// mirroring `unicorn/no-new-buffer`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-new-array.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNewArray struct{}
+
+func (unicornNoNewArray) Name() string           { return "unicorn/no-new-array" }
+func (unicornNoNewArray) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNewExpression} }
+func (unicornNoNewArray) Check(ctx *Context, node *shimast.Node) {
+  ne := node.AsNewExpression()
+  if ne != nil && identifierText(ne.Expression) == "Array" {
+    ctx.Report(node, "Don't use `new Array(...)` — use an array literal or `Array.from`/`Array.of` instead.")
+  }
+}
+
+func init() {
+  Register(unicornNoNewArray{})
+}

package/linthost/rules_unicorn_no_new_buffer.go

@@ -0,0 +1,31 @@
+// unicorn/no-new-buffer: the `new Buffer(...)` constructor was deprecated
+// in Node because its overloads route on argument type at runtime — an
+// integer allocates uninitialized memory, a string decodes bytes, an array
+// copies them — so the same call site silently changes meaning when its
+// input shape changes. The replacement is the explicit `Buffer.from()` /
+// `Buffer.alloc()` pair.
+//
+// AST-only and identifier-text-driven: the rule fires on any `NewExpression`
+// whose callee is an `Identifier` named `Buffer`. Shadowed `Buffer`
+// bindings and import sources are out of scope; argument count and shape
+// are not part of the match, so `new Buffer(10)`, `new Buffer("ascii")`,
+// and `new Buffer([])` all report.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-new-buffer.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNewBuffer struct{}
+
+func (unicornNoNewBuffer) Name() string           { return "unicorn/no-new-buffer" }
+func (unicornNoNewBuffer) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNewExpression} }
+func (unicornNoNewBuffer) Check(ctx *Context, node *shimast.Node) {
+  ne := node.AsNewExpression()
+  if ne != nil && identifierText(ne.Expression) == "Buffer" {
+    ctx.Report(node, "`new Buffer()` is deprecated, use `Buffer.from()` or `Buffer.alloc()` instead.")
+  }
+}
+
+func init() {
+  Register(unicornNoNewBuffer{})
+}

package/linthost/rules_unicorn_no_null.go

@@ -0,0 +1,24 @@
+// unicorn/no-null: the bare `null` literal is treated as a code smell —
+// the rule's policy is that `undefined` is the single absent-value token
+// in user code. Every occurrence of the keyword anywhere in the source is
+// flagged so the codebase converges on one convention.
+//
+// AST-only: the engine dispatches once per `NullKeyword` node and the
+// rule reports unconditionally on that node. There is no fixer in this
+// pass — the diagnostic alone is the contract.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-null.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNull struct{}
+
+func (unicornNoNull) Name() string           { return "unicorn/no-null" }
+func (unicornNoNull) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNullKeyword} }
+func (unicornNoNull) Check(ctx *Context, node *shimast.Node) {
+  ctx.Report(node, "Use `undefined` instead of `null`.")
+}
+
+func init() {
+  Register(unicornNoNull{})
+}

package/linthost/rules_unicorn_no_object_as_default_parameter.go

@@ -0,0 +1,48 @@
+// unicorn/no-object-as-default-parameter: writing
+// `function f(opts = { tag: "x" })` ships a hidden default object that
+// is hard to override granularly — callers either supply the whole
+// object or get every default at once, and the option keys are
+// invisible at the call site. Destructuring with per-key defaults
+// (`function f({ tag = "x" } = {})`) is the canonical replacement.
+//
+// AST-only: dispatch on `ParameterDeclaration`. Fire when the parameter
+// has a non-empty object-literal initializer and the parameter name
+// itself is a bare identifier (already-destructured parameters are
+// covered by the destructuring form the rule recommends). Empty
+// objects `param = {}` are out of scope — that pattern is a different
+// rule.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-object-as-default-parameter.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoObjectAsDefaultParameter struct{}
+
+func (unicornNoObjectAsDefaultParameter) Name() string {
+  return "unicorn/no-object-as-default-parameter"
+}
+func (unicornNoObjectAsDefaultParameter) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindParameter}
+}
+func (unicornNoObjectAsDefaultParameter) Check(ctx *Context, node *shimast.Node) {
+  param := node.AsParameterDeclaration()
+  if param == nil || param.Initializer == nil || param.Name() == nil {
+    return
+  }
+  if param.Name().Kind != shimast.KindIdentifier {
+    return
+  }
+  init := stripParens(param.Initializer)
+  if init == nil || init.Kind != shimast.KindObjectLiteralExpression {
+    return
+  }
+  obj := init.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) == 0 {
+    return
+  }
+  ctx.Report(node, "Don't use an object literal as a default parameter — destructure the option instead.")
+}
+
+func init() {
+  Register(unicornNoObjectAsDefaultParameter{})
+}

package/linthost/rules_unicorn_no_process_exit.go

@@ -0,0 +1,43 @@
+// unicorn/no-process-exit: calling `process.exit(...)` short-circuits the
+// Node runtime before pending I/O, timers, or microtasks drain, which
+// turns ordinary error paths into silent data loss. The rule pushes
+// authors toward throwing or returning a non-zero status so the host
+// process owns the termination decision.
+//
+// AST-only first pass: a `CallExpression` whose callee is a
+// `PropertyAccessExpression` of the literal form `process.exit` fires.
+// Computed access (`process["exit"]`), optional chaining
+// (`process?.exit()`), and shadowed `process` bindings are intentionally
+// out of scope — only the bare callsite is reported.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-process-exit.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoProcessExit struct{}
+
+func (unicornNoProcessExit) Name() string { return "unicorn/no-process-exit" }
+func (unicornNoProcessExit) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoProcessExit) 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
+  }
+  if identifierText(access.Expression) != "process" {
+    return
+  }
+  if identifierText(access.Name()) != "exit" {
+    return
+  }
+  ctx.Report(node, "Don't use `process.exit()`. Throw an error or return a non-zero status instead.")
+}
+
+func init() {
+  Register(unicornNoProcessExit{})
+}

package/linthost/rules_unicorn_no_single_promise_in_promise_methods.go

@@ -0,0 +1,59 @@
+// unicorn/no-single-promise-in-promise-methods:
+// `Promise.all([single])`, `Promise.allSettled([single])`,
+// `Promise.race([single])`, and `Promise.any([single])` are redundant
+// wrappers — the result is just `single` (or a one-element array
+// wrapping its resolution, which the caller can produce trivially).
+// The wrapper hides the fact that there is only one promise in flight
+// and forces an extra allocation for no behavioral difference.
+//
+// AST-only and identifier-text-driven: dispatch on `CallExpression`,
+// match a `Promise.<method>` callee against the four collection
+// methods, and require exactly one argument whose stripped form is an
+// `ArrayLiteralExpression` with exactly one element. Shadowed
+// `Promise` bindings are out of scope; the syntactic shape is the
+// signal.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-single-promise-in-promise-methods.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoSinglePromiseInPromiseMethods struct{}
+
+func (unicornNoSinglePromiseInPromiseMethods) Name() string {
+  return "unicorn/no-single-promise-in-promise-methods"
+}
+func (unicornNoSinglePromiseInPromiseMethods) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoSinglePromiseInPromiseMethods) 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.Expression) != "Promise" {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "all", "allSettled", "race", "any":
+  default:
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  arr := arg.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
+    return
+  }
+  ctx.Report(node, "Don't wrap a single promise in `Promise.<method>([...])` — the wrapper is redundant.")
+}
+
+func init() {
+  Register(unicornNoSinglePromiseInPromiseMethods{})
+}

package/linthost/rules_unicorn_no_static_only_class.go

@@ -0,0 +1,56 @@
+// unicorn/no-static-only-class: a class whose every member is `static`
+// is a namespace dressed up as a class. The `class` keyword introduces
+// a constructor, a prototype chain, and `new`-able semantics that the
+// static-only form never uses. A plain object literal or a module
+// namespace is the more honest shape.
+//
+// AST-only: visit both `ClassDeclaration` and `ClassExpression`. The
+// rule requires at least one member (empty classes are handled by a
+// separate rule) and every member must be a method, property, getter,
+// or setter declaration with the `static` modifier. Constructors,
+// index signatures, and any non-static member disqualify the class.
+// Classes with heritage clauses (`extends`, `implements`) are also
+// skipped — the inheritance IS the reason the class exists, so it
+// can't be replaced by a plain object.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-static-only-class.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoStaticOnlyClass struct{}
+
+func (unicornNoStaticOnlyClass) Name() string { return "unicorn/no-static-only-class" }
+func (unicornNoStaticOnlyClass) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
+}
+func (unicornNoStaticOnlyClass) Check(ctx *Context, node *shimast.Node) {
+  if classHasHeritage(node) {
+    return
+  }
+  members := classMembers(node)
+  if len(members) == 0 {
+    // Empty classes are out of scope — separate rule territory.
+    return
+  }
+  for _, member := range members {
+    if member == nil {
+      return
+    }
+    switch member.Kind {
+    case shimast.KindMethodDeclaration,
+      shimast.KindPropertyDeclaration,
+      shimast.KindGetAccessor,
+      shimast.KindSetAccessor:
+      if !hasModifier(member, shimast.KindStaticKeyword) {
+        return
+      }
+    default:
+      return
+    }
+  }
+  ctx.Report(node, "A class with only static members can be replaced by a plain object or module namespace.")
+}
+
+func init() {
+  Register(unicornNoStaticOnlyClass{})
+}

package/linthost/rules_unicorn_no_thenable.go

@@ -0,0 +1,74 @@
+// unicorn/no-thenable: an object that exposes a callable `then` property
+// becomes accidentally thenable — the runtime's `Promise.resolve(value)`
+// pipeline treats every such value as a promise, so awaiting it invokes
+// the user's `then` instead of resolving to the object itself. This is a
+// common source of surprises in plain data objects and class shapes that
+// were never intended as promises.
+//
+// AST-only: dispatch on every property-defining node form (data
+// property, method, shorthand property, getter, setter) and fire when
+// the name node is an Identifier `then` or a StringLiteral `"then"`.
+// `moduleExportNameText` already returns the right textual value for
+// both shapes; computed names and other syntactic forms are skipped.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-thenable.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoThenable struct{}
+
+func (unicornNoThenable) Name() string { return "unicorn/no-thenable" }
+func (unicornNoThenable) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindPropertyAssignment,
+    shimast.KindMethodDeclaration,
+    shimast.KindShorthandPropertyAssignment,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+  }
+}
+func (unicornNoThenable) Check(ctx *Context, node *shimast.Node) {
+  var name *shimast.Node
+  switch node.Kind {
+  case shimast.KindPropertyAssignment:
+    if a := node.AsPropertyAssignment(); a != nil {
+      name = a.Name()
+    }
+  case shimast.KindMethodDeclaration:
+    if m := node.AsMethodDeclaration(); m != nil {
+      name = m.Name()
+    }
+  case shimast.KindShorthandPropertyAssignment:
+    if s := node.AsShorthandPropertyAssignment(); s != nil {
+      name = s.Name()
+    }
+  case shimast.KindGetAccessor:
+    if g := node.AsGetAccessorDeclaration(); g != nil {
+      name = g.Name()
+    }
+  case shimast.KindSetAccessor:
+    if s := node.AsSetAccessorDeclaration(); s != nil {
+      name = s.Name()
+    }
+  }
+  if name == nil {
+    return
+  }
+  switch name.Kind {
+  case shimast.KindIdentifier:
+    if identifierText(name) != "then" {
+      return
+    }
+  case shimast.KindStringLiteral:
+    if stringLiteralText(name) != "then" {
+      return
+    }
+  default:
+    return
+  }
+  ctx.Report(node, "Don't define a property named `then` — it makes the object accidentally thenable.")
+}
+
+func init() {
+  Register(unicornNoThenable{})
+}