@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_unicorn_no_unreadable_array_destructuring.go

@@ -22,47 +22,47 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoUnreadableArrayDestructuring struct{}
 
 func (unicornNoUnreadableArrayDestructuring) Name() string {
-	return "unicorn/no-unreadable-array-destructuring"
+  return "unicorn/no-unreadable-array-destructuring"
 }
 func (unicornNoUnreadableArrayDestructuring) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindArrayBindingPattern, shimast.KindArrayLiteralExpression}
+  return []shimast.Kind{shimast.KindArrayBindingPattern, shimast.KindArrayLiteralExpression}
 }
 func (unicornNoUnreadableArrayDestructuring) Check(ctx *Context, node *shimast.Node) {
-	var elements []*shimast.Node
-	switch node.Kind {
-	case shimast.KindArrayBindingPattern:
-		pattern := node.AsBindingPattern()
-		if pattern == nil || pattern.Elements == nil {
-			return
-		}
-		elements = pattern.Elements.Nodes
-	case shimast.KindArrayLiteralExpression:
-		// Array literals fire only when they appear in a destructuring-
-		// assignment position; otherwise the holes are just sparse-array
-		// construction, which a different rule covers.
-		if !isAssignmentDestructuringTarget(node) {
-			return
-		}
-		arr := node.AsArrayLiteralExpression()
-		if arr == nil || arr.Elements == nil {
-			return
-		}
-		elements = arr.Elements.Nodes
-	default:
-		return
-	}
-	run := 0
-	for _, el := range elements {
-		if isArrayDestructuringHole(el) {
-			run++
-			continue
-		}
-		if run >= 2 {
-			ctx.Report(node, "Don't use unreadable array destructuring with long hole runs.")
-			return
-		}
-		run = 0
-	}
+  var elements []*shimast.Node
+  switch node.Kind {
+  case shimast.KindArrayBindingPattern:
+    pattern := node.AsBindingPattern()
+    if pattern == nil || pattern.Elements == nil {
+      return
+    }
+    elements = pattern.Elements.Nodes
+  case shimast.KindArrayLiteralExpression:
+    // Array literals fire only when they appear in a destructuring-
+    // assignment position; otherwise the holes are just sparse-array
+    // construction, which a different rule covers.
+    if !isAssignmentDestructuringTarget(node) {
+      return
+    }
+    arr := node.AsArrayLiteralExpression()
+    if arr == nil || arr.Elements == nil {
+      return
+    }
+    elements = arr.Elements.Nodes
+  default:
+    return
+  }
+  run := 0
+  for _, el := range elements {
+    if isArrayDestructuringHole(el) {
+      run++
+      continue
+    }
+    if run >= 2 {
+      ctx.Report(node, "Don't use unreadable array destructuring with long hole runs.")
+      return
+    }
+    run = 0
+  }
 }
 
 // isArrayDestructuringHole reports whether `el` is a comma "hole" in an
@@ -71,19 +71,19 @@ func (unicornNoUnreadableArrayDestructuring) Check(ctx *Context, node *shimast.N
 // hole in an `ArrayBindingPattern` as a `BindingElement` with no name
 // (and no initializer / dotdotdot). Both shapes contribute to a run.
 func isArrayDestructuringHole(el *shimast.Node) bool {
-	if el == nil {
-		return false
-	}
-	if el.Kind == shimast.KindOmittedExpression {
-		return true
-	}
-	if el.Kind == shimast.KindBindingElement {
-		be := el.AsBindingElement()
-		if be != nil && be.Name() == nil && be.Initializer == nil && be.DotDotDotToken == nil {
-			return true
-		}
-	}
-	return false
+  if el == nil {
+    return false
+  }
+  if el.Kind == shimast.KindOmittedExpression {
+    return true
+  }
+  if el.Kind == shimast.KindBindingElement {
+    be := el.AsBindingElement()
+    if be != nil && be.Name() == nil && be.Initializer == nil && be.DotDotDotToken == nil {
+      return true
+    }
+  }
+  return false
 }
 
 // isAssignmentDestructuringTarget reports whether `node` (an
@@ -92,24 +92,24 @@ func isArrayDestructuringHole(el *shimast.Node) bool {
 // assignment as an array-literal expression in LHS slot; without this
 // gate every plain sparse array literal would trip the rule.
 func isAssignmentDestructuringTarget(node *shimast.Node) bool {
-	parent := node.Parent
-	for parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
-		parent = parent.Parent
-	}
-	if parent == nil {
-		return false
-	}
-	if parent.Kind == shimast.KindBinaryExpression {
-		bin := parent.AsBinaryExpression()
-		if bin != nil && bin.OperatorToken != nil &&
-			bin.OperatorToken.Kind == shimast.KindEqualsToken &&
-			stripParens(bin.Left) == node {
-			return true
-		}
-	}
-	return false
+  parent := node.Parent
+  for parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
+    parent = parent.Parent
+  }
+  if parent == nil {
+    return false
+  }
+  if parent.Kind == shimast.KindBinaryExpression {
+    bin := parent.AsBinaryExpression()
+    if bin != nil && bin.OperatorToken != nil &&
+      bin.OperatorToken.Kind == shimast.KindEqualsToken &&
+      stripParens(bin.Left) == node {
+      return true
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(unicornNoUnreadableArrayDestructuring{})
+  Register(unicornNoUnreadableArrayDestructuring{})
 }

package/linthost/rules_unicorn_no_unreadable_iife.go

@@ -20,31 +20,31 @@ type unicornNoUnreadableIIFE struct{}
 
 func (unicornNoUnreadableIIFE) Name() string { return "unicorn/no-unreadable-iife" }
 func (unicornNoUnreadableIIFE) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoUnreadableIIFE) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	if call.Expression.Kind != shimast.KindParenthesizedExpression {
-		return
-	}
-	paren := call.Expression.AsParenthesizedExpression()
-	if paren == nil || paren.Expression == nil ||
-		paren.Expression.Kind != shimast.KindArrowFunction {
-		return
-	}
-	arrow := paren.Expression.AsArrowFunction()
-	if arrow == nil || arrow.Body == nil {
-		return
-	}
-	if arrow.Body.Kind != shimast.KindCallExpression {
-		return
-	}
-	ctx.Report(node, "Avoid unreadable IIFEs — extract the function.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if call.Expression.Kind != shimast.KindParenthesizedExpression {
+    return
+  }
+  paren := call.Expression.AsParenthesizedExpression()
+  if paren == nil || paren.Expression == nil ||
+    paren.Expression.Kind != shimast.KindArrowFunction {
+    return
+  }
+  arrow := paren.Expression.AsArrowFunction()
+  if arrow == nil || arrow.Body == nil {
+    return
+  }
+  if arrow.Body.Kind != shimast.KindCallExpression {
+    return
+  }
+  ctx.Report(node, "Avoid unreadable IIFEs — extract the function.")
 }
 
 func init() {
-	Register(unicornNoUnreadableIIFE{})
+  Register(unicornNoUnreadableIIFE{})
 }

package/linthost/rules_unicorn_no_useless_collection_argument.go

@@ -19,45 +19,45 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoUselessCollectionArgument struct{}
 
 func (unicornNoUselessCollectionArgument) Name() string {
-	return "unicorn/no-useless-collection-argument"
+  return "unicorn/no-useless-collection-argument"
 }
 func (unicornNoUselessCollectionArgument) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression}
+  return []shimast.Kind{shimast.KindNewExpression}
 }
 func (unicornNoUselessCollectionArgument) Check(ctx *Context, node *shimast.Node) {
-	ne := node.AsNewExpression()
-	if ne == nil {
-		return
-	}
-	switch identifierText(ne.Expression) {
-	case "Set", "Map", "WeakSet", "WeakMap":
-	default:
-		return
-	}
-	if ne.Arguments == nil || len(ne.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := stripParens(ne.Arguments.Nodes[0])
-	if arg == nil {
-		return
-	}
-	switch arg.Kind {
-	case shimast.KindNullKeyword, shimast.KindUndefinedKeyword:
-		ctx.Report(node, "Don't pass a useless initializer to `new <Collection>()`.")
-		return
-	case shimast.KindIdentifier:
-		if identifierText(arg) == "undefined" {
-			ctx.Report(node, "Don't pass a useless initializer to `new <Collection>()`.")
-		}
-		return
-	case shimast.KindArrayLiteralExpression:
-		if arr := arg.AsArrayLiteralExpression(); arr != nil &&
-			(arr.Elements == nil || len(arr.Elements.Nodes) == 0) {
-			ctx.Report(node, "Don't pass a useless initializer to `new <Collection>()`.")
-		}
-	}
+  ne := node.AsNewExpression()
+  if ne == nil {
+    return
+  }
+  switch identifierText(ne.Expression) {
+  case "Set", "Map", "WeakSet", "WeakMap":
+  default:
+    return
+  }
+  if ne.Arguments == nil || len(ne.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(ne.Arguments.Nodes[0])
+  if arg == nil {
+    return
+  }
+  switch arg.Kind {
+  case shimast.KindNullKeyword, shimast.KindUndefinedKeyword:
+    ctx.Report(node, "Don't pass a useless initializer to `new <Collection>()`.")
+    return
+  case shimast.KindIdentifier:
+    if identifierText(arg) == "undefined" {
+      ctx.Report(node, "Don't pass a useless initializer to `new <Collection>()`.")
+    }
+    return
+  case shimast.KindArrayLiteralExpression:
+    if arr := arg.AsArrayLiteralExpression(); arr != nil &&
+      (arr.Elements == nil || len(arr.Elements.Nodes) == 0) {
+      ctx.Report(node, "Don't pass a useless initializer to `new <Collection>()`.")
+    }
+  }
 }
 
 func init() {
-	Register(unicornNoUselessCollectionArgument{})
+  Register(unicornNoUselessCollectionArgument{})
 }

package/linthost/rules_unicorn_no_useless_error_capture_stack_trace.go

@@ -18,29 +18,29 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoUselessErrorCaptureStackTrace struct{}
 
 func (unicornNoUselessErrorCaptureStackTrace) Name() string {
-	return "unicorn/no-useless-error-capture-stack-trace"
+  return "unicorn/no-useless-error-capture-stack-trace"
 }
 func (unicornNoUselessErrorCaptureStackTrace) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoUselessErrorCaptureStackTrace) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	if !isMatchingPropertyAccess(call.Expression, "Error", "captureStackTrace") {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) < 1 {
-		return
-	}
-	first := stripParens(call.Arguments.Nodes[0])
-	if first == nil || first.Kind != shimast.KindThisKeyword {
-		return
-	}
-	ctx.Report(node, "Don't call `Error.captureStackTrace(this, ...)` in an `Error` subclass — the default capture already happens.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if !isMatchingPropertyAccess(call.Expression, "Error", "captureStackTrace") {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 1 {
+    return
+  }
+  first := stripParens(call.Arguments.Nodes[0])
+  if first == nil || first.Kind != shimast.KindThisKeyword {
+    return
+  }
+  ctx.Report(node, "Don't call `Error.captureStackTrace(this, ...)` in an `Error` subclass — the default capture already happens.")
 }
 
 func init() {
-	Register(unicornNoUselessErrorCaptureStackTrace{})
+  Register(unicornNoUselessErrorCaptureStackTrace{})
 }

package/linthost/rules_unicorn_no_useless_fallback_in_spread.go

@@ -22,60 +22,60 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoUselessFallbackInSpread struct{}
 
 func (unicornNoUselessFallbackInSpread) Name() string {
-	return "unicorn/no-useless-fallback-in-spread"
+  return "unicorn/no-useless-fallback-in-spread"
 }
 func (unicornNoUselessFallbackInSpread) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSpreadElement, shimast.KindSpreadAssignment}
+  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.")
-		}
-	}
+  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{})
+  Register(unicornNoUselessFallbackInSpread{})
 }

package/linthost/rules_unicorn_no_useless_iterator_to_array.go

@@ -21,52 +21,52 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoUselessIteratorToArray struct{}
 
 func (unicornNoUselessIteratorToArray) Name() string {
-	return "unicorn/no-useless-iterator-to-array"
+  return "unicorn/no-useless-iterator-to-array"
 }
 func (unicornNoUselessIteratorToArray) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindArrayLiteralExpression}
+  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.")
+  // 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{})
+  Register(unicornNoUselessIteratorToArray{})
 }