@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_no_useless_fallback_in_spread.go

@@ -0,0 +1,81 @@
+// unicorn/no-useless-fallback-in-spread: spreading `null` or `undefined`
+// into an object literal is already a runtime no-op, so the common
+// defensive shape `...(x ?? {})` adds an allocation and a comparison
+// that change nothing. The same goes for `...(x || {})` and the
+// array-literal variants. Drop the fallback and spread the value
+// directly.
+//
+// AST-only: visit each spread node — `SpreadElement` only when its
+// parent is an `ArrayLiteralExpression` (call-argument spread is
+// excluded because spreading `null` / `undefined` into a function call
+// throws a `TypeError`, so the fallback is load-bearing there) and
+// `SpreadAssignment` for object spread. After stripping parentheses,
+// the spread's operand must be a binary expression using `??` or `||`
+// whose right-hand side is an empty object or array literal. The
+// diagnostic anchors on the spread node so editors highlight the
+// redundant fallback together with its `...`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-fallback-in-spread.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessFallbackInSpread struct{}
+
+func (unicornNoUselessFallbackInSpread) Name() string {
+  return "unicorn/no-useless-fallback-in-spread"
+}
+func (unicornNoUselessFallbackInSpread) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSpreadElement, shimast.KindSpreadAssignment}
+}
+func (unicornNoUselessFallbackInSpread) Check(ctx *Context, node *shimast.Node) {
+  var operand *shimast.Node
+  switch node.Kind {
+  case shimast.KindSpreadElement:
+    // Only flag array-literal spread. Call-argument spread of a
+    // null/undefined operand throws TypeError at runtime, so the
+    // `?? []` / `|| []` fallback is load-bearing in that position.
+    if node.Parent == nil || node.Parent.Kind != shimast.KindArrayLiteralExpression {
+      return
+    }
+    if spread := node.AsSpreadElement(); spread != nil {
+      operand = spread.Expression
+    }
+  case shimast.KindSpreadAssignment:
+    if spread := node.AsSpreadAssignment(); spread != nil {
+      operand = spread.Expression
+    }
+  }
+  inner := stripParens(operand)
+  if inner == nil || inner.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  bin := inner.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindQuestionQuestionToken, shimast.KindBarBarToken:
+  default:
+    return
+  }
+  right := stripParens(bin.Right)
+  if right == nil {
+    return
+  }
+  switch right.Kind {
+  case shimast.KindObjectLiteralExpression:
+    if obj := right.AsObjectLiteralExpression(); obj != nil &&
+      (obj.Properties == nil || len(obj.Properties.Nodes) == 0) {
+      ctx.Report(node, "Don't use a useless `?? {}` or `?? []` fallback when spreading — `...null` and `...undefined` are no-ops.")
+    }
+  case shimast.KindArrayLiteralExpression:
+    if arr := right.AsArrayLiteralExpression(); arr != nil &&
+      (arr.Elements == nil || len(arr.Elements.Nodes) == 0) {
+      ctx.Report(node, "Don't use a useless `?? {}` or `?? []` fallback when spreading — `...null` and `...undefined` are no-ops.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornNoUselessFallbackInSpread{})
+}

package/linthost/rules_unicorn_no_useless_iterator_to_array.go

@@ -0,0 +1,72 @@
+// unicorn/no-useless-iterator-to-array: wrapping an iterator-producing
+// call in an array-literal spread (`[...arr.entries()]`) materializes
+// every element into a throwaway array just to walk through it again.
+// The wrappers `.entries()`, `.keys()`, `.values()` already return
+// iterables that any iteration consumer can consume directly.
+//
+// AST-only and conservative: visit each `ArrayLiteralExpression` whose
+// only element is a `SpreadElement` wrapping a `CallExpression` whose
+// callee is `PropertyAccess(_, name)` with `name ∈ {entries, keys,
+// values}`. The array literal must also be in an iterator-consuming
+// parent position — currently only `for…of` is matched, since materializing
+// an array to iterate it once is the rule's textbook case. Using the
+// materialized array as data (`[...iter][0]`, `[...iter].map(…)`,
+// `const arr = [...iter]`) is NOT flagged because the author wants the
+// array, not a fresh walk.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-iterator-to-array.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessIteratorToArray struct{}
+
+func (unicornNoUselessIteratorToArray) Name() string {
+  return "unicorn/no-useless-iterator-to-array"
+}
+func (unicornNoUselessIteratorToArray) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindArrayLiteralExpression}
+}
+func (unicornNoUselessIteratorToArray) Check(ctx *Context, node *shimast.Node) {
+  // Only fire when the array literal is the iterable of a `for…of`
+  // loop — that's the canonical wasted-materialization shape. Other
+  // uses (`[...iter][0]`, `const arr = [...iter]`, `.map`, etc.)
+  // genuinely need the materialized array.
+  if node.Parent == nil || node.Parent.Kind != shimast.KindForOfStatement {
+    return
+  }
+  arr := node.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
+    return
+  }
+  only := arr.Elements.Nodes[0]
+  if only == nil || only.Kind != shimast.KindSpreadElement {
+    return
+  }
+  spread := only.AsSpreadElement()
+  if spread == nil {
+    return
+  }
+  inner := stripParens(spread.Expression)
+  if inner == nil || inner.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := inner.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "entries", "keys", "values":
+  default:
+    return
+  }
+  ctx.Report(node, "Don't wrap an iterator with `[...iter]` when iterating directly works.")
+}
+
+func init() {
+  Register(unicornNoUselessIteratorToArray{})
+}

package/linthost/rules_unicorn_no_useless_length_check.go

@@ -0,0 +1,144 @@
+// unicorn/no-useless-length-check: `arr.length > 0 && arr.some(…)`
+// short-circuits on an empty array, but `arr.some(…)` already returns
+// `false` for the empty case, so the leading length check is redundant.
+// The same goes for `forEach` (returns `undefined` either way). The
+// rule prunes the dead check so the call shape is the only thing the
+// reader has to track.
+//
+// `every`, `map`, and `filter` are deliberately excluded from the `&&`
+// set: `every` returns `true` on an empty array (so the length check
+// IS load-bearing); `map` and `filter` return `[]` which is truthy
+// (the length check changes the truthiness of the whole expression).
+// Upstream covers those under the complementary `||` pattern
+// (`array.length === 0 || array.every(…)`), which this MVP does not
+// implement yet.
+//
+// AST-only MVP: visit each `BinaryExpression`, match operator `&&`,
+// require LHS to be `PropertyAccess(X, length) > 0` or `!== 0`, and
+// require RHS to be `CallExpression(PropertyAccess(X, name), …)` where
+// `name` is one of `some` / `forEach` and the textual form of the two
+// `X` expressions matches. Fire on the binary expression.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-length-check.md
+package linthost
+
+import (
+  "fmt"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+var unicornNoUselessLengthCheckMethods = map[string]struct{}{
+  "some":    {},
+  "forEach": {},
+}
+
+type unicornNoUselessLengthCheck struct{}
+
+func (unicornNoUselessLengthCheck) Name() string { return "unicorn/no-useless-length-check" }
+func (unicornNoUselessLengthCheck) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornNoUselessLengthCheck) Check(ctx *Context, node *shimast.Node) {
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil ||
+    bin.OperatorToken.Kind != shimast.KindAmpersandAmpersandToken {
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if left == nil || right == nil {
+    return
+  }
+  lengthReceiver := unicornUselessLengthCheckLHSReceiver(ctx, left)
+  if lengthReceiver == "" {
+    return
+  }
+  method, callReceiver := unicornUselessLengthCheckRHSReceiver(ctx, right)
+  if method == "" || callReceiver == "" {
+    return
+  }
+  if lengthReceiver != callReceiver {
+    return
+  }
+  ctx.Report(node, fmt.Sprintf("Useless `.length` check — `%s` already handles empty arrays correctly.", method))
+}
+
+// unicornUselessLengthCheckLHSReceiver returns the textual form of `X`
+// when `node` is `X.length > 0` or `X.length !== 0` (either operand
+// order); returns "" otherwise.
+func unicornUselessLengthCheckLHSReceiver(ctx *Context, node *shimast.Node) string {
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+    return ""
+  }
+  op := bin.OperatorToken.Kind
+  if op != shimast.KindGreaterThanToken &&
+    op != shimast.KindExclamationEqualsEqualsToken &&
+    op != shimast.KindExclamationEqualsToken {
+    return ""
+  }
+  lhs := stripParens(bin.Left)
+  rhs := stripParens(bin.Right)
+  // Try `X.length <op> 0`.
+  if recv := unicornUselessLengthCheckMatchLengthAccess(ctx, lhs); recv != "" &&
+    unicornUselessLengthCheckIsZero(rhs) {
+    return recv
+  }
+  // `0 !== X.length` (no `<` form because `>` is asymmetric — covered
+  // by the LHS branch above).
+  if op == shimast.KindExclamationEqualsEqualsToken || op == shimast.KindExclamationEqualsToken {
+    if recv := unicornUselessLengthCheckMatchLengthAccess(ctx, rhs); recv != "" &&
+      unicornUselessLengthCheckIsZero(lhs) {
+      return recv
+    }
+  }
+  return ""
+}
+
+// unicornUselessLengthCheckMatchLengthAccess returns the receiver text
+// when `node` is a `PropertyAccessExpression(X, length)`; "" otherwise.
+func unicornUselessLengthCheckMatchLengthAccess(ctx *Context, node *shimast.Node) string {
+  if node == nil || node.Kind != shimast.KindPropertyAccessExpression {
+    return ""
+  }
+  access := node.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "length" {
+    return ""
+  }
+  return nodeText(ctx.File, access.Expression)
+}
+
+// unicornUselessLengthCheckIsZero reports whether `node` is the numeric
+// literal `0`.
+func unicornUselessLengthCheckIsZero(node *shimast.Node) bool {
+  return node != nil &&
+    node.Kind == shimast.KindNumericLiteral &&
+    numericLiteralText(node) == "0"
+}
+
+// unicornUselessLengthCheckRHSReceiver returns (method, receiverText)
+// when `node` is `X.method(...)` for one of the empty-safe iteration
+// methods; ("", "") otherwise.
+func unicornUselessLengthCheckRHSReceiver(ctx *Context, node *shimast.Node) (string, string) {
+  if node == nil || node.Kind != shimast.KindCallExpression {
+    return "", ""
+  }
+  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 := unicornNoUselessLengthCheckMethods[method]; !ok {
+    return "", ""
+  }
+  return method, nodeText(ctx.File, access.Expression)
+}
+
+func init() {
+  Register(unicornNoUselessLengthCheck{})
+}

package/linthost/rules_unicorn_no_useless_promise_resolve_reject.go

@@ -0,0 +1,81 @@
+// unicorn/no-useless-promise-resolve-reject: inside an `async`
+// function, `return x` already wraps the value in a resolved promise
+// and `throw err` already produces a rejected one. Writing `return
+// Promise.resolve(x)` or `return Promise.reject(err)` rebuilds the
+// wrapper the runtime would build anyway, hides the actual value
+// behind an extra call, and reads as if the author forgot the
+// function was async.
+//
+// AST-only and parent-walking: visit each `ReturnStatement`, find the
+// nearest enclosing function-like ancestor, and require it to carry
+// the `async` modifier. The return's expression after `stripParens`
+// must be a `CallExpression` whose callee is
+// `PropertyAccess(Identifier("Promise"), name)` with
+// `name ∈ {resolve, reject}`. Arrow concise bodies are not handled
+// here because the rule's contract anchors on the `return` keyword.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-promise-resolve-reject.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessPromiseResolveReject struct{}
+
+func (unicornNoUselessPromiseResolveReject) Name() string {
+  return "unicorn/no-useless-promise-resolve-reject"
+}
+func (unicornNoUselessPromiseResolveReject) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindReturnStatement}
+}
+func (unicornNoUselessPromiseResolveReject) Check(ctx *Context, node *shimast.Node) {
+  ret := node.AsReturnStatement()
+  if ret == nil || ret.Expression == nil {
+    return
+  }
+  if !unicornNoUselessPromiseResolveRejectInAsync(node) {
+    return
+  }
+  expr := stripParens(ret.Expression)
+  if expr == nil || expr.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := expr.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
+  }
+  switch identifierText(access.Name()) {
+  case "resolve", "reject":
+  default:
+    return
+  }
+  ctx.Report(node, "In `async` functions, `return x` and `throw e` work identically — drop the `Promise.<method>` wrapper.")
+}
+
+// unicornNoUselessPromiseResolveRejectInAsync walks ancestors of `node`
+// and reports whether the nearest enclosing function-like declaration
+// is marked `async`. Crossing a function boundary that is not async
+// stops the walk — a nested non-async function shadows the outer
+// async context.
+func unicornNoUselessPromiseResolveRejectInAsync(node *shimast.Node) bool {
+  for cur := node.Parent; cur != nil; cur = cur.Parent {
+    switch cur.Kind {
+    case shimast.KindFunctionDeclaration,
+      shimast.KindFunctionExpression,
+      shimast.KindArrowFunction,
+      shimast.KindMethodDeclaration:
+      return hasModifier(cur, shimast.KindAsyncKeyword)
+    }
+  }
+  return false
+}
+
+func init() {
+  Register(unicornNoUselessPromiseResolveReject{})
+}

package/linthost/rules_unicorn_no_useless_spread.go

@@ -0,0 +1,67 @@
+// unicorn/no-useless-spread: wrapping an already-spread literal in
+// another spread produces the original literal — `[...[1, 2, 3]]` is
+// just `[1, 2, 3]`, and `{...{a: 1}}` is `{a: 1}`. The extra spread
+// reads like an attempted clone but allocates an intermediate literal
+// for no observable effect.
+//
+// AST-only and conservative: visit every `ArrayLiteralExpression` and
+// `ObjectLiteralExpression`; match when the literal contains exactly
+// one element that is a `SpreadElement` / `SpreadAssignment` whose
+// operand (after `stripParens`) is itself a literal of the same kind.
+// The receiver expressions are not inspected — the syntactic shape
+// `[...[…]]` / `{...{…}}` is the signal regardless of the inner
+// literal's contents. Mirrors the conservative dispatch used by
+// `unicorn/prefer-set-size`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-spread.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessSpread struct{}
+
+func (unicornNoUselessSpread) Name() string { return "unicorn/no-useless-spread" }
+func (unicornNoUselessSpread) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindArrayLiteralExpression, shimast.KindObjectLiteralExpression}
+}
+func (unicornNoUselessSpread) Check(ctx *Context, node *shimast.Node) {
+  switch node.Kind {
+  case shimast.KindArrayLiteralExpression:
+    arr := node.AsArrayLiteralExpression()
+    if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
+      return
+    }
+    only := arr.Elements.Nodes[0]
+    if only == nil || only.Kind != shimast.KindSpreadElement {
+      return
+    }
+    spread := only.AsSpreadElement()
+    if spread == nil {
+      return
+    }
+    inner := stripParens(spread.Expression)
+    if inner != nil && inner.Kind == shimast.KindArrayLiteralExpression {
+      ctx.Report(node, "Don't wrap an already-spread literal in another spread.")
+    }
+  case shimast.KindObjectLiteralExpression:
+    obj := node.AsObjectLiteralExpression()
+    if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 1 {
+      return
+    }
+    only := obj.Properties.Nodes[0]
+    if only == nil || only.Kind != shimast.KindSpreadAssignment {
+      return
+    }
+    spread := only.AsSpreadAssignment()
+    if spread == nil {
+      return
+    }
+    inner := stripParens(spread.Expression)
+    if inner != nil && inner.Kind == shimast.KindObjectLiteralExpression {
+      ctx.Report(node, "Don't wrap an already-spread literal in another spread.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornNoUselessSpread{})
+}

package/linthost/rules_unicorn_no_useless_switch_case.go

@@ -0,0 +1,55 @@
+// unicorn/no-useless-switch-case: a `case` clause with no statements
+// that sits immediately above the `default` clause falls through to
+// `default` for free — the value it matches would have hit `default`
+// regardless. Keeping the empty case adds noise without changing the
+// switch's behavior, so the rule reports it.
+//
+// AST-only: visit each `SwitchStatement`, walk its case-block clauses,
+// and report any non-default `CaseClause` whose statements list is
+// empty and whose immediate next sibling is the `DefaultClause`. The
+// empty-body check distinguishes intentional grouped cases that share a
+// non-trivial body from the redundant fall-into-default shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-switch-case.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessSwitchCase struct{}
+
+func (unicornNoUselessSwitchCase) Name() string { return "unicorn/no-useless-switch-case" }
+func (unicornNoUselessSwitchCase) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSwitchStatement}
+}
+func (unicornNoUselessSwitchCase) Check(ctx *Context, node *shimast.Node) {
+  sw := node.AsSwitchStatement()
+  if sw == nil || sw.CaseBlock == nil {
+    return
+  }
+  block := sw.CaseBlock.AsCaseBlock()
+  if block == nil || block.Clauses == nil {
+    return
+  }
+  clauses := block.Clauses.Nodes
+  for i := 0; i < len(clauses)-1; i++ {
+    clause := clauses[i]
+    if clause == nil || clause.Kind != shimast.KindCaseClause {
+      continue
+    }
+    next := clauses[i+1]
+    if next == nil || next.Kind != shimast.KindDefaultClause {
+      continue
+    }
+    cd := clause.AsCaseOrDefaultClause()
+    if cd == nil {
+      continue
+    }
+    if cd.Statements != nil && len(cd.Statements.Nodes) != 0 {
+      continue
+    }
+    ctx.Report(clause, "Useless `case` clause — it falls through to the `default` which would handle this value anyway.")
+  }
+}
+
+func init() {
+  Register(unicornNoUselessSwitchCase{})
+}

package/linthost/rules_unicorn_no_useless_undefined.go

@@ -0,0 +1,55 @@
+// unicorn/no-useless-undefined: `return undefined;` produces the same
+// value as the bare `return;` form, and `void 0` is the canonical
+// roundabout spelling of the same constant. Writing the keyword
+// explicitly adds noise without changing behavior.
+//
+// Minimum-viable port: only the `return` statement shape fires. The
+// call-argument case is intentionally skipped because matching it
+// safely requires knowing which callees accept omission, and the
+// parameter-default case (`function f(x = undefined)`) is deferred.
+//
+// AST-only: visit each `ReturnStatement` whose expression after
+// `stripParens` is either the `undefined` keyword/identifier or the
+// `void 0` shape (a `VoidExpression` whose operand is the numeric
+// literal `0`). Reports on the return statement itself so the
+// diagnostic anchors on the keyword rather than the operand.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-undefined.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoUselessUndefined struct{}
+
+func (unicornNoUselessUndefined) Name() string { return "unicorn/no-useless-undefined" }
+func (unicornNoUselessUndefined) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindReturnStatement}
+}
+func (unicornNoUselessUndefined) Check(ctx *Context, node *shimast.Node) {
+  ret := node.AsReturnStatement()
+  if ret == nil || ret.Expression == nil {
+    return
+  }
+  expr := stripParens(ret.Expression)
+  if expr == nil {
+    return
+  }
+  if expr.Kind == shimast.KindUndefinedKeyword || identifierText(expr) == "undefined" {
+    ctx.Report(node, "Don't `return undefined;` — `return undefined;` and bare `return;` have the same effect.")
+    return
+  }
+  if expr.Kind == shimast.KindVoidExpression {
+    void := expr.AsVoidExpression()
+    if void == nil || void.Expression == nil {
+      return
+    }
+    operand := stripParens(void.Expression)
+    if operand != nil && operand.Kind == shimast.KindNumericLiteral &&
+      numericLiteralText(operand) == "0" {
+      ctx.Report(node, "Don't `return undefined;` — `return undefined;` and bare `return;` have the same effect.")
+    }
+  }
+}
+
+func init() {
+  Register(unicornNoUselessUndefined{})
+}

package/linthost/rules_unicorn_no_zero_fractions.go

@@ -0,0 +1,52 @@
+// unicorn/no-zero-fractions: numeric literals such as `1.0`, `1.`, and
+// `.0` carry a redundant fractional component or a trailing dot whose
+// only visual effect is to mislead the reader into thinking the value
+// needs floating-point semantics. The rule rewrites the source pattern
+// out by reporting on the literal node.
+//
+// AST-only: visit `KindNumericLiteral`, read the raw source text via
+// `nodeText` so the parser-normalized `.Text` (which drops the trailing
+// dot and zero-pad) doesn't mask the smell, and match three regular
+// expressions covering the canonical shapes:
+//
+//   - `1.0`, `1.00`, `-1.0e5` — fractional part is all zeros.
+//   - `1.` — trailing dot with no fractional digits.
+//   - `.0`, `-.0e3` — leading dot with an all-zero fractional part.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-zero-fractions.md
+package linthost
+
+import (
+  "regexp"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+var (
+  unicornNoZeroFractionsTrailingZero = regexp.MustCompile(`^-?\d+\.0+([eE][+-]?\d+)?$`)
+  unicornNoZeroFractionsTrailingDot  = regexp.MustCompile(`^-?\d+\.$`)
+  unicornNoZeroFractionsLeadingDot   = regexp.MustCompile(`^-?\.0+([eE][+-]?\d+)?$`)
+)
+
+type unicornNoZeroFractions struct{}
+
+func (unicornNoZeroFractions) Name() string { return "unicorn/no-zero-fractions" }
+func (unicornNoZeroFractions) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNumericLiteral}
+}
+func (unicornNoZeroFractions) Check(ctx *Context, node *shimast.Node) {
+  source := strings.TrimSpace(nodeText(ctx.File, node))
+  if source == "" {
+    return
+  }
+  if unicornNoZeroFractionsTrailingZero.MatchString(source) ||
+    unicornNoZeroFractionsTrailingDot.MatchString(source) ||
+    unicornNoZeroFractionsLeadingDot.MatchString(source) {
+    ctx.Report(node, "Don't use a redundant `.0` fraction or trailing dot on a number literal.")
+  }
+}
+
+func init() {
+  Register(unicornNoZeroFractions{})
+}

package/linthost/rules_unicorn_number_literal_case.go

@@ -0,0 +1,69 @@
+// unicorn/number-literal-case: hex / binary / octal numeric literals
+// have a conventional canonical form — the radix prefix is lowercase
+// (`0x`, `0b`, `0o`) while hex digits are uppercase (`0xFF`). Mixed-case
+// alternatives (`0Xff`, `0xff`, `0xFf`, `0XFF`) read inconsistently and
+// the rule normalizes the codebase by reporting every literal that
+// isn't already canonical.
+//
+// AST-only: visit `KindNumericLiteral` and `KindBigIntLiteral`, read
+// the raw source text via `nodeText` so the prefix and digit casing
+// survive the parser's normalization, and report when the prefix letter
+// is uppercase OR any hex digit is lowercase. Decimal literals lack a
+// prefix and never fire.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/number-literal-case.md
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornNumberLiteralCase struct{}
+
+func (unicornNumberLiteralCase) Name() string { return "unicorn/number-literal-case" }
+func (unicornNumberLiteralCase) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNumericLiteral, shimast.KindBigIntLiteral}
+}
+func (unicornNumberLiteralCase) Check(ctx *Context, node *shimast.Node) {
+  source := strings.TrimSpace(nodeText(ctx.File, node))
+  if len(source) < 2 || source[0] != '0' {
+    return
+  }
+  prefix := source[1]
+  switch prefix {
+  case 'x', 'X':
+    if unicornNumberLiteralCaseHexNeedsFix(source, prefix) {
+      ctx.Report(node, "Number literals should use a lowercase prefix and uppercase digits — e.g. `0xFF` instead of `0xff`.")
+    }
+  case 'b', 'B', 'o', 'O':
+    // Binary / octal digits are 0-1 / 0-7; only the prefix letter
+    // can be in the wrong case.
+    if prefix == 'B' || prefix == 'O' {
+      ctx.Report(node, "Number literals should use a lowercase prefix and uppercase digits — e.g. `0xFF` instead of `0xff`.")
+    }
+  }
+}
+
+// unicornNumberLiteralCaseHexNeedsFix reports whether the hex literal's
+// raw source text deviates from `0x` + uppercase digits. The trailing
+// `n` of a hex bigint literal (`0xFFn`) is allowed.
+func unicornNumberLiteralCaseHexNeedsFix(source string, prefix byte) bool {
+  if prefix != 'x' {
+    return true
+  }
+  digits := source[2:]
+  digits = strings.TrimSuffix(digits, "n")
+  for i := 0; i < len(digits); i++ {
+    ch := digits[i]
+    if ch >= 'a' && ch <= 'f' {
+      return true
+    }
+  }
+  return false
+}
+
+func init() {
+  Register(unicornNumberLiteralCase{})
+}