@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_unicorn_prefer_query_selector.go

@@ -17,40 +17,40 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornPreferQuerySelectorMethods = map[string]struct{}{
-	"getElementById":         {},
-	"getElementsByClassName": {},
-	"getElementsByTagName":   {},
+  "getElementById":         {},
+  "getElementsByClassName": {},
+  "getElementsByTagName":   {},
 }
 
 type unicornPreferQuerySelector struct{}
 
 func (unicornPreferQuerySelector) Name() string { return "unicorn/prefer-query-selector" }
 func (unicornPreferQuerySelector) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferQuerySelector) 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
-	}
-	method := identifierText(access.Name())
-	if _, ok := unicornPreferQuerySelectorMethods[method]; !ok {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := call.Arguments.Nodes[0]
-	if arg == nil || arg.Kind != shimast.KindStringLiteral {
-		return
-	}
-	ctx.Report(node, "Prefer `querySelector` / `querySelectorAll` over `"+method+"`.")
+  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 := unicornPreferQuerySelectorMethods[method]; !ok {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := call.Arguments.Nodes[0]
+  if arg == nil || arg.Kind != shimast.KindStringLiteral {
+    return
+  }
+  ctx.Report(node, "Prefer `querySelector` / `querySelectorAll` over `"+method+"`.")
 }
 
 func init() {
-	Register(unicornPreferQuerySelector{})
+  Register(unicornPreferQuerySelector{})
 }

package/linthost/rules_unicorn_prefer_reflect_apply.go

@@ -18,19 +18,19 @@ type unicornPreferReflectApply struct{}
 
 func (unicornPreferReflectApply) Name() string { return "unicorn/prefer-reflect-apply" }
 func (unicornPreferReflectApply) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferReflectApply) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	if nodeText(ctx.File, call.Expression) != "Function.prototype.apply.call" {
-		return
-	}
-	ctx.Report(node, "Prefer `Reflect.apply` over `Function.prototype.apply.call`.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if nodeText(ctx.File, call.Expression) != "Function.prototype.apply.call" {
+    return
+  }
+  ctx.Report(node, "Prefer `Reflect.apply` over `Function.prototype.apply.call`.")
 }
 
 func init() {
-	Register(unicornPreferReflectApply{})
+  Register(unicornPreferReflectApply{})
 }

package/linthost/rules_unicorn_prefer_regexp_test_rule.go

@@ -19,62 +19,62 @@ type unicornPreferRegexpTest struct{}
 
 func (unicornPreferRegexpTest) Name() string { return "unicorn/prefer-regexp-test" }
 func (unicornPreferRegexpTest) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferRegexpTest) 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 "match", "exec":
-	default:
-		return
-	}
-	if !unicornPreferRegexpTestInBooleanPosition(node) {
-		return
-	}
-	ctx.Report(node, "Prefer `RegExp#test()` over `String#match()` / `RegExp#exec()` in a boolean context.")
+  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 "match", "exec":
+  default:
+    return
+  }
+  if !unicornPreferRegexpTestInBooleanPosition(node) {
+    return
+  }
+  ctx.Report(node, "Prefer `RegExp#test()` over `String#match()` / `RegExp#exec()` in a boolean context.")
 }
 
 // unicornPreferRegexpTestInBooleanPosition reports whether `node` sits in
 // a position that consumes only its truthiness: the condition of an
 // `if` / ternary, the operand of `!`, or one side of `&&` / `||` / `??`.
 func unicornPreferRegexpTestInBooleanPosition(node *shimast.Node) bool {
-	parent := node.Parent
-	if parent == nil {
-		return false
-	}
-	switch parent.Kind {
-	case shimast.KindIfStatement:
-		ifStmt := parent.AsIfStatement()
-		return ifStmt != nil && ifStmt.Expression == node
-	case shimast.KindConditionalExpression:
-		cond := parent.AsConditionalExpression()
-		return cond != nil && cond.Condition == node
-	case shimast.KindPrefixUnaryExpression:
-		pre := parent.AsPrefixUnaryExpression()
-		return pre != nil && pre.Operator == shimast.KindExclamationToken
-	case shimast.KindBinaryExpression:
-		bin := parent.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil {
-			return false
-		}
-		switch bin.OperatorToken.Kind {
-		case shimast.KindAmpersandAmpersandToken,
-			shimast.KindBarBarToken,
-			shimast.KindQuestionQuestionToken:
-			return true
-		}
-	}
-	return false
+  parent := node.Parent
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindIfStatement:
+    ifStmt := parent.AsIfStatement()
+    return ifStmt != nil && ifStmt.Expression == node
+  case shimast.KindConditionalExpression:
+    cond := parent.AsConditionalExpression()
+    return cond != nil && cond.Condition == node
+  case shimast.KindPrefixUnaryExpression:
+    pre := parent.AsPrefixUnaryExpression()
+    return pre != nil && pre.Operator == shimast.KindExclamationToken
+  case shimast.KindBinaryExpression:
+    bin := parent.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return false
+    }
+    switch bin.OperatorToken.Kind {
+    case shimast.KindAmpersandAmpersandToken,
+      shimast.KindBarBarToken,
+      shimast.KindQuestionQuestionToken:
+      return true
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(unicornPreferRegexpTest{})
+  Register(unicornPreferRegexpTest{})
 }

package/linthost/rules_unicorn_prefer_response_static_json.go

@@ -17,37 +17,37 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferResponseStaticJson struct{}
 
 func (unicornPreferResponseStaticJson) Name() string {
-	return "unicorn/prefer-response-static-json"
+  return "unicorn/prefer-response-static-json"
 }
 func (unicornPreferResponseStaticJson) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression}
+  return []shimast.Kind{shimast.KindNewExpression}
 }
 func (unicornPreferResponseStaticJson) Check(ctx *Context, node *shimast.Node) {
-	ne := node.AsNewExpression()
-	if ne == nil || identifierText(ne.Expression) != "Response" {
-		return
-	}
-	if ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
-		return
-	}
-	first := stripParens(ne.Arguments.Nodes[0])
-	if first == nil || first.Kind != shimast.KindCallExpression {
-		return
-	}
-	call := first.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil ||
-		identifierText(access.Expression) != "JSON" ||
-		identifierText(access.Name()) != "stringify" {
-		return
-	}
-	ctx.Report(node, "Prefer `Response.json(value)` over `new Response(JSON.stringify(value), ...)`.")
+  ne := node.AsNewExpression()
+  if ne == nil || identifierText(ne.Expression) != "Response" {
+    return
+  }
+  if ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
+    return
+  }
+  first := stripParens(ne.Arguments.Nodes[0])
+  if first == nil || first.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := first.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil ||
+    identifierText(access.Expression) != "JSON" ||
+    identifierText(access.Name()) != "stringify" {
+    return
+  }
+  ctx.Report(node, "Prefer `Response.json(value)` over `new Response(JSON.stringify(value), ...)`.")
 }
 
 func init() {
-	Register(unicornPreferResponseStaticJson{})
+  Register(unicornPreferResponseStaticJson{})
 }

package/linthost/rules_unicorn_prefer_set_has.go

@@ -18,25 +18,25 @@ type unicornPreferSetHas struct{}
 
 func (unicornPreferSetHas) Name() string { return "unicorn/prefer-set-has" }
 func (unicornPreferSetHas) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferSetHas) 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()) != "includes" {
-		return
-	}
-	receiver := stripParens(access.Expression)
-	if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
-		return
-	}
-	ctx.Report(node, "Prefer `Set#has()` over `Array#includes()` for repeated membership lookups against a constant collection.")
+  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()) != "includes" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  ctx.Report(node, "Prefer `Set#has()` over `Array#includes()` for repeated membership lookups against a constant collection.")
 }
 
 func init() {
-	Register(unicornPreferSetHas{})
+  Register(unicornPreferSetHas{})
 }

package/linthost/rules_unicorn_prefer_set_size.go

@@ -18,31 +18,31 @@ type unicornPreferSetSize struct{}
 
 func (unicornPreferSetSize) Name() string { return "unicorn/prefer-set-size" }
 func (unicornPreferSetSize) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
 }
 func (unicornPreferSetSize) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Name()) != "length" {
-		return
-	}
-	receiver := stripParens(access.Expression)
-	if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
-		return
-	}
-	arr := receiver.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
-	}
-	ctx.Report(node, "Prefer `Set#size` over `[...set].length`.")
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "length" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  arr := receiver.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
+  }
+  ctx.Report(node, "Prefer `Set#size` over `[...set].length`.")
 }
 
 func init() {
-	Register(unicornPreferSetSize{})
+  Register(unicornPreferSetSize{})
 }

package/linthost/rules_unicorn_prefer_simple_condition_first.go

@@ -22,13 +22,13 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferSimpleConditionFirst struct{}
 
 func (unicornPreferSimpleConditionFirst) Name() string {
-	return "unicorn/prefer-simple-condition-first"
+  return "unicorn/prefer-simple-condition-first"
 }
 func (unicornPreferSimpleConditionFirst) Visits() []shimast.Kind { return nil }
 func (unicornPreferSimpleConditionFirst) Check(_ *Context, _ *shimast.Node) {
-	// Intentionally empty — see file header for the escape-hatch rationale.
+  // Intentionally empty — see file header for the escape-hatch rationale.
 }
 
 func init() {
-	Register(unicornPreferSimpleConditionFirst{})
+  Register(unicornPreferSimpleConditionFirst{})
 }

package/linthost/rules_unicorn_prefer_single_call.go

@@ -22,40 +22,40 @@ type unicornPreferSingleCall struct{}
 
 func (unicornPreferSingleCall) Name() string { return "unicorn/prefer-single-call" }
 func (unicornPreferSingleCall) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBlock, shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindBlock, shimast.KindSourceFile}
 }
 func (unicornPreferSingleCall) Check(ctx *Context, node *shimast.Node) {
-	var stmts []*shimast.Node
-	switch node.Kind {
-	case shimast.KindBlock:
-		block := node.AsBlock()
-		if block == nil || block.Statements == nil {
-			return
-		}
-		stmts = block.Statements.Nodes
-	case shimast.KindSourceFile:
-		file := node.AsSourceFile()
-		if file == nil || file.Statements == nil {
-			return
-		}
-		stmts = file.Statements.Nodes
-	default:
-		return
-	}
-	for i := 1; i < len(stmts); i++ {
-		prevReceiver, prevMethod := unicornPreferSingleCallExtract(ctx, stmts[i-1])
-		if prevReceiver == "" {
-			continue
-		}
-		currReceiver, currMethod := unicornPreferSingleCallExtract(ctx, stmts[i])
-		if currReceiver == "" {
-			continue
-		}
-		if prevReceiver != currReceiver || prevMethod != currMethod {
-			continue
-		}
-		ctx.Report(stmts[i], "Combine consecutive `"+currMethod+"` calls with multiple arguments into a single call.")
-	}
+  var stmts []*shimast.Node
+  switch node.Kind {
+  case shimast.KindBlock:
+    block := node.AsBlock()
+    if block == nil || block.Statements == nil {
+      return
+    }
+    stmts = block.Statements.Nodes
+  case shimast.KindSourceFile:
+    file := node.AsSourceFile()
+    if file == nil || file.Statements == nil {
+      return
+    }
+    stmts = file.Statements.Nodes
+  default:
+    return
+  }
+  for i := 1; i < len(stmts); i++ {
+    prevReceiver, prevMethod := unicornPreferSingleCallExtract(ctx, stmts[i-1])
+    if prevReceiver == "" {
+      continue
+    }
+    currReceiver, currMethod := unicornPreferSingleCallExtract(ctx, stmts[i])
+    if currReceiver == "" {
+      continue
+    }
+    if prevReceiver != currReceiver || prevMethod != currMethod {
+      continue
+    }
+    ctx.Report(stmts[i], "Combine consecutive `"+currMethod+"` calls with multiple arguments into a single call.")
+  }
 }
 
 // unicornPreferSingleCallExtract returns (receiverText, methodName) for a
@@ -63,34 +63,34 @@ func (unicornPreferSingleCall) Check(ctx *Context, node *shimast.Node) {
 // of the variadic appenders the rule targets. Returns ("", "") for any
 // other shape.
 func unicornPreferSingleCallExtract(ctx *Context, stmt *shimast.Node) (string, string) {
-	if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
-		return "", ""
-	}
-	exprStmt := stmt.AsExpressionStatement()
-	if exprStmt == nil || exprStmt.Expression == nil {
-		return "", ""
-	}
-	call := stripParens(exprStmt.Expression)
-	if call == nil || call.Kind != shimast.KindCallExpression {
-		return "", ""
-	}
-	c := call.AsCallExpression()
-	if c == nil || c.Expression == nil || c.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return "", ""
-	}
-	access := c.Expression.AsPropertyAccessExpression()
-	if access == nil || access.Expression == nil {
-		return "", ""
-	}
-	method := identifierText(access.Name())
-	switch method {
-	case "push", "unshift", "addEventListener", "removeEventListener":
-	default:
-		return "", ""
-	}
-	return nodeText(ctx.File, access.Expression), method
+  if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+    return "", ""
+  }
+  exprStmt := stmt.AsExpressionStatement()
+  if exprStmt == nil || exprStmt.Expression == nil {
+    return "", ""
+  }
+  call := stripParens(exprStmt.Expression)
+  if call == nil || call.Kind != shimast.KindCallExpression {
+    return "", ""
+  }
+  c := call.AsCallExpression()
+  if c == nil || c.Expression == nil || c.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return "", ""
+  }
+  access := c.Expression.AsPropertyAccessExpression()
+  if access == nil || access.Expression == nil {
+    return "", ""
+  }
+  method := identifierText(access.Name())
+  switch method {
+  case "push", "unshift", "addEventListener", "removeEventListener":
+  default:
+    return "", ""
+  }
+  return nodeText(ctx.File, access.Expression), method
 }
 
 func init() {
-	Register(unicornPreferSingleCall{})
+  Register(unicornPreferSingleCall{})
 }

package/linthost/rules_unicorn_prefer_spread.go

@@ -19,33 +19,33 @@ type unicornPreferSpread struct{}
 
 func (unicornPreferSpread) Name() string { return "unicorn/prefer-spread" }
 func (unicornPreferSpread) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferSpread) 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
-	}
-	if identifierText(access.Name()) != "from" {
-		return
-	}
-	receiver := stripParens(access.Expression)
-	if identifierText(receiver) != "Array" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	ctx.Report(node, "Prefer spread `[...x]` over `Array.from(x)` for single-arg shallow copies.")
+  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
+  }
+  if identifierText(access.Name()) != "from" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if identifierText(receiver) != "Array" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  ctx.Report(node, "Prefer spread `[...x]` over `Array.from(x)` for single-arg shallow copies.")
 }
 
 func init() {
-	Register(unicornPreferSpread{})
+  Register(unicornPreferSpread{})
 }

package/linthost/rules_unicorn_prefer_string_raw.go

@@ -16,28 +16,28 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type unicornPreferStringRaw struct{}
 
 func (unicornPreferStringRaw) Name() string { return "unicorn/prefer-string-raw" }
 func (unicornPreferStringRaw) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+  return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
 }
 func (unicornPreferStringRaw) Check(ctx *Context, node *shimast.Node) {
-	raw := nodeText(ctx.File, node)
-	if raw == "" {
-		return
-	}
-	if !strings.Contains(raw, `\\`) {
-		return
-	}
-	ctx.Report(node, "Prefer `String.raw` for strings with backslash escapes.")
+  raw := nodeText(ctx.File, node)
+  if raw == "" {
+    return
+  }
+  if !strings.Contains(raw, `\\`) {
+    return
+  }
+  ctx.Report(node, "Prefer `String.raw` for strings with backslash escapes.")
 }
 
 func init() {
-	Register(unicornPreferStringRaw{})
+  Register(unicornPreferStringRaw{})
 }