@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_no_accessor_recursion.go

@@ -0,0 +1,115 @@
+// unicorn/no-accessor-recursion: a `get value()` that reads
+// `this.value` triggers itself — the getter is the only thing that
+// resolves `this.value`, so the call recurses until the stack runs
+// out. The same holds for setters, computed and string-keyed names,
+// and class / object-literal accessors. The rule pins every read of
+// `this.<X>` inside the `<X>` accessor as a recursion bug.
+//
+// AST-only: visit both `KindGetAccessor` and `KindSetAccessor`. Take
+// the accessor's own name and walk its body, reporting every
+// `KindPropertyAccessExpression(KindThisKeyword, <name>)` that
+// matches. The walk does NOT descend into nested non-arrow function
+// bodies (`FunctionDeclaration`, `FunctionExpression`,
+// `MethodDeclaration`, `GetAccessor`, `SetAccessor`,
+// `Constructor`), because those rebind `this`. Arrow functions
+// preserve the outer `this` and are walked through.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-accessor-recursion.md
+package linthost
+
+import (
+  "fmt"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornNoAccessorRecursion struct{}
+
+func (unicornNoAccessorRecursion) Name() string { return "unicorn/no-accessor-recursion" }
+func (unicornNoAccessorRecursion) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindGetAccessor, shimast.KindSetAccessor}
+}
+func (unicornNoAccessorRecursion) Check(ctx *Context, node *shimast.Node) {
+  name := unicornAccessorRecursionName(node)
+  if name == "" {
+    return
+  }
+  body := node.Body()
+  if body == nil {
+    return
+  }
+  unicornAccessorRecursionWalkRespectingThisBoundary(body, func(child *shimast.Node) {
+    if child == nil || child.Kind != shimast.KindPropertyAccessExpression {
+      return
+    }
+    access := child.AsPropertyAccessExpression()
+    if access == nil || access.Expression == nil {
+      return
+    }
+    if access.Expression.Kind != shimast.KindThisKeyword {
+      return
+    }
+    if identifierText(access.Name()) != name {
+      return
+    }
+    ctx.Report(child, fmt.Sprintf("Reading `this.%s` inside the `%s` accessor recurses forever.", name, name))
+  })
+}
+
+// unicornAccessorRecursionWalkRespectingThisBoundary walks `node` and
+// its descendants depth-first, but does not descend into bodies that
+// rebind `this`. Arrow functions are walked through because they
+// capture the outer `this`.
+func unicornAccessorRecursionWalkRespectingThisBoundary(node *shimast.Node, visit func(*shimast.Node)) {
+  if node == nil {
+    return
+  }
+  visit(node)
+  node.ForEachChild(func(child *shimast.Node) bool {
+    if child == nil {
+      return false
+    }
+    switch child.Kind {
+    case shimast.KindFunctionDeclaration,
+      shimast.KindFunctionExpression,
+      shimast.KindMethodDeclaration,
+      shimast.KindGetAccessor,
+      shimast.KindSetAccessor,
+      shimast.KindConstructor:
+      return false
+    }
+    unicornAccessorRecursionWalkRespectingThisBoundary(child, visit)
+    return false
+  })
+}
+
+// unicornAccessorRecursionName returns the property name of a
+// get/set accessor declaration. Only bare Identifier and StringLiteral
+// names are supported because computed names cannot be matched against
+// the `this.<X>` shape statically.
+func unicornAccessorRecursionName(node *shimast.Node) string {
+  var name *shimast.Node
+  switch node.Kind {
+  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:
+    return identifierText(name)
+  case shimast.KindStringLiteral:
+    return stringLiteralText(name)
+  }
+  return ""
+}
+
+func init() {
+  Register(unicornNoAccessorRecursion{})
+}

package/linthost/rules_unicorn_no_anonymous_default_export.go

@@ -0,0 +1,74 @@
+// unicorn/no-anonymous-default-export: `export default function () {}`
+// and `export default class {}` (and the arrow-function equivalent)
+// leave the exported value without a local binding name. Stack traces,
+// dev-tools labels, and downstream `import X from …` all rebind to the
+// importer's chosen name, so the export site contributes nothing to
+// readability. Giving the function/class a name keeps the original
+// identifier visible everywhere.
+//
+// AST-only: TypeScript-Go's parser splits the two surface forms of
+// `export default`. `export default <expression>` parses as
+// `KindExportAssignment`; `export default function …` / `export default
+// class …` parse as `KindFunctionDeclaration` / `KindClassDeclaration`
+// with `export` + `default` modifiers and an optional `Name()`. The
+// rule covers both paths: it reports an `ExportAssignment` whose
+// expression is a `KindFunctionExpression`/`KindArrowFunction`/
+// `KindClassExpression` with no name, and reports an export-default
+// `Function`/`ClassDeclaration` whose `Name()` is nil.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-anonymous-default-export.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoAnonymousDefaultExport struct{}
+
+func (unicornNoAnonymousDefaultExport) Name() string {
+  return "unicorn/no-anonymous-default-export"
+}
+func (unicornNoAnonymousDefaultExport) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindExportAssignment,
+    shimast.KindFunctionDeclaration,
+    shimast.KindClassDeclaration,
+  }
+}
+func (unicornNoAnonymousDefaultExport) Check(ctx *Context, node *shimast.Node) {
+  switch node.Kind {
+  case shimast.KindExportAssignment:
+    assign := node.AsExportAssignment()
+    if assign == nil || assign.IsExportEquals || assign.Expression == nil {
+      return
+    }
+    expr := stripParens(assign.Expression)
+    if expr == nil {
+      return
+    }
+    switch expr.Kind {
+    case shimast.KindFunctionExpression:
+      if fn := expr.AsFunctionExpression(); fn != nil && fn.Name() == nil {
+        ctx.Report(node, "Give a name to the default export.")
+      }
+    case shimast.KindArrowFunction:
+      // Arrow functions never bind a name; an `export default` of
+      // one is always anonymous.
+      ctx.Report(node, "Give a name to the default export.")
+    case shimast.KindClassExpression:
+      if cls := expr.AsClassExpression(); cls != nil && cls.Name() == nil {
+        ctx.Report(node, "Give a name to the default export.")
+      }
+    }
+  case shimast.KindFunctionDeclaration, shimast.KindClassDeclaration:
+    if !hasModifier(node, shimast.KindExportKeyword) ||
+      !hasModifier(node, shimast.KindDefaultKeyword) {
+      return
+    }
+    if node.Name() == nil {
+      ctx.Report(node, "Give a name to the default export.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornNoAnonymousDefaultExport{})
+}

package/linthost/rules_unicorn_no_array_callback_reference.go

@@ -0,0 +1,65 @@
+// unicorn/no-array-callback-reference: passing a function reference
+// directly to an `Array#…` iteration method silently exposes it to
+// extra positional arguments. `[1,2,3].filter(isEven)` passes `isEven`
+// the index and the source array as well as the element, which is fine
+// for `isEven` but breaks the moment the predicate's signature grows
+// optional parameters. Wrapping in an arrow that takes just the value
+// pins the call shape locally.
+//
+// AST-only: each visited `CallExpression` is matched against a
+// property-access callee whose method name is one of the iteration
+// methods, and the first argument is checked for the bare-identifier
+// shape. Anything more elaborate (member access, arrow, call result)
+// has already named the call shape explicitly and is out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-callback-reference.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoArrayCallbackReferenceMethods = map[string]struct{}{
+  "every":         {},
+  "filter":        {},
+  "find":          {},
+  "findIndex":     {},
+  "findLast":      {},
+  "findLastIndex": {},
+  "flatMap":       {},
+  "forEach":       {},
+  "map":           {},
+  "some":          {},
+}
+
+type unicornNoArrayCallbackReference struct{}
+
+func (unicornNoArrayCallbackReference) Name() string {
+  return "unicorn/no-array-callback-reference"
+}
+func (unicornNoArrayCallbackReference) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayCallbackReference) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  method := identifierText(access.Name())
+  if _, ok := unicornNoArrayCallbackReferenceMethods[method]; !ok {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return
+  }
+  first := call.Arguments.Nodes[0]
+  if first == nil || first.Kind != shimast.KindIdentifier {
+    return
+  }
+  ctx.Report(first, "Don't pass a function reference directly to `Array#"+method+"` — wrap it in an arrow that takes only the value.")
+}
+
+func init() {
+  Register(unicornNoArrayCallbackReference{})
+}

package/linthost/rules_unicorn_no_array_for_each.go

@@ -0,0 +1,40 @@
+// unicorn/no-array-for-each: `Array#forEach` is harder to short-circuit and
+// to reason about than a `for…of` loop — `break`/`continue`/`return` from
+// the loop body all become per-iteration callback returns with different
+// semantics, and async/await inside the callback silently no-ops because
+// the iteration callback is not awaited.
+//
+// AST-only: dispatch on each `CallExpression`, look for a property-access
+// callee whose method identifier is `forEach`, and fire on the call. The
+// receiver expression is not type-checked — the syntactic shape is the
+// signal the rule wants to discourage, regardless of whether the value is
+// known to be an array at the type level.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-for-each.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoArrayForEach struct{}
+
+func (unicornNoArrayForEach) Name() string { return "unicorn/no-array-for-each" }
+func (unicornNoArrayForEach) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayForEach) 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.Name()) != "forEach" {
+    return
+  }
+  ctx.Report(node, "Use `for…of` instead of `.forEach(…)`.")
+}
+
+func init() {
+  Register(unicornNoArrayForEach{})
+}

package/linthost/rules_unicorn_no_array_method_this_argument.go

@@ -0,0 +1,61 @@
+// unicorn/no-array-method-this-argument: the iteration methods on
+// `Array.prototype` accept an optional `thisArg` after the callback. The
+// runtime binds that `thisArg` only for non-arrow callbacks — arrow
+// callbacks ignore it entirely — so the second argument's behavior
+// depends on the callable shape of the first. Replacing it with a closure
+// that captures the intended value makes the binding unambiguous and
+// arrow-safe.
+//
+// AST-only: visit each `CallExpression`, match a property-access callee
+// whose method identifier is one of the Array.prototype iteration methods
+// that accept a thisArg, and fire when the call has exactly two
+// arguments. One argument is the canonical no-thisArg shape; three or
+// more means a different callsite signature and is out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-method-this-argument.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoArrayMethodThisArgumentMethods = map[string]struct{}{
+  "every":         {},
+  "filter":        {},
+  "find":          {},
+  "findIndex":     {},
+  "findLast":      {},
+  "findLastIndex": {},
+  "flatMap":       {},
+  "forEach":       {},
+  "map":           {},
+  "some":          {},
+}
+
+type unicornNoArrayMethodThisArgument struct{}
+
+func (unicornNoArrayMethodThisArgument) Name() string {
+  return "unicorn/no-array-method-this-argument"
+}
+func (unicornNoArrayMethodThisArgument) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayMethodThisArgument) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  method := identifierText(access.Name())
+  if _, ok := unicornNoArrayMethodThisArgumentMethods[method]; !ok {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+    return
+  }
+  ctx.Report(node, "Don't use `thisArg` on `Array#"+method+"` — use an explicit closure that captures the value instead.")
+}
+
+func init() {
+  Register(unicornNoArrayMethodThisArgument{})
+}

package/linthost/rules_unicorn_no_array_reduce.go

@@ -0,0 +1,41 @@
+// unicorn/no-array-reduce: `Array#reduce` and `Array#reduceRight` collapse
+// an iteration into a single callback that has to encode both the
+// accumulator state and the per-element step, which routinely produces
+// less-readable code than an explicit loop. The rule pushes authors
+// toward `for…of` (or a typed accumulator initialized outside the loop)
+// so the state and the step live on separate lines.
+//
+// AST-only: visit each `CallExpression`, check that the callee is a
+// property access whose method identifier is `reduce` or `reduceRight`,
+// and fire on the call. The receiver expression is not type-checked —
+// the syntactic shape is the signal the rule wants to discourage.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-reduce.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoArrayReduce struct{}
+
+func (unicornNoArrayReduce) Name() string { return "unicorn/no-array-reduce" }
+func (unicornNoArrayReduce) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayReduce) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  method := identifierText(access.Name())
+  if method != "reduce" && method != "reduceRight" {
+    return
+  }
+  ctx.Report(node, "Avoid `Array#"+method+"()` — use an explicit loop or `for…of` instead.")
+}
+
+func init() {
+  Register(unicornNoArrayReduce{})
+}

package/linthost/rules_unicorn_no_array_reverse.go

@@ -0,0 +1,44 @@
+// unicorn/no-array-reverse: `Array#reverse()` mutates the array in place
+// and also returns the same reference, which lets aliasing bugs slip into
+// otherwise-pure pipelines (`const out = input.reverse()` rewrites
+// `input` too). ES2023 ships `Array#toReversed()`, which produces a new
+// array and leaves the source untouched, so the rule pushes authors
+// toward the non-mutating form.
+//
+// AST-only: visit each `CallExpression`, check that the callee is a
+// property access whose method identifier is `reverse`, and require zero
+// arguments — `reverse` accepts none, so a non-empty argument list is
+// almost certainly a different `reverse` on a user-defined type and is
+// excluded by design.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-reverse.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoArrayReverse struct{}
+
+func (unicornNoArrayReverse) Name() string { return "unicorn/no-array-reverse" }
+func (unicornNoArrayReverse) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArrayReverse) 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.Name()) != "reverse" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) != 0 {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#toReversed()` over the mutating `Array#reverse()`.")
+}
+
+func init() {
+  Register(unicornNoArrayReverse{})
+}

package/linthost/rules_unicorn_no_array_sort.go

@@ -0,0 +1,43 @@
+// unicorn/no-array-sort: `Array#sort()` mutates the array in place and
+// returns the same reference, so any caller holding the original sees
+// the sorted order too. ES2023 introduced `Array#toSorted()`, which
+// returns a fresh sorted copy and leaves the source untouched; the rule
+// pushes authors toward the non-mutating form.
+//
+// AST-only: visit each `CallExpression`, check that the callee is a
+// property access whose method identifier is `sort`, and accept either
+// zero arguments or exactly one (the optional comparator). Calls with
+// two or more arguments are almost certainly a different `sort` on a
+// user-defined type and are excluded by design.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-sort.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoArraySort struct{}
+
+func (unicornNoArraySort) Name() string { return "unicorn/no-array-sort" }
+func (unicornNoArraySort) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoArraySort) 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.Name()) != "sort" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 1 {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#toSorted()` over the mutating `Array#sort()`.")
+}
+
+func init() {
+  Register(unicornNoArraySort{})
+}

package/linthost/rules_unicorn_no_await_expression_member.go

@@ -0,0 +1,40 @@
+// unicorn/no-await-expression-member: `(await foo).bar` and
+// `(await foo)[index]` mix two reading positions in one expression —
+// the resolution step (`await foo`) and the projection step (`.bar`).
+// Splitting them into a temporary `const value = await foo; value.bar`
+// makes the order of operations explicit and lines up better with
+// stepping through the async function in a debugger.
+//
+// AST-only: any `PropertyAccessExpression` whose receiver is an
+// `AwaitExpression` (possibly wrapped in `ParenthesizedExpression`) fires.
+// `ElementAccessExpression` is left out of this minimal pass — the
+// PropertyAccess shape is the canonical violation cited in the upstream
+// docs and matches the receiver shape directly via `stripParens`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-await-expression-member.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoAwaitExpressionMember struct{}
+
+func (unicornNoAwaitExpressionMember) Name() string {
+  return "unicorn/no-await-expression-member"
+}
+func (unicornNoAwaitExpressionMember) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornNoAwaitExpressionMember) Check(ctx *Context, node *shimast.Node) {
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindAwaitExpression {
+    return
+  }
+  ctx.Report(node, "Don't use member access on an `await` expression — assign the awaited value to a variable first.")
+}
+
+func init() {
+  Register(unicornNoAwaitExpressionMember{})
+}

package/linthost/rules_unicorn_no_await_in_promise_methods.go

@@ -0,0 +1,69 @@
+// unicorn/no-await-in-promise-methods: awaiting an element inside the
+// array argument of `Promise.all` / `Promise.allSettled` / `Promise.race`
+// / `Promise.any` defeats the parallelism the call exists for. The
+// awaits resolve serially in source order before the array is even
+// handed to `Promise.<method>`, so the combinator only sees the
+// already-resolved values.
+//
+// AST-only: visit each `CallExpression`, match the callee against
+// `Promise.<method>` for the four parallel combinators, and check the
+// sole argument's `ArrayLiteralExpression` elements for any
+// `AwaitExpression` shape. Fire on the offending await node so the
+// report anchors to the actual misuse.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-await-in-promise-methods.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornNoAwaitInPromiseMethodsMethods = map[string]struct{}{
+  "all":        {},
+  "allSettled": {},
+  "race":       {},
+  "any":        {},
+}
+
+type unicornNoAwaitInPromiseMethods struct{}
+
+func (unicornNoAwaitInPromiseMethods) Name() string {
+  return "unicorn/no-await-in-promise-methods"
+}
+func (unicornNoAwaitInPromiseMethods) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoAwaitInPromiseMethods) 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) != "Promise" {
+    return
+  }
+  method := identifierText(access.Name())
+  if _, ok := unicornNoAwaitInPromiseMethodsMethods[method]; !ok {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := call.Arguments.Nodes[0]
+  if arg == nil || arg.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  arr := arg.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil {
+    return
+  }
+  for _, elem := range arr.Elements.Nodes {
+    if elem != nil && elem.Kind == shimast.KindAwaitExpression {
+      ctx.Report(elem, "Don't `await` inside `Promise."+method+"` array members — the awaits serialize the calls.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornNoAwaitInPromiseMethods{})
+}

package/linthost/rules_unicorn_no_console_spaces.go

@@ -0,0 +1,61 @@
+// unicorn/no-console-spaces: `console.log("a ", "b")` produces
+// `"a  b"` with a doubled space because the runtime already inserts a
+// single ASCII space between arguments. Leading/trailing whitespace on
+// the literal duplicates that separator and is almost always a leftover
+// from hand-formatting. The rule flags every string-literal argument
+// whose content starts or ends with a space so the source converges on
+// argument-only content and the runtime owns the separator.
+//
+// AST-only and identifier-text-driven: dispatch on `CallExpression`,
+// match a `console.<method>` callee against the six common log
+// methods, and report each `StringLiteral` argument with a leading or
+// trailing space. The receiver is matched by identifier text only;
+// shadowed `console` bindings are out of scope, mirroring the other
+// console-shape rules in this family.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-console-spaces.md
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornNoConsoleSpaces struct{}
+
+func (unicornNoConsoleSpaces) Name() string { return "unicorn/no-console-spaces" }
+func (unicornNoConsoleSpaces) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoConsoleSpaces) 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) != "console" {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "log", "warn", "error", "info", "debug", "trace":
+  default:
+    return
+  }
+  if call.Arguments == nil {
+    return
+  }
+  for _, arg := range call.Arguments.Nodes {
+    if arg == nil || arg.Kind != shimast.KindStringLiteral {
+      continue
+    }
+    text := stringLiteralText(arg)
+    if strings.HasPrefix(text, " ") || strings.HasSuffix(text, " ") {
+      ctx.Report(arg, "Don't include leading or trailing spaces in `console.<method>` arguments.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornNoConsoleSpaces{})
+}