@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_unicorn_no_useless_length_check.go

@@ -22,123 +22,123 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 var unicornNoUselessLengthCheckMethods = map[string]struct{}{
-	"some":    {},
-	"forEach": {},
+  "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}
+  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))
+  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 ""
+  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)
+  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"
+  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)
+  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{})
+  Register(unicornNoUselessLengthCheck{})
 }

package/linthost/rules_unicorn_no_useless_promise_resolve_reject.go

@@ -21,41 +21,41 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoUselessPromiseResolveReject struct{}
 
 func (unicornNoUselessPromiseResolveReject) Name() string {
-	return "unicorn/no-useless-promise-resolve-reject"
+  return "unicorn/no-useless-promise-resolve-reject"
 }
 func (unicornNoUselessPromiseResolveReject) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindReturnStatement}
+  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.")
+  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`
@@ -64,18 +64,18 @@ func (unicornNoUselessPromiseResolveReject) Check(ctx *Context, node *shimast.No
 // 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
+  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{})
+  Register(unicornNoUselessPromiseResolveReject{})
 }

package/linthost/rules_unicorn_no_useless_spread.go

@@ -21,47 +21,47 @@ type unicornNoUselessSpread struct{}
 
 func (unicornNoUselessSpread) Name() string { return "unicorn/no-useless-spread" }
 func (unicornNoUselessSpread) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindArrayLiteralExpression, shimast.KindObjectLiteralExpression}
+  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.")
-		}
-	}
+  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{})
+  Register(unicornNoUselessSpread{})
 }

package/linthost/rules_unicorn_no_useless_switch_case.go

@@ -18,38 +18,38 @@ type unicornNoUselessSwitchCase struct{}
 
 func (unicornNoUselessSwitchCase) Name() string { return "unicorn/no-useless-switch-case" }
 func (unicornNoUselessSwitchCase) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSwitchStatement}
+  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.")
-	}
+  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{})
+  Register(unicornNoUselessSwitchCase{})
 }

package/linthost/rules_unicorn_no_useless_undefined.go

@@ -22,34 +22,34 @@ type unicornNoUselessUndefined struct{}
 
 func (unicornNoUselessUndefined) Name() string { return "unicorn/no-useless-undefined" }
 func (unicornNoUselessUndefined) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindReturnStatement}
+  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.")
-		}
-	}
+  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{})
+  Register(unicornNoUselessUndefined{})
 }

package/linthost/rules_unicorn_no_zero_fractions.go

@@ -17,36 +17,36 @@
 package linthost
 
 import (
-	"regexp"
-	"strings"
+  "regexp"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  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+)?$`)
+  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}
+  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.")
-	}
+  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{})
+  Register(unicornNoZeroFractions{})
 }