@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_unicorn_prefer_string_replace_all.go

@@ -19,57 +19,57 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type unicornPreferStringReplaceAll struct{}
 
 func (unicornPreferStringReplaceAll) Name() string { return "unicorn/prefer-string-replace-all" }
 func (unicornPreferStringReplaceAll) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferStringReplaceAll) 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()) != "replace" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) < 1 {
-		return
-	}
-	first := stripParens(call.Arguments.Nodes[0])
-	if first == nil || first.Kind != shimast.KindRegularExpressionLiteral {
-		return
-	}
-	raw := nodeText(ctx.File, first)
-	if !unicornPreferStringReplaceAllHasGlobalFlag(raw) {
-		return
-	}
-	if !unicornPreferStringReplaceAllIsLiteralPattern(raw) {
-		return
-	}
-	ctx.Report(node, "Prefer `String#replaceAll(literal, replacement)` over `replace(/literal/g, replacement)`.")
+  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()) != "replace" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 1 {
+    return
+  }
+  first := stripParens(call.Arguments.Nodes[0])
+  if first == nil || first.Kind != shimast.KindRegularExpressionLiteral {
+    return
+  }
+  raw := nodeText(ctx.File, first)
+  if !unicornPreferStringReplaceAllHasGlobalFlag(raw) {
+    return
+  }
+  if !unicornPreferStringReplaceAllIsLiteralPattern(raw) {
+    return
+  }
+  ctx.Report(node, "Prefer `String#replaceAll(literal, replacement)` over `replace(/literal/g, replacement)`.")
 }
 
 // unicornPreferStringReplaceAllHasGlobalFlag returns true when `raw` (the
 // source text of a RegularExpressionLiteral, including the surrounding
 // `/` delimiters and trailing flag block) carries the `g` flag.
 func unicornPreferStringReplaceAllHasGlobalFlag(raw string) bool {
-	if len(raw) < 3 || raw[0] != '/' {
-		return false
-	}
-	closing := strings.LastIndexByte(raw, '/')
-	if closing <= 0 {
-		return false
-	}
-	flags := raw[closing+1:]
-	return strings.ContainsRune(flags, 'g')
+  if len(raw) < 3 || raw[0] != '/' {
+    return false
+  }
+  closing := strings.LastIndexByte(raw, '/')
+  if closing <= 0 {
+    return false
+  }
+  flags := raw[closing+1:]
+  return strings.ContainsRune(flags, 'g')
 }
 
 // unicornPreferStringReplaceAllIsLiteralPattern returns true when the
@@ -79,17 +79,17 @@ func unicornPreferStringReplaceAllHasGlobalFlag(raw string) bool {
 // recovering the original character cleanly from raw source requires
 // regex-aware parsing we don't do here.
 func unicornPreferStringReplaceAllIsLiteralPattern(raw string) bool {
-	if len(raw) < 3 || raw[0] != '/' {
-		return false
-	}
-	closing := strings.LastIndexByte(raw, '/')
-	if closing <= 0 {
-		return false
-	}
-	body := raw[1:closing]
-	return !strings.ContainsAny(body, `\.*+?[](){}|^$`)
+  if len(raw) < 3 || raw[0] != '/' {
+    return false
+  }
+  closing := strings.LastIndexByte(raw, '/')
+  if closing <= 0 {
+    return false
+  }
+  body := raw[1:closing]
+  return !strings.ContainsAny(body, `\.*+?[](){}|^$`)
 }
 
 func init() {
-	Register(unicornPreferStringReplaceAll{})
+  Register(unicornPreferStringReplaceAll{})
 }

package/linthost/rules_unicorn_prefer_string_slice.go

@@ -18,26 +18,26 @@ type unicornPreferStringSlice struct{}
 
 func (unicornPreferStringSlice) Name() string { return "unicorn/prefer-string-slice" }
 func (unicornPreferStringSlice) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferStringSlice) 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
-	}
-	switch identifierText(access.Name()) {
-	case "substr", "substring":
-	default:
-		return
-	}
-	ctx.Report(node, "Prefer `String#slice()` over `substr` / `substring`.")
+  call := node.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 "substr", "substring":
+  default:
+    return
+  }
+  ctx.Report(node, "Prefer `String#slice()` over `substr` / `substring`.")
 }
 
 func init() {
-	Register(unicornPreferStringSlice{})
+  Register(unicornPreferStringSlice{})
 }

package/linthost/rules_unicorn_prefer_string_starts_ends_with.go

@@ -17,132 +17,132 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferStringStartsEndsWith struct{}
 
 func (unicornPreferStringStartsEndsWith) Name() string {
-	return "unicorn/prefer-string-starts-ends-with"
+  return "unicorn/prefer-string-starts-ends-with"
 }
 func (unicornPreferStringStartsEndsWith) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (unicornPreferStringStartsEndsWith) Check(ctx *Context, node *shimast.Node) {
-	bin := node.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
-		return
-	}
-	switch bin.OperatorToken.Kind {
-	case shimast.KindEqualsEqualsEqualsToken,
-		shimast.KindExclamationEqualsEqualsToken:
-	default:
-		return
-	}
-	left := stripParens(bin.Left)
-	right := stripParens(bin.Right)
-	if unicornPreferStringStartsEndsWithMatches(left, right) ||
-		unicornPreferStringStartsEndsWithMatches(right, left) {
-		ctx.Report(node, "Prefer `String#startsWith()` / `String#endsWith()` over slice-and-compare.")
-	}
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken:
+  default:
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if unicornPreferStringStartsEndsWithMatches(left, right) ||
+    unicornPreferStringStartsEndsWithMatches(right, left) {
+    ctx.Report(node, "Prefer `String#startsWith()` / `String#endsWith()` over slice-and-compare.")
+  }
 }
 
 // unicornPreferStringStartsEndsWithMatches reports whether `callSide` is
 // the slice call and `literalSide` is a matching string literal.
 func unicornPreferStringStartsEndsWithMatches(callSide, literalSide *shimast.Node) bool {
-	if callSide == nil || literalSide == nil {
-		return false
-	}
-	if callSide.Kind != shimast.KindCallExpression {
-		return false
-	}
-	if literalSide.Kind != shimast.KindStringLiteral &&
-		literalSide.Kind != shimast.KindNoSubstitutionTemplateLiteral {
-		return false
-	}
-	call := callSide.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return false
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil || identifierText(access.Name()) != "slice" {
-		return false
-	}
-	if call.Arguments == nil {
-		return false
-	}
-	args := call.Arguments.Nodes
-	wantLen := -1
-	switch len(args) {
-	case 2:
-		first := stripParens(args[0])
-		second := stripParens(args[1])
-		if first == nil || first.Kind != shimast.KindNumericLiteral ||
-			numericLiteralText(first) != "0" {
-			return false
-		}
-		if second == nil || second.Kind != shimast.KindNumericLiteral {
-			return false
-		}
-		if !unicornPreferStringStartsEndsWithDigits(numericLiteralText(second)) {
-			return false
-		}
-		wantLen = unicornPreferStringStartsEndsWithToInt(numericLiteralText(second))
-	case 1:
-		// `.slice(-N)` — a unary minus over a positive numeric literal.
-		only := stripParens(args[0])
-		if only == nil || only.Kind != shimast.KindPrefixUnaryExpression {
-			return false
-		}
-		prefix := only.AsPrefixUnaryExpression()
-		if prefix == nil || prefix.Operator != shimast.KindMinusToken ||
-			prefix.Operand == nil ||
-			prefix.Operand.Kind != shimast.KindNumericLiteral {
-			return false
-		}
-		text := numericLiteralText(prefix.Operand)
-		if !unicornPreferStringStartsEndsWithDigits(text) {
-			return false
-		}
-		wantLen = unicornPreferStringStartsEndsWithToInt(text)
-	default:
-		return false
-	}
-	if wantLen <= 0 {
-		return false
-	}
-	return len(stringLiteralText(literalSide)) == wantLen
+  if callSide == nil || literalSide == nil {
+    return false
+  }
+  if callSide.Kind != shimast.KindCallExpression {
+    return false
+  }
+  if literalSide.Kind != shimast.KindStringLiteral &&
+    literalSide.Kind != shimast.KindNoSubstitutionTemplateLiteral {
+    return false
+  }
+  call := callSide.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "slice" {
+    return false
+  }
+  if call.Arguments == nil {
+    return false
+  }
+  args := call.Arguments.Nodes
+  wantLen := -1
+  switch len(args) {
+  case 2:
+    first := stripParens(args[0])
+    second := stripParens(args[1])
+    if first == nil || first.Kind != shimast.KindNumericLiteral ||
+      numericLiteralText(first) != "0" {
+      return false
+    }
+    if second == nil || second.Kind != shimast.KindNumericLiteral {
+      return false
+    }
+    if !unicornPreferStringStartsEndsWithDigits(numericLiteralText(second)) {
+      return false
+    }
+    wantLen = unicornPreferStringStartsEndsWithToInt(numericLiteralText(second))
+  case 1:
+    // `.slice(-N)` — a unary minus over a positive numeric literal.
+    only := stripParens(args[0])
+    if only == nil || only.Kind != shimast.KindPrefixUnaryExpression {
+      return false
+    }
+    prefix := only.AsPrefixUnaryExpression()
+    if prefix == nil || prefix.Operator != shimast.KindMinusToken ||
+      prefix.Operand == nil ||
+      prefix.Operand.Kind != shimast.KindNumericLiteral {
+      return false
+    }
+    text := numericLiteralText(prefix.Operand)
+    if !unicornPreferStringStartsEndsWithDigits(text) {
+      return false
+    }
+    wantLen = unicornPreferStringStartsEndsWithToInt(text)
+  default:
+    return false
+  }
+  if wantLen <= 0 {
+    return false
+  }
+  return len(stringLiteralText(literalSide)) == wantLen
 }
 
 // unicornPreferStringStartsEndsWithDigits reports whether `text` is a
 // non-empty ASCII decimal-integer literal. Decimals, hex, and `e`-notation
 // are rejected since the rule only handles fixed-length prefixes.
 func unicornPreferStringStartsEndsWithDigits(text string) bool {
-	if text == "" {
-		return false
-	}
-	for i := 0; i < len(text); i++ {
-		c := text[i]
-		if c < '0' || c > '9' {
-			return false
-		}
-	}
-	return true
+  if text == "" {
+    return false
+  }
+  for i := 0; i < len(text); i++ {
+    c := text[i]
+    if c < '0' || c > '9' {
+      return false
+    }
+  }
+  return true
 }
 
 // unicornPreferStringStartsEndsWithToInt parses an ASCII decimal-integer
 // literal into an int. Callers must have validated the input first; this
 // helper returns -1 only as a defensive fallback for an overflow guard.
 func unicornPreferStringStartsEndsWithToInt(text string) int {
-	n := 0
-	for i := 0; i < len(text); i++ {
-		c := text[i]
-		if c < '0' || c > '9' {
-			return -1
-		}
-		n = n*10 + int(c-'0')
-		if n > 1<<30 {
-			return -1
-		}
-	}
-	return n
+  n := 0
+  for i := 0; i < len(text); i++ {
+    c := text[i]
+    if c < '0' || c > '9' {
+      return -1
+    }
+    n = n*10 + int(c-'0')
+    if n > 1<<30 {
+      return -1
+    }
+  }
+  return n
 }
 
 func init() {
-	Register(unicornPreferStringStartsEndsWith{})
+  Register(unicornPreferStringStartsEndsWith{})
 }

package/linthost/rules_unicorn_prefer_string_trim_start_end.go

@@ -17,32 +17,32 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferStringTrimStartEnd struct{}
 
 func (unicornPreferStringTrimStartEnd) Name() string {
-	return "unicorn/prefer-string-trim-start-end"
+  return "unicorn/prefer-string-trim-start-end"
 }
 func (unicornPreferStringTrimStartEnd) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferStringTrimStartEnd) 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
-	}
-	switch identifierText(access.Name()) {
-	case "trimLeft", "trimRight":
-	default:
-		return
-	}
-	if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
-		return
-	}
-	ctx.Report(node, "Prefer `String#trimStart` / `String#trimEnd` over the deprecated `trimLeft` / `trimRight`.")
+  call := node.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 "trimLeft", "trimRight":
+  default:
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    return
+  }
+  ctx.Report(node, "Prefer `String#trimStart` / `String#trimEnd` over the deprecated `trimLeft` / `trimRight`.")
 }
 
 func init() {
-	Register(unicornPreferStringTrimStartEnd{})
+  Register(unicornPreferStringTrimStartEnd{})
 }

package/linthost/rules_unicorn_prefer_structured_clone.go

@@ -17,27 +17,27 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferStructuredClone struct{}
 
 func (unicornPreferStructuredClone) Name() string {
-	return "unicorn/prefer-structured-clone"
+  return "unicorn/prefer-structured-clone"
 }
 func (unicornPreferStructuredClone) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferStructuredClone) Check(ctx *Context, node *shimast.Node) {
-	if !isJSONMethodCall(node, "parse") {
-		return
-	}
-	outer := node.AsCallExpression()
-	if outer == nil || outer.Arguments == nil || len(outer.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := stripParens(outer.Arguments.Nodes[0])
-	if arg == nil || arg.Kind != shimast.KindCallExpression {
-		return
-	}
-	if !isJSONMethodCall(arg, "stringify") {
-		return
-	}
-	ctx.Report(node, "Prefer `structuredClone(x)` over `JSON.parse(JSON.stringify(x))`.")
+  if !isJSONMethodCall(node, "parse") {
+    return
+  }
+  outer := node.AsCallExpression()
+  if outer == nil || outer.Arguments == nil || len(outer.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(outer.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindCallExpression {
+    return
+  }
+  if !isJSONMethodCall(arg, "stringify") {
+    return
+  }
+  ctx.Report(node, "Prefer `structuredClone(x)` over `JSON.parse(JSON.stringify(x))`.")
 }
 
 // isJSONMethodCall reports whether `node` is a CallExpression whose
@@ -46,26 +46,26 @@ func (unicornPreferStructuredClone) Check(ctx *Context, node *shimast.Node) {
 // firing on `aliased.parse(...)` shapes that happen to share the
 // method name.
 func isJSONMethodCall(node *shimast.Node, method string) bool {
-	if node == nil || node.Kind != shimast.KindCallExpression {
-		return false
-	}
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return false
-	}
-	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return false
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return false
-	}
-	if identifierText(access.Name()) != method {
-		return false
-	}
-	return identifierText(stripParens(access.Expression)) == "JSON"
+  if node == nil || node.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return false
+  }
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return false
+  }
+  if identifierText(access.Name()) != method {
+    return false
+  }
+  return identifierText(stripParens(access.Expression)) == "JSON"
 }
 
 func init() {
-	Register(unicornPreferStructuredClone{})
+  Register(unicornPreferStructuredClone{})
 }