@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_unicorn_prefer_array_index_of.go

@@ -19,129 +19,129 @@ type unicornPreferArrayIndexOf struct{}
 
 func (unicornPreferArrayIndexOf) Name() string { return "unicorn/prefer-array-index-of" }
 func (unicornPreferArrayIndexOf) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferArrayIndexOf) 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()) != "findIndex" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	fn := stripParens(call.Arguments.Nodes[0])
-	if fn == nil {
-		return
-	}
-	var body *shimast.Node
-	switch fn.Kind {
-	case shimast.KindArrowFunction:
-		arrow := fn.AsArrowFunction()
-		if arrow == nil {
-			return
-		}
-		body = arrow.Body
-	case shimast.KindFunctionExpression:
-		expr := fn.AsFunctionExpression()
-		if expr == nil {
-			return
-		}
-		body = expr.Body
-	default:
-		return
-	}
-	params := fn.Parameters()
-	if len(params) != 1 {
-		return
-	}
-	paramName := parameterIdentifierName(params[0])
-	if paramName == "" {
-		return
-	}
-	expr := unicornPreferArrayIndexOfBodyExpression(body)
-	if expr == nil {
-		return
-	}
-	bin := expr.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil ||
-		bin.OperatorToken.Kind != shimast.KindEqualsEqualsEqualsToken {
-		return
-	}
-	left := stripParens(bin.Left)
-	right := stripParens(bin.Right)
-	if left == nil || right == nil {
-		return
-	}
-	if unicornPreferArrayIndexOfMatchesParam(left, paramName) &&
-		unicornPreferArrayIndexOfIsLiteral(right) {
-		ctx.Report(node, "Prefer `Array#indexOf()` over `Array#findIndex(x => x === literal)`.")
-		return
-	}
-	if unicornPreferArrayIndexOfMatchesParam(right, paramName) &&
-		unicornPreferArrayIndexOfIsLiteral(left) {
-		ctx.Report(node, "Prefer `Array#indexOf()` over `Array#findIndex(x => x === literal)`.")
-	}
+  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()) != "findIndex" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  fn := stripParens(call.Arguments.Nodes[0])
+  if fn == nil {
+    return
+  }
+  var body *shimast.Node
+  switch fn.Kind {
+  case shimast.KindArrowFunction:
+    arrow := fn.AsArrowFunction()
+    if arrow == nil {
+      return
+    }
+    body = arrow.Body
+  case shimast.KindFunctionExpression:
+    expr := fn.AsFunctionExpression()
+    if expr == nil {
+      return
+    }
+    body = expr.Body
+  default:
+    return
+  }
+  params := fn.Parameters()
+  if len(params) != 1 {
+    return
+  }
+  paramName := parameterIdentifierName(params[0])
+  if paramName == "" {
+    return
+  }
+  expr := unicornPreferArrayIndexOfBodyExpression(body)
+  if expr == nil {
+    return
+  }
+  bin := expr.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil ||
+    bin.OperatorToken.Kind != shimast.KindEqualsEqualsEqualsToken {
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if left == nil || right == nil {
+    return
+  }
+  if unicornPreferArrayIndexOfMatchesParam(left, paramName) &&
+    unicornPreferArrayIndexOfIsLiteral(right) {
+    ctx.Report(node, "Prefer `Array#indexOf()` over `Array#findIndex(x => x === literal)`.")
+    return
+  }
+  if unicornPreferArrayIndexOfMatchesParam(right, paramName) &&
+    unicornPreferArrayIndexOfIsLiteral(left) {
+    ctx.Report(node, "Prefer `Array#indexOf()` over `Array#findIndex(x => x === literal)`.")
+  }
 }
 
 // unicornPreferArrayIndexOfBodyExpression normalizes the function body to
 // the comparison expression: a concise arrow body returns its expression,
 // a block body with a single `return expr;` returns the expression.
 func unicornPreferArrayIndexOfBodyExpression(body *shimast.Node) *shimast.Node {
-	if body == nil {
-		return nil
-	}
-	if body.Kind != shimast.KindBlock {
-		expr := stripParens(body)
-		if expr == nil || expr.Kind != shimast.KindBinaryExpression {
-			return nil
-		}
-		return expr
-	}
-	block := body.AsBlock()
-	if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
-		return nil
-	}
-	stmt := block.Statements.Nodes[0]
-	if stmt == nil || stmt.Kind != shimast.KindReturnStatement {
-		return nil
-	}
-	ret := stmt.AsReturnStatement()
-	if ret == nil || ret.Expression == nil {
-		return nil
-	}
-	expr := stripParens(ret.Expression)
-	if expr == nil || expr.Kind != shimast.KindBinaryExpression {
-		return nil
-	}
-	return expr
+  if body == nil {
+    return nil
+  }
+  if body.Kind != shimast.KindBlock {
+    expr := stripParens(body)
+    if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+      return nil
+    }
+    return expr
+  }
+  block := body.AsBlock()
+  if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+    return nil
+  }
+  stmt := block.Statements.Nodes[0]
+  if stmt == nil || stmt.Kind != shimast.KindReturnStatement {
+    return nil
+  }
+  ret := stmt.AsReturnStatement()
+  if ret == nil || ret.Expression == nil {
+    return nil
+  }
+  expr := stripParens(ret.Expression)
+  if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+    return nil
+  }
+  return expr
 }
 
 func unicornPreferArrayIndexOfMatchesParam(node *shimast.Node, name string) bool {
-	return identifierText(node) == name
+  return identifierText(node) == name
 }
 
 func unicornPreferArrayIndexOfIsLiteral(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	switch node.Kind {
-	case shimast.KindStringLiteral,
-		shimast.KindNumericLiteral,
-		shimast.KindBigIntLiteral,
-		shimast.KindNoSubstitutionTemplateLiteral,
-		shimast.KindNullKeyword,
-		shimast.KindTrueKeyword,
-		shimast.KindFalseKeyword:
-		return true
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindNullKeyword,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword:
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(unicornPreferArrayIndexOf{})
+  Register(unicornPreferArrayIndexOf{})
 }

package/linthost/rules_unicorn_prefer_array_some.go

@@ -16,52 +16,52 @@ type unicornPreferArraySome struct{}
 
 func (unicornPreferArraySome) Name() string { return "unicorn/prefer-array-some" }
 func (unicornPreferArraySome) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (unicornPreferArraySome) 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.KindGreaterThanToken,
-		shimast.KindGreaterThanEqualsToken,
-		shimast.KindExclamationEqualsEqualsToken,
-		shimast.KindExclamationEqualsToken:
-	default:
-		return
-	}
-	right := stripParens(bin.Right)
-	if right == nil || right.Kind != shimast.KindNumericLiteral {
-		return
-	}
-	if numericLiteralText(right) != "0" {
-		return
-	}
-	left := stripParens(bin.Left)
-	if left == nil || left.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	outer := left.AsPropertyAccessExpression()
-	if outer == nil || identifierText(outer.Name()) != "length" {
-		return
-	}
-	receiver := stripParens(outer.Expression)
-	if receiver == nil || receiver.Kind != shimast.KindCallExpression {
-		return
-	}
-	call := receiver.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil || identifierText(access.Name()) != "filter" {
-		return
-	}
-	ctx.Report(node, "Prefer `Array#some()` over `.filter(...).length > 0`.")
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindGreaterThanToken,
+    shimast.KindGreaterThanEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken:
+  default:
+    return
+  }
+  right := stripParens(bin.Right)
+  if right == nil || right.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  if numericLiteralText(right) != "0" {
+    return
+  }
+  left := stripParens(bin.Left)
+  if left == nil || left.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  outer := left.AsPropertyAccessExpression()
+  if outer == nil || identifierText(outer.Name()) != "length" {
+    return
+  }
+  receiver := stripParens(outer.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := receiver.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "filter" {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#some()` over `.filter(...).length > 0`.")
 }
 
 func init() {
-	Register(unicornPreferArraySome{})
+  Register(unicornPreferArraySome{})
 }

package/linthost/rules_unicorn_prefer_at.go

@@ -19,39 +19,39 @@ type unicornPreferAt struct{}
 
 func (unicornPreferAt) Name() string { return "unicorn/prefer-at" }
 func (unicornPreferAt) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindElementAccessExpression}
+  return []shimast.Kind{shimast.KindElementAccessExpression}
 }
 func (unicornPreferAt) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsElementAccessExpression()
-	if access == nil || access.ArgumentExpression == nil {
-		return
-	}
-	index := stripParens(access.ArgumentExpression)
-	if index == nil || index.Kind != shimast.KindBinaryExpression {
-		return
-	}
-	bin := index.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
-	}
-	text := numericLiteralText(right)
-	if !unicornPreferAtIsPositiveInteger(text) {
-		return
-	}
-	ctx.Report(node, "Prefer `Array#at(-N)` / `String#at(-N)` over `arr[arr.length - N]`.")
+  access := node.AsElementAccessExpression()
+  if access == nil || access.ArgumentExpression == nil {
+    return
+  }
+  index := stripParens(access.ArgumentExpression)
+  if index == nil || index.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  bin := index.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
+  }
+  text := numericLiteralText(right)
+  if !unicornPreferAtIsPositiveInteger(text) {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#at(-N)` / `String#at(-N)` over `arr[arr.length - N]`.")
 }
 
 // unicornPreferAtIsPositiveInteger reports whether `text` is the literal
@@ -60,18 +60,18 @@ func (unicornPreferAt) Check(ctx *Context, node *shimast.Node) {
 // empty string, plain `0`, and anything containing a non-digit (decimals,
 // `e`-notation, hex, bigint suffix).
 func unicornPreferAtIsPositiveInteger(text string) bool {
-	if text == "" || text == "0" {
-		return false
-	}
-	for i := 0; i < len(text); i++ {
-		c := text[i]
-		if c < '0' || c > '9' {
-			return false
-		}
-	}
-	return true
+  if text == "" || text == "0" {
+    return false
+  }
+  for i := 0; i < len(text); i++ {
+    c := text[i]
+    if c < '0' || c > '9' {
+      return false
+    }
+  }
+  return true
 }
 
 func init() {
-	Register(unicornPreferAt{})
+  Register(unicornPreferAt{})
 }

package/linthost/rules_unicorn_prefer_bigint_literals.go

@@ -20,32 +20,32 @@ type unicornPreferBigintLiterals struct{}
 
 func (unicornPreferBigintLiterals) Name() string { return "unicorn/prefer-bigint-literals" }
 func (unicornPreferBigintLiterals) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferBigintLiterals) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || identifierText(call.Expression) != "BigInt" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := stripParens(call.Arguments.Nodes[0])
-	if arg == nil {
-		return
-	}
-	switch arg.Kind {
-	case shimast.KindNumericLiteral:
-		// `BigInt(1)` — always rewritable to `1n`.
-	case shimast.KindStringLiteral:
-		text := stringLiteralText(arg)
-		if !unicornPreferBigintLiteralsIsDecimalInteger(text) {
-			return
-		}
-	default:
-		return
-	}
-	ctx.Report(node, "Prefer BigInt literal `1n` over `BigInt(1)`.")
+  call := node.AsCallExpression()
+  if call == nil || identifierText(call.Expression) != "BigInt" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil {
+    return
+  }
+  switch arg.Kind {
+  case shimast.KindNumericLiteral:
+    // `BigInt(1)` — always rewritable to `1n`.
+  case shimast.KindStringLiteral:
+    text := stringLiteralText(arg)
+    if !unicornPreferBigintLiteralsIsDecimalInteger(text) {
+      return
+    }
+  default:
+    return
+  }
+  ctx.Report(node, "Prefer BigInt literal `1n` over `BigInt(1)`.")
 }
 
 // unicornPreferBigintLiteralsIsDecimalInteger reports whether `text` is
@@ -53,25 +53,25 @@ func (unicornPreferBigintLiterals) Check(ctx *Context, node *shimast.Node) {
 // minus. The check is intentionally conservative; anything more exotic
 // (hex prefix, exponent, decimal point) leaves the BigInt call alone.
 func unicornPreferBigintLiteralsIsDecimalInteger(text string) bool {
-	if text == "" {
-		return false
-	}
-	i := 0
-	if text[0] == '-' || text[0] == '+' {
-		i++
-	}
-	if i == len(text) {
-		return false
-	}
-	for ; i < len(text); i++ {
-		ch := text[i]
-		if ch < '0' || ch > '9' {
-			return false
-		}
-	}
-	return true
+  if text == "" {
+    return false
+  }
+  i := 0
+  if text[0] == '-' || text[0] == '+' {
+    i++
+  }
+  if i == len(text) {
+    return false
+  }
+  for ; i < len(text); i++ {
+    ch := text[i]
+    if ch < '0' || ch > '9' {
+      return false
+    }
+  }
+  return true
 }
 
 func init() {
-	Register(unicornPreferBigintLiterals{})
+  Register(unicornPreferBigintLiterals{})
 }

package/linthost/rules_unicorn_prefer_blob_reading_methods.go

@@ -19,26 +19,26 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferBlobReadingMethods struct{}
 
 func (unicornPreferBlobReadingMethods) Name() string {
-	return "unicorn/prefer-blob-reading-methods"
+  return "unicorn/prefer-blob-reading-methods"
 }
 func (unicornPreferBlobReadingMethods) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferBlobReadingMethods) 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 "readAsArrayBuffer", "readAsText":
-		ctx.Report(node, "Prefer `Blob#arrayBuffer()` / `Blob#text()` over `FileReader#readAsArrayBuffer` / `readAsText`.")
-	}
+  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 "readAsArrayBuffer", "readAsText":
+    ctx.Report(node, "Prefer `Blob#arrayBuffer()` / `Blob#text()` over `FileReader#readAsArrayBuffer` / `readAsText`.")
+  }
 }
 
 func init() {
-	Register(unicornPreferBlobReadingMethods{})
+  Register(unicornPreferBlobReadingMethods{})
 }