@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_unicorn_prefer_negative_index.go

@@ -20,55 +20,55 @@ type unicornPreferNegativeIndex struct{}
 
 func (unicornPreferNegativeIndex) Name() string { return "unicorn/prefer-negative-index" }
 func (unicornPreferNegativeIndex) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferNegativeIndex) 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
-	}
-	switch identifierText(access.Name()) {
-	case "slice", "splice", "toSpliced", "at", "lastIndexOf":
-	default:
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
-		return
-	}
-	first := stripParens(call.Arguments.Nodes[0])
-	if first == nil || first.Kind != shimast.KindBinaryExpression {
-		return
-	}
-	bin := first.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil ||
-		bin.OperatorToken.Kind != shimast.KindMinusToken {
-		return
-	}
-	left := stripParens(bin.Left)
-	if left == nil || left.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	prop := left.AsPropertyAccessExpression()
-	if prop == nil || identifierText(prop.Name()) != "length" {
-		return
-	}
-	right := stripParens(bin.Right)
-	if right == nil || right.Kind != shimast.KindNumericLiteral {
-		return
-	}
-	if !unicornPreferAtIsPositiveInteger(numericLiteralText(right)) {
-		return
-	}
-	ctx.Report(first, "Use a negative index (`-N`) instead of `arr.length - N`.")
+  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
+  }
+  switch identifierText(access.Name()) {
+  case "slice", "splice", "toSpliced", "at", "lastIndexOf":
+  default:
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return
+  }
+  first := stripParens(call.Arguments.Nodes[0])
+  if first == nil || first.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  bin := first.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil ||
+    bin.OperatorToken.Kind != shimast.KindMinusToken {
+    return
+  }
+  left := stripParens(bin.Left)
+  if left == nil || left.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  prop := left.AsPropertyAccessExpression()
+  if prop == nil || identifierText(prop.Name()) != "length" {
+    return
+  }
+  right := stripParens(bin.Right)
+  if right == nil || right.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  if !unicornPreferAtIsPositiveInteger(numericLiteralText(right)) {
+    return
+  }
+  ctx.Report(first, "Use a negative index (`-N`) instead of `arr.length - N`.")
 }
 
 func init() {
-	Register(unicornPreferNegativeIndex{})
+  Register(unicornPreferNegativeIndex{})
 }

package/linthost/rules_unicorn_prefer_node_protocol.go

@@ -18,105 +18,105 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 // unicornPreferNodeProtocolBuiltins enumerates the bare Node built-in
 // module specifiers that must be rewritten to use the `node:` prefix.
 var unicornPreferNodeProtocolBuiltins = map[string]struct{}{
-	"assert":              {},
-	"assert/strict":       {},
-	"async_hooks":         {},
-	"buffer":              {},
-	"child_process":       {},
-	"cluster":             {},
-	"console":             {},
-	"constants":           {},
-	"crypto":              {},
-	"dgram":               {},
-	"diagnostics_channel": {},
-	"dns":                 {},
-	"dns/promises":        {},
-	"domain":              {},
-	"events":              {},
-	"fs":                  {},
-	"fs/promises":         {},
-	"http":                {},
-	"http2":               {},
-	"https":               {},
-	"inspector":           {},
-	"module":              {},
-	"net":                 {},
-	"os":                  {},
-	"path":                {},
-	"path/posix":          {},
-	"path/win32":          {},
-	"perf_hooks":          {},
-	"process":             {},
-	"punycode":            {},
-	"querystring":         {},
-	"readline":            {},
-	"readline/promises":   {},
-	"repl":                {},
-	"stream":              {},
-	"stream/consumers":    {},
-	"stream/promises":     {},
-	"stream/web":          {},
-	"string_decoder":      {},
-	"sys":                 {},
-	"timers":              {},
-	"timers/promises":     {},
-	"tls":                 {},
-	"trace_events":        {},
-	"tty":                 {},
-	"url":                 {},
-	"util":                {},
-	"util/types":          {},
-	"v8":                  {},
-	"vm":                  {},
-	"wasi":                {},
-	"worker_threads":      {},
-	"zlib":                {},
+  "assert":              {},
+  "assert/strict":       {},
+  "async_hooks":         {},
+  "buffer":              {},
+  "child_process":       {},
+  "cluster":             {},
+  "console":             {},
+  "constants":           {},
+  "crypto":              {},
+  "dgram":               {},
+  "diagnostics_channel": {},
+  "dns":                 {},
+  "dns/promises":        {},
+  "domain":              {},
+  "events":              {},
+  "fs":                  {},
+  "fs/promises":         {},
+  "http":                {},
+  "http2":               {},
+  "https":               {},
+  "inspector":           {},
+  "module":              {},
+  "net":                 {},
+  "os":                  {},
+  "path":                {},
+  "path/posix":          {},
+  "path/win32":          {},
+  "perf_hooks":          {},
+  "process":             {},
+  "punycode":            {},
+  "querystring":         {},
+  "readline":            {},
+  "readline/promises":   {},
+  "repl":                {},
+  "stream":              {},
+  "stream/consumers":    {},
+  "stream/promises":     {},
+  "stream/web":          {},
+  "string_decoder":      {},
+  "sys":                 {},
+  "timers":              {},
+  "timers/promises":     {},
+  "tls":                 {},
+  "trace_events":        {},
+  "tty":                 {},
+  "url":                 {},
+  "util":                {},
+  "util/types":          {},
+  "v8":                  {},
+  "vm":                  {},
+  "wasi":                {},
+  "worker_threads":      {},
+  "zlib":                {},
 }
 
 type unicornPreferNodeProtocol struct{}
 
 func (unicornPreferNodeProtocol) Name() string { return "unicorn/prefer-node-protocol" }
 func (unicornPreferNodeProtocol) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindCallExpression}
 }
 func (unicornPreferNodeProtocol) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindImportDeclaration:
-		imp := node.AsImportDeclaration()
-		if imp == nil || imp.ModuleSpecifier == nil {
-			return
-		}
-		if imp.ModuleSpecifier.Kind != shimast.KindStringLiteral {
-			return
-		}
-		specifier := stringLiteralText(imp.ModuleSpecifier)
-		if _, ok := unicornPreferNodeProtocolBuiltins[specifier]; !ok {
-			return
-		}
-		ctx.Report(imp.ModuleSpecifier, "Prefer `node:` protocol when importing Node built-ins.")
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil || call.Expression == nil {
-			return
-		}
-		if identifierText(call.Expression) != "require" {
-			return
-		}
-		if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-			return
-		}
-		arg := call.Arguments.Nodes[0]
-		if arg == nil || arg.Kind != shimast.KindStringLiteral {
-			return
-		}
-		specifier := stringLiteralText(arg)
-		if _, ok := unicornPreferNodeProtocolBuiltins[specifier]; !ok {
-			return
-		}
-		ctx.Report(arg, "Prefer `node:` protocol when importing Node built-ins.")
-	}
+  switch node.Kind {
+  case shimast.KindImportDeclaration:
+    imp := node.AsImportDeclaration()
+    if imp == nil || imp.ModuleSpecifier == nil {
+      return
+    }
+    if imp.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+      return
+    }
+    specifier := stringLiteralText(imp.ModuleSpecifier)
+    if _, ok := unicornPreferNodeProtocolBuiltins[specifier]; !ok {
+      return
+    }
+    ctx.Report(imp.ModuleSpecifier, "Prefer `node:` protocol when importing Node built-ins.")
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil || call.Expression == nil {
+      return
+    }
+    if identifierText(call.Expression) != "require" {
+      return
+    }
+    if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+      return
+    }
+    arg := call.Arguments.Nodes[0]
+    if arg == nil || arg.Kind != shimast.KindStringLiteral {
+      return
+    }
+    specifier := stringLiteralText(arg)
+    if _, ok := unicornPreferNodeProtocolBuiltins[specifier]; !ok {
+      return
+    }
+    ctx.Report(arg, "Prefer `node:` protocol when importing Node built-ins.")
+  }
 }
 
 func init() {
-	Register(unicornPreferNodeProtocol{})
+  Register(unicornPreferNodeProtocol{})
 }

package/linthost/rules_unicorn_prefer_number_properties.go

@@ -16,73 +16,73 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornPreferNumberPropertiesNames = map[string]struct{}{
-	"isNaN":      {},
-	"isFinite":   {},
-	"parseFloat": {},
-	"parseInt":   {},
-	"NaN":        {},
-	"Infinity":   {},
+  "isNaN":      {},
+  "isFinite":   {},
+  "parseFloat": {},
+  "parseInt":   {},
+  "NaN":        {},
+  "Infinity":   {},
 }
 
 type unicornPreferNumberProperties struct{}
 
 func (unicornPreferNumberProperties) Name() string {
-	return "unicorn/prefer-number-properties"
+  return "unicorn/prefer-number-properties"
 }
 func (unicornPreferNumberProperties) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIdentifier}
+  return []shimast.Kind{shimast.KindIdentifier}
 }
 func (unicornPreferNumberProperties) Check(ctx *Context, node *shimast.Node) {
-	name := identifierText(node)
-	if _, ok := unicornPreferNumberPropertiesNames[name]; !ok {
-		return
-	}
-	parent := node.Parent
-	if parent == nil {
-		return
-	}
-	switch parent.Kind {
-	case shimast.KindPropertyAccessExpression:
-		// `obj.isNaN` — the identifier is the property name, not a
-		// reference to the global. `Number.isNaN(...)` itself also
-		// reaches here and must not be flagged.
-		access := parent.AsPropertyAccessExpression()
-		if access != nil && access.Name() == node {
-			return
-		}
-	case shimast.KindQualifiedName:
-		// Type-position `A.B` — same rationale as PropertyAccess.
-		return
-	case shimast.KindPropertyAssignment,
-		shimast.KindShorthandPropertyAssignment,
-		shimast.KindMethodDeclaration,
-		shimast.KindPropertyDeclaration,
-		shimast.KindEnumMember,
-		shimast.KindPropertySignature,
-		shimast.KindMethodSignature,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor:
-		// Member name slots on object/class shapes.
-		return
-	case shimast.KindParameter,
-		shimast.KindVariableDeclaration,
-		shimast.KindBindingElement,
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindClassDeclaration,
-		shimast.KindClassExpression,
-		shimast.KindImportSpecifier,
-		shimast.KindImportClause,
-		shimast.KindNamespaceImport,
-		shimast.KindExportSpecifier,
-		shimast.KindTypeParameter,
-		shimast.KindLabeledStatement:
-		// Binding / declaration names, not references to the global.
-		return
-	}
-	ctx.Report(node, "Prefer `Number.<X>` over the global `<X>` (e.g. `Number.isNaN`, `Number.parseInt`).")
+  name := identifierText(node)
+  if _, ok := unicornPreferNumberPropertiesNames[name]; !ok {
+    return
+  }
+  parent := node.Parent
+  if parent == nil {
+    return
+  }
+  switch parent.Kind {
+  case shimast.KindPropertyAccessExpression:
+    // `obj.isNaN` — the identifier is the property name, not a
+    // reference to the global. `Number.isNaN(...)` itself also
+    // reaches here and must not be flagged.
+    access := parent.AsPropertyAccessExpression()
+    if access != nil && access.Name() == node {
+      return
+    }
+  case shimast.KindQualifiedName:
+    // Type-position `A.B` — same rationale as PropertyAccess.
+    return
+  case shimast.KindPropertyAssignment,
+    shimast.KindShorthandPropertyAssignment,
+    shimast.KindMethodDeclaration,
+    shimast.KindPropertyDeclaration,
+    shimast.KindEnumMember,
+    shimast.KindPropertySignature,
+    shimast.KindMethodSignature,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor:
+    // Member name slots on object/class shapes.
+    return
+  case shimast.KindParameter,
+    shimast.KindVariableDeclaration,
+    shimast.KindBindingElement,
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindClassDeclaration,
+    shimast.KindClassExpression,
+    shimast.KindImportSpecifier,
+    shimast.KindImportClause,
+    shimast.KindNamespaceImport,
+    shimast.KindExportSpecifier,
+    shimast.KindTypeParameter,
+    shimast.KindLabeledStatement:
+    // Binding / declaration names, not references to the global.
+    return
+  }
+  ctx.Report(node, "Prefer `Number.<X>` over the global `<X>` (e.g. `Number.isNaN`, `Number.parseInt`).")
 }
 
 func init() {
-	Register(unicornPreferNumberProperties{})
+  Register(unicornPreferNumberProperties{})
 }

package/linthost/rules_unicorn_prefer_object_from_entries.go

@@ -19,37 +19,37 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferObjectFromEntries struct{}
 
 func (unicornPreferObjectFromEntries) Name() string {
-	return "unicorn/prefer-object-from-entries"
+  return "unicorn/prefer-object-from-entries"
 }
 func (unicornPreferObjectFromEntries) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferObjectFromEntries) 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()) != "reduce" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
-		return
-	}
-	seed := stripParens(call.Arguments.Nodes[1])
-	if seed == nil || seed.Kind != shimast.KindObjectLiteralExpression {
-		return
-	}
-	obj := seed.AsObjectLiteralExpression()
-	if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 0 {
-		return
-	}
-	ctx.Report(node, "Prefer `Object.fromEntries(...)` over `.reduce((acc, ...) => ..., {})` patterns.")
+  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()) != "reduce" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+    return
+  }
+  seed := stripParens(call.Arguments.Nodes[1])
+  if seed == nil || seed.Kind != shimast.KindObjectLiteralExpression {
+    return
+  }
+  obj := seed.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 0 {
+    return
+  }
+  ctx.Report(node, "Prefer `Object.fromEntries(...)` over `.reduce((acc, ...) => ..., {})` patterns.")
 }
 
 func init() {
-	Register(unicornPreferObjectFromEntries{})
+  Register(unicornPreferObjectFromEntries{})
 }

package/linthost/rules_unicorn_prefer_optional_catch_binding.go

@@ -19,44 +19,44 @@
 package linthost
 
 import (
-	"regexp"
+  "regexp"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 var unicornPreferOptionalCatchBindingNamePattern = map[string]*regexp.Regexp{
-	"e":     regexp.MustCompile(`\be\b`),
-	"error": regexp.MustCompile(`\berror\b`),
+  "e":     regexp.MustCompile(`\be\b`),
+  "error": regexp.MustCompile(`\berror\b`),
 }
 
 type unicornPreferOptionalCatchBinding struct{}
 
 func (unicornPreferOptionalCatchBinding) Name() string {
-	return "unicorn/prefer-optional-catch-binding"
+  return "unicorn/prefer-optional-catch-binding"
 }
 func (unicornPreferOptionalCatchBinding) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCatchClause}
+  return []shimast.Kind{shimast.KindCatchClause}
 }
 func (unicornPreferOptionalCatchBinding) Check(ctx *Context, node *shimast.Node) {
-	catch := node.AsCatchClause()
-	if catch == nil || catch.VariableDeclaration == nil || catch.Block == nil {
-		return
-	}
-	binding := catch.VariableDeclaration.Name()
-	if binding == nil || binding.Kind != shimast.KindIdentifier {
-		return
-	}
-	name := identifierText(binding)
-	pattern, ok := unicornPreferOptionalCatchBindingNamePattern[name]
-	if !ok {
-		return
-	}
-	if pattern.MatchString(nodeText(ctx.File, catch.Block)) {
-		return
-	}
-	ctx.Report(binding, "Prefer optional catch binding `catch { ... }` when the error is unused.")
+  catch := node.AsCatchClause()
+  if catch == nil || catch.VariableDeclaration == nil || catch.Block == nil {
+    return
+  }
+  binding := catch.VariableDeclaration.Name()
+  if binding == nil || binding.Kind != shimast.KindIdentifier {
+    return
+  }
+  name := identifierText(binding)
+  pattern, ok := unicornPreferOptionalCatchBindingNamePattern[name]
+  if !ok {
+    return
+  }
+  if pattern.MatchString(nodeText(ctx.File, catch.Block)) {
+    return
+  }
+  ctx.Report(binding, "Prefer optional catch binding `catch { ... }` when the error is unused.")
 }
 
 func init() {
-	Register(unicornPreferOptionalCatchBinding{})
+  Register(unicornPreferOptionalCatchBinding{})
 }

package/linthost/rules_unicorn_prefer_prototype_methods.go

@@ -21,34 +21,34 @@ type unicornPreferPrototypeMethods struct{}
 
 func (unicornPreferPrototypeMethods) Name() string { return "unicorn/prefer-prototype-methods" }
 func (unicornPreferPrototypeMethods) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
 }
 func (unicornPreferPrototypeMethods) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil || access.Expression == nil {
-		return
-	}
-	receiver := stripParens(access.Expression)
-	if receiver == nil {
-		return
-	}
-	switch receiver.Kind {
-	case shimast.KindArrayLiteralExpression:
-		arr := receiver.AsArrayLiteralExpression()
-		if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 0 {
-			return
-		}
-	case shimast.KindObjectLiteralExpression:
-		obj := receiver.AsObjectLiteralExpression()
-		if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 0 {
-			return
-		}
-	default:
-		return
-	}
-	ctx.Report(node, "Use `Array.prototype.<method>` / `Object.prototype.<method>` instead of borrowing via an empty literal.")
+  access := node.AsPropertyAccessExpression()
+  if access == nil || access.Expression == nil {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil {
+    return
+  }
+  switch receiver.Kind {
+  case shimast.KindArrayLiteralExpression:
+    arr := receiver.AsArrayLiteralExpression()
+    if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 0 {
+      return
+    }
+  case shimast.KindObjectLiteralExpression:
+    obj := receiver.AsObjectLiteralExpression()
+    if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) != 0 {
+      return
+    }
+  default:
+    return
+  }
+  ctx.Report(node, "Use `Array.prototype.<method>` / `Object.prototype.<method>` instead of borrowing via an empty literal.")
 }
 
 func init() {
-	Register(unicornPreferPrototypeMethods{})
+  Register(unicornPreferPrototypeMethods{})
 }