@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_unicorn_prefer_logical_operator_over_ternary.go

@@ -18,31 +18,31 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferLogicalOperatorOverTernary struct{}
 
 func (unicornPreferLogicalOperatorOverTernary) Name() string {
-	return "unicorn/prefer-logical-operator-over-ternary"
+  return "unicorn/prefer-logical-operator-over-ternary"
 }
 func (unicornPreferLogicalOperatorOverTernary) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindConditionalExpression}
+  return []shimast.Kind{shimast.KindConditionalExpression}
 }
 func (unicornPreferLogicalOperatorOverTernary) Check(ctx *Context, node *shimast.Node) {
-	cond := node.AsConditionalExpression()
-	if cond == nil {
-		return
-	}
-	condExpr := stripParens(cond.Condition)
-	whenTrue := stripParens(cond.WhenTrue)
-	if condExpr == nil || whenTrue == nil {
-		return
-	}
-	condText := nodeText(ctx.File, condExpr)
-	if condText == "" {
-		return
-	}
-	if condText != nodeText(ctx.File, whenTrue) {
-		return
-	}
-	ctx.Report(node, "Prefer `a || b` / `a ?? b` over the equivalent ternary `a ? a : b`.")
+  cond := node.AsConditionalExpression()
+  if cond == nil {
+    return
+  }
+  condExpr := stripParens(cond.Condition)
+  whenTrue := stripParens(cond.WhenTrue)
+  if condExpr == nil || whenTrue == nil {
+    return
+  }
+  condText := nodeText(ctx.File, condExpr)
+  if condText == "" {
+    return
+  }
+  if condText != nodeText(ctx.File, whenTrue) {
+    return
+  }
+  ctx.Report(node, "Prefer `a || b` / `a ?? b` over the equivalent ternary `a ? a : b`.")
 }
 
 func init() {
-	Register(unicornPreferLogicalOperatorOverTernary{})
+  Register(unicornPreferLogicalOperatorOverTernary{})
 }

package/linthost/rules_unicorn_prefer_math_min_max.go

@@ -19,42 +19,42 @@ type unicornPreferMathMinMax struct{}
 
 func (unicornPreferMathMinMax) Name() string { return "unicorn/prefer-math-min-max" }
 func (unicornPreferMathMinMax) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindConditionalExpression}
+  return []shimast.Kind{shimast.KindConditionalExpression}
 }
 func (unicornPreferMathMinMax) Check(ctx *Context, node *shimast.Node) {
-	cond := node.AsConditionalExpression()
-	if cond == nil {
-		return
-	}
-	condExpr := stripParens(cond.Condition)
-	if condExpr == nil || condExpr.Kind != shimast.KindBinaryExpression {
-		return
-	}
-	bin := condExpr.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil {
-		return
-	}
-	switch bin.OperatorToken.Kind {
-	case shimast.KindLessThanToken,
-		shimast.KindLessThanEqualsToken,
-		shimast.KindGreaterThanToken,
-		shimast.KindGreaterThanEqualsToken:
-	default:
-		return
-	}
-	leftText := nodeText(ctx.File, stripParens(bin.Left))
-	rightText := nodeText(ctx.File, stripParens(bin.Right))
-	if leftText == "" || rightText == "" {
-		return
-	}
-	trueText := nodeText(ctx.File, stripParens(cond.WhenTrue))
-	falseText := nodeText(ctx.File, stripParens(cond.WhenFalse))
-	if (leftText == trueText && rightText == falseText) ||
-		(leftText == falseText && rightText == trueText) {
-		ctx.Report(node, "Prefer `Math.min` / `Math.max` over a conditional comparing the same two values.")
-	}
+  cond := node.AsConditionalExpression()
+  if cond == nil {
+    return
+  }
+  condExpr := stripParens(cond.Condition)
+  if condExpr == nil || condExpr.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  bin := condExpr.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindLessThanToken,
+    shimast.KindLessThanEqualsToken,
+    shimast.KindGreaterThanToken,
+    shimast.KindGreaterThanEqualsToken:
+  default:
+    return
+  }
+  leftText := nodeText(ctx.File, stripParens(bin.Left))
+  rightText := nodeText(ctx.File, stripParens(bin.Right))
+  if leftText == "" || rightText == "" {
+    return
+  }
+  trueText := nodeText(ctx.File, stripParens(cond.WhenTrue))
+  falseText := nodeText(ctx.File, stripParens(cond.WhenFalse))
+  if (leftText == trueText && rightText == falseText) ||
+    (leftText == falseText && rightText == trueText) {
+    ctx.Report(node, "Prefer `Math.min` / `Math.max` over a conditional comparing the same two values.")
+  }
 }
 
 func init() {
-	Register(unicornPreferMathMinMax{})
+  Register(unicornPreferMathMinMax{})
 }

package/linthost/rules_unicorn_prefer_math_trunc.go

@@ -22,41 +22,41 @@ type unicornPreferMathTrunc struct{}
 
 func (unicornPreferMathTrunc) Name() string { return "unicorn/prefer-math-trunc" }
 func (unicornPreferMathTrunc) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression, shimast.KindPrefixUnaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression, shimast.KindPrefixUnaryExpression}
 }
 func (unicornPreferMathTrunc) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindBinaryExpression:
-		expr := node.AsBinaryExpression()
-		if expr == nil || expr.OperatorToken == nil ||
-			expr.OperatorToken.Kind != shimast.KindBarToken {
-			return
-		}
-		right := stripParens(expr.Right)
-		if right == nil || right.Kind != shimast.KindNumericLiteral {
-			return
-		}
-		if numericLiteralText(right) != "0" {
-			return
-		}
-		ctx.Report(node, "Prefer `Math.trunc(x)` over `~~x` / `x | 0` for integer truncation.")
-	case shimast.KindPrefixUnaryExpression:
-		outer := node.AsPrefixUnaryExpression()
-		if outer == nil || outer.Operator != shimast.KindTildeToken || outer.Operand == nil {
-			return
-		}
-		operand := stripParens(outer.Operand)
-		if operand == nil || operand.Kind != shimast.KindPrefixUnaryExpression {
-			return
-		}
-		inner := operand.AsPrefixUnaryExpression()
-		if inner == nil || inner.Operator != shimast.KindTildeToken {
-			return
-		}
-		ctx.Report(node, "Prefer `Math.trunc(x)` over `~~x` / `x | 0` for integer truncation.")
-	}
+  switch node.Kind {
+  case shimast.KindBinaryExpression:
+    expr := node.AsBinaryExpression()
+    if expr == nil || expr.OperatorToken == nil ||
+      expr.OperatorToken.Kind != shimast.KindBarToken {
+      return
+    }
+    right := stripParens(expr.Right)
+    if right == nil || right.Kind != shimast.KindNumericLiteral {
+      return
+    }
+    if numericLiteralText(right) != "0" {
+      return
+    }
+    ctx.Report(node, "Prefer `Math.trunc(x)` over `~~x` / `x | 0` for integer truncation.")
+  case shimast.KindPrefixUnaryExpression:
+    outer := node.AsPrefixUnaryExpression()
+    if outer == nil || outer.Operator != shimast.KindTildeToken || outer.Operand == nil {
+      return
+    }
+    operand := stripParens(outer.Operand)
+    if operand == nil || operand.Kind != shimast.KindPrefixUnaryExpression {
+      return
+    }
+    inner := operand.AsPrefixUnaryExpression()
+    if inner == nil || inner.Operator != shimast.KindTildeToken {
+      return
+    }
+    ctx.Report(node, "Prefer `Math.trunc(x)` over `~~x` / `x | 0` for integer truncation.")
+  }
 }
 
 func init() {
-	Register(unicornPreferMathTrunc{})
+  Register(unicornPreferMathTrunc{})
 }

package/linthost/rules_unicorn_prefer_modern_dom_apis.go

@@ -15,33 +15,33 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornPreferModernDomApisMethods = map[string]struct{}{
-	"insertBefore":       {},
-	"replaceChild":       {},
-	"insertAdjacentText": {},
+  "insertBefore":       {},
+  "replaceChild":       {},
+  "insertAdjacentText": {},
 }
 
 type unicornPreferModernDomApis struct{}
 
 func (unicornPreferModernDomApis) Name() string { return "unicorn/prefer-modern-dom-apis" }
 func (unicornPreferModernDomApis) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferModernDomApis) 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 := unicornPreferModernDomApisMethods[method]; !ok {
-		return
-	}
-	ctx.Report(node, "Prefer `before` / `after` / `replaceWith` 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 := unicornPreferModernDomApisMethods[method]; !ok {
+    return
+  }
+  ctx.Report(node, "Prefer `before` / `after` / `replaceWith` over `"+method+"`.")
 }
 
 func init() {
-	Register(unicornPreferModernDomApis{})
+  Register(unicornPreferModernDomApis{})
 }

package/linthost/rules_unicorn_prefer_modern_math_apis.go

@@ -19,52 +19,52 @@ type unicornPreferModernMathApis struct{}
 
 func (unicornPreferModernMathApis) Name() string { return "unicorn/prefer-modern-math-apis" }
 func (unicornPreferModernMathApis) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (unicornPreferModernMathApis) Check(ctx *Context, node *shimast.Node) {
-	bin := node.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil ||
-		bin.OperatorToken.Kind != shimast.KindAsteriskToken {
-		return
-	}
-	left := stripParens(bin.Left)
-	right := stripParens(bin.Right)
-	if unicornPreferModernMathApisMatchesPair(left, right) ||
-		unicornPreferModernMathApisMatchesPair(right, left) {
-		ctx.Report(node, "Prefer `Math.log10(x)` / `Math.log2(x)` over `Math.log(x) * Math.LOG10E` / `Math.log(x) * Math.LOG2E`.")
-	}
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil ||
+    bin.OperatorToken.Kind != shimast.KindAsteriskToken {
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if unicornPreferModernMathApisMatchesPair(left, right) ||
+    unicornPreferModernMathApisMatchesPair(right, left) {
+    ctx.Report(node, "Prefer `Math.log10(x)` / `Math.log2(x)` over `Math.log(x) * Math.LOG10E` / `Math.log(x) * Math.LOG2E`.")
+  }
 }
 
 // unicornPreferModernMathApisMatchesPair reports whether `callSide` is
 // `Math.log(...)` and `constSide` is `Math.LOG10E` or `Math.LOG2E`.
 func unicornPreferModernMathApisMatchesPair(callSide, constSide *shimast.Node) bool {
-	if callSide == nil || constSide == nil {
-		return false
-	}
-	if callSide.Kind != shimast.KindCallExpression {
-		return false
-	}
-	call := callSide.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return false
-	}
-	if !isMatchingPropertyAccess(call.Expression, "Math", "log") {
-		return false
-	}
-	if constSide.Kind != shimast.KindPropertyAccessExpression {
-		return false
-	}
-	prop := constSide.AsPropertyAccessExpression()
-	if prop == nil || identifierText(prop.Expression) != "Math" {
-		return false
-	}
-	switch identifierText(prop.Name()) {
-	case "LOG10E", "LOG2E":
-		return true
-	}
-	return false
+  if callSide == nil || constSide == nil {
+    return false
+  }
+  if callSide.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := callSide.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return false
+  }
+  if !isMatchingPropertyAccess(call.Expression, "Math", "log") {
+    return false
+  }
+  if constSide.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  prop := constSide.AsPropertyAccessExpression()
+  if prop == nil || identifierText(prop.Expression) != "Math" {
+    return false
+  }
+  switch identifierText(prop.Name()) {
+  case "LOG10E", "LOG2E":
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(unicornPreferModernMathApis{})
+  Register(unicornPreferModernMathApis{})
 }

package/linthost/rules_unicorn_prefer_module.go

@@ -20,31 +20,31 @@ type unicornPreferModule struct{}
 
 func (unicornPreferModule) Name() string { return "unicorn/prefer-module" }
 func (unicornPreferModule) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression, shimast.KindIdentifier}
+  return []shimast.Kind{shimast.KindCallExpression, shimast.KindIdentifier}
 }
 func (unicornPreferModule) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil || call.Expression == nil {
-			return
-		}
-		if identifierText(call.Expression) != "require" {
-			return
-		}
-		ctx.Report(node, "Prefer ES modules over CommonJS — use `import` / `import.meta.dirname` / `import.meta.filename`.")
-	case shimast.KindIdentifier:
-		name := identifierText(node)
-		if name != "__dirname" && name != "__filename" {
-			return
-		}
-		if !isUnicornValuePositionIdentifier(node) {
-			return
-		}
-		ctx.Report(node, "Prefer ES modules over CommonJS — use `import` / `import.meta.dirname` / `import.meta.filename`.")
-	}
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil || call.Expression == nil {
+      return
+    }
+    if identifierText(call.Expression) != "require" {
+      return
+    }
+    ctx.Report(node, "Prefer ES modules over CommonJS — use `import` / `import.meta.dirname` / `import.meta.filename`.")
+  case shimast.KindIdentifier:
+    name := identifierText(node)
+    if name != "__dirname" && name != "__filename" {
+      return
+    }
+    if !isUnicornValuePositionIdentifier(node) {
+      return
+    }
+    ctx.Report(node, "Prefer ES modules over CommonJS — use `import` / `import.meta.dirname` / `import.meta.filename`.")
+  }
 }
 
 func init() {
-	Register(unicornPreferModule{})
+  Register(unicornPreferModule{})
 }

package/linthost/rules_unicorn_prefer_native_coercion_functions.go

@@ -18,42 +18,42 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferNativeCoercionFunctions struct{}
 
 func (unicornPreferNativeCoercionFunctions) Name() string {
-	return "unicorn/prefer-native-coercion-functions"
+  return "unicorn/prefer-native-coercion-functions"
 }
 func (unicornPreferNativeCoercionFunctions) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindArrowFunction, shimast.KindFunctionExpression}
+  return []shimast.Kind{shimast.KindArrowFunction, shimast.KindFunctionExpression}
 }
 func (unicornPreferNativeCoercionFunctions) Check(ctx *Context, node *shimast.Node) {
-	params := node.Parameters()
-	if len(params) != 1 {
-		return
-	}
-	paramName := parameterIdentifierName(params[0])
-	if paramName == "" {
-		return
-	}
-	var body *shimast.Node
-	switch node.Kind {
-	case shimast.KindArrowFunction:
-		if arrow := node.AsArrowFunction(); arrow != nil {
-			body = arrow.Body
-		}
-	case shimast.KindFunctionExpression:
-		if fn := node.AsFunctionExpression(); fn != nil {
-			body = fn.Body
-		}
-	}
-	if body == nil {
-		return
-	}
-	call := unicornPreferNativeCoercionBodyCall(body)
-	if call == nil {
-		return
-	}
-	if !unicornPreferNativeCoercionIsCoercion(call, paramName) {
-		return
-	}
-	ctx.Report(node, "Use the bare `String` / `Number` / `Boolean` / `BigInt` function reference instead of an arrow wrapper.")
+  params := node.Parameters()
+  if len(params) != 1 {
+    return
+  }
+  paramName := parameterIdentifierName(params[0])
+  if paramName == "" {
+    return
+  }
+  var body *shimast.Node
+  switch node.Kind {
+  case shimast.KindArrowFunction:
+    if arrow := node.AsArrowFunction(); arrow != nil {
+      body = arrow.Body
+    }
+  case shimast.KindFunctionExpression:
+    if fn := node.AsFunctionExpression(); fn != nil {
+      body = fn.Body
+    }
+  }
+  if body == nil {
+    return
+  }
+  call := unicornPreferNativeCoercionBodyCall(body)
+  if call == nil {
+    return
+  }
+  if !unicornPreferNativeCoercionIsCoercion(call, paramName) {
+    return
+  }
+  ctx.Report(node, "Use the bare `String` / `Number` / `Boolean` / `BigInt` function reference instead of an arrow wrapper.")
 }
 
 // unicornPreferNativeCoercionBodyCall normalizes a function body to the
@@ -61,54 +61,54 @@ func (unicornPreferNativeCoercionFunctions) Check(ctx *Context, node *shimast.No
 // directly; a block body must contain exactly one `return <expr>;` and
 // the returned expression must itself be a call.
 func unicornPreferNativeCoercionBodyCall(body *shimast.Node) *shimast.Node {
-	if body == nil {
-		return nil
-	}
-	if body.Kind != shimast.KindBlock {
-		expr := stripParens(body)
-		if expr == nil || expr.Kind != shimast.KindCallExpression {
-			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.KindCallExpression {
-		return nil
-	}
-	return expr
+  if body == nil {
+    return nil
+  }
+  if body.Kind != shimast.KindBlock {
+    expr := stripParens(body)
+    if expr == nil || expr.Kind != shimast.KindCallExpression {
+      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.KindCallExpression {
+    return nil
+  }
+  return expr
 }
 
 // unicornPreferNativeCoercionIsCoercion reports whether `call` is a
 // `String|Number|Boolean|BigInt|Symbol(<param>)` invocation where the
 // single argument is the parameter identifier.
 func unicornPreferNativeCoercionIsCoercion(call *shimast.Node, paramName string) bool {
-	c := call.AsCallExpression()
-	if c == nil || c.Expression == nil {
-		return false
-	}
-	switch identifierText(c.Expression) {
-	case "String", "Number", "Boolean", "BigInt", "Symbol":
-	default:
-		return false
-	}
-	if c.Arguments == nil || len(c.Arguments.Nodes) != 1 {
-		return false
-	}
-	return identifierText(stripParens(c.Arguments.Nodes[0])) == paramName
+  c := call.AsCallExpression()
+  if c == nil || c.Expression == nil {
+    return false
+  }
+  switch identifierText(c.Expression) {
+  case "String", "Number", "Boolean", "BigInt", "Symbol":
+  default:
+    return false
+  }
+  if c.Arguments == nil || len(c.Arguments.Nodes) != 1 {
+    return false
+  }
+  return identifierText(stripParens(c.Arguments.Nodes[0])) == paramName
 }
 
 func init() {
-	Register(unicornPreferNativeCoercionFunctions{})
+  Register(unicornPreferNativeCoercionFunctions{})
 }