@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_unicorn_prefer_switch.go

@@ -24,80 +24,80 @@ type unicornPreferSwitch struct{}
 
 func (unicornPreferSwitch) Name() string { return "unicorn/prefer-switch" }
 func (unicornPreferSwitch) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIfStatement}
+  return []shimast.Kind{shimast.KindIfStatement}
 }
 func (unicornPreferSwitch) Check(ctx *Context, node *shimast.Node) {
-	// Only fire on the outermost if — if our parent is also an
-	// `IfStatement` whose else-branch is `node`, this is a middle of the
-	// chain and a higher-up visit will report it once.
-	if node.Parent != nil && node.Parent.Kind == shimast.KindIfStatement {
-		parent := node.Parent.AsIfStatement()
-		if parent != nil && parent.ElseStatement == node {
-			return
-		}
-	}
-	stmt := node.AsIfStatement()
-	if stmt == nil || stmt.Expression == nil {
-		return
-	}
-	discriminant, ok := unicornPreferSwitchDiscriminant(ctx, stmt.Expression)
-	if !ok {
-		return
-	}
-	// Count the outermost `if` plus every well-shaped `else if` that
-	// compares against the same discriminant.
-	branches := 1
-	cur := stmt.ElseStatement
-	for cur != nil && cur.Kind == shimast.KindIfStatement {
-		inner := cur.AsIfStatement()
-		if inner == nil || inner.Expression == nil {
-			return
-		}
-		next, ok := unicornPreferSwitchDiscriminant(ctx, inner.Expression)
-		if !ok || next != discriminant {
-			return
-		}
-		branches++
-		cur = inner.ElseStatement
-	}
-	if branches >= 3 {
-		ctx.Report(node, "Three or more `else if` clauses comparing the same value should be a `switch`.")
-	}
+  // Only fire on the outermost if — if our parent is also an
+  // `IfStatement` whose else-branch is `node`, this is a middle of the
+  // chain and a higher-up visit will report it once.
+  if node.Parent != nil && node.Parent.Kind == shimast.KindIfStatement {
+    parent := node.Parent.AsIfStatement()
+    if parent != nil && parent.ElseStatement == node {
+      return
+    }
+  }
+  stmt := node.AsIfStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return
+  }
+  discriminant, ok := unicornPreferSwitchDiscriminant(ctx, stmt.Expression)
+  if !ok {
+    return
+  }
+  // Count the outermost `if` plus every well-shaped `else if` that
+  // compares against the same discriminant.
+  branches := 1
+  cur := stmt.ElseStatement
+  for cur != nil && cur.Kind == shimast.KindIfStatement {
+    inner := cur.AsIfStatement()
+    if inner == nil || inner.Expression == nil {
+      return
+    }
+    next, ok := unicornPreferSwitchDiscriminant(ctx, inner.Expression)
+    if !ok || next != discriminant {
+      return
+    }
+    branches++
+    cur = inner.ElseStatement
+  }
+  if branches >= 3 {
+    ctx.Report(node, "Three or more `else if` clauses comparing the same value should be a `switch`.")
+  }
 }
 
 // unicornPreferSwitchDiscriminant returns the textual form of the left
 // operand of an `===`/`==` comparison against a string-or-numeric
 // literal. Returns ok=false for any other shape.
 func unicornPreferSwitchDiscriminant(ctx *Context, expr *shimast.Node) (string, bool) {
-	expr = stripParens(expr)
-	if expr == nil || expr.Kind != shimast.KindBinaryExpression {
-		return "", false
-	}
-	bin := expr.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil {
-		return "", false
-	}
-	switch bin.OperatorToken.Kind {
-	case shimast.KindEqualsEqualsEqualsToken, shimast.KindEqualsEqualsToken:
-	default:
-		return "", false
-	}
-	right := stripParens(bin.Right)
-	if right == nil {
-		return "", false
-	}
-	switch right.Kind {
-	case shimast.KindStringLiteral, shimast.KindNumericLiteral:
-	default:
-		return "", false
-	}
-	left := stripParens(bin.Left)
-	if left == nil {
-		return "", false
-	}
-	return nodeText(ctx.File, left), true
+  expr = stripParens(expr)
+  if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+    return "", false
+  }
+  bin := expr.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil {
+    return "", false
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsEqualsToken, shimast.KindEqualsEqualsToken:
+  default:
+    return "", false
+  }
+  right := stripParens(bin.Right)
+  if right == nil {
+    return "", false
+  }
+  switch right.Kind {
+  case shimast.KindStringLiteral, shimast.KindNumericLiteral:
+  default:
+    return "", false
+  }
+  left := stripParens(bin.Left)
+  if left == nil {
+    return "", false
+  }
+  return nodeText(ctx.File, left), true
 }
 
 func init() {
-	Register(unicornPreferSwitch{})
+  Register(unicornPreferSwitch{})
 }

package/linthost/rules_unicorn_prefer_ternary.go

@@ -21,26 +21,26 @@ type unicornPreferTernary struct{}
 
 func (unicornPreferTernary) Name() string { return "unicorn/prefer-ternary" }
 func (unicornPreferTernary) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIfStatement}
+  return []shimast.Kind{shimast.KindIfStatement}
 }
 func (unicornPreferTernary) Check(ctx *Context, node *shimast.Node) {
-	stmt := node.AsIfStatement()
-	if stmt == nil || stmt.ThenStatement == nil || stmt.ElseStatement == nil {
-		return
-	}
-	// Reject `else if` — an `if`/`else if`/`else` ladder is a different
-	// rewrite target (it becomes nested ternaries, which the upstream
-	// rule explicitly does not require).
-	if stmt.ElseStatement.Kind == shimast.KindIfStatement {
-		return
-	}
-	if !unicornPreferTernaryIsSingleReturn(stmt.ThenStatement) {
-		return
-	}
-	if !unicornPreferTernaryIsSingleReturn(stmt.ElseStatement) {
-		return
-	}
-	ctx.Report(node, "Use a ternary instead of `if`/`else` whose branches differ only in the returned value.")
+  stmt := node.AsIfStatement()
+  if stmt == nil || stmt.ThenStatement == nil || stmt.ElseStatement == nil {
+    return
+  }
+  // Reject `else if` — an `if`/`else if`/`else` ladder is a different
+  // rewrite target (it becomes nested ternaries, which the upstream
+  // rule explicitly does not require).
+  if stmt.ElseStatement.Kind == shimast.KindIfStatement {
+    return
+  }
+  if !unicornPreferTernaryIsSingleReturn(stmt.ThenStatement) {
+    return
+  }
+  if !unicornPreferTernaryIsSingleReturn(stmt.ElseStatement) {
+    return
+  }
+  ctx.Report(node, "Use a ternary instead of `if`/`else` whose branches differ only in the returned value.")
 }
 
 // unicornPreferTernaryIsSingleReturn reports whether `branch` is a
@@ -48,24 +48,24 @@ func (unicornPreferTernary) Check(ctx *Context, node *shimast.Node) {
 // block. Returns false for empty returns (`return;`); ternary cannot
 // fold those because both arms have to produce a value.
 func unicornPreferTernaryIsSingleReturn(branch *shimast.Node) bool {
-	if branch == nil {
-		return false
-	}
-	stmt := branch
-	if branch.Kind == shimast.KindBlock {
-		block := branch.AsBlock()
-		if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
-			return false
-		}
-		stmt = block.Statements.Nodes[0]
-	}
-	if stmt == nil || stmt.Kind != shimast.KindReturnStatement {
-		return false
-	}
-	ret := stmt.AsReturnStatement()
-	return ret != nil && ret.Expression != nil
+  if branch == nil {
+    return false
+  }
+  stmt := branch
+  if branch.Kind == shimast.KindBlock {
+    block := branch.AsBlock()
+    if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+      return false
+    }
+    stmt = block.Statements.Nodes[0]
+  }
+  if stmt == nil || stmt.Kind != shimast.KindReturnStatement {
+    return false
+  }
+  ret := stmt.AsReturnStatement()
+  return ret != nil && ret.Expression != nil
 }
 
 func init() {
-	Register(unicornPreferTernary{})
+  Register(unicornPreferTernary{})
 }

package/linthost/rules_unicorn_prefer_top_level_await.go

@@ -21,22 +21,22 @@ type unicornPreferTopLevelAwait struct{}
 
 func (unicornPreferTopLevelAwait) Name() string { return "unicorn/prefer-top-level-await" }
 func (unicornPreferTopLevelAwait) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferTopLevelAwait) 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()) != "then" {
-		return
-	}
-	if !unicornPreferTopLevelAwaitIsTopLevel(node) {
-		return
-	}
-	ctx.Report(node, "Prefer top-level `await` over `.then` chains in ES modules.")
+  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()) != "then" {
+    return
+  }
+  if !unicornPreferTopLevelAwaitIsTopLevel(node) {
+    return
+  }
+  ctx.Report(node, "Prefer top-level `await` over `.then` chains in ES modules.")
 }
 
 // unicornPreferTopLevelAwaitIsTopLevel walks ancestors and reports
@@ -46,27 +46,27 @@ func (unicornPreferTopLevelAwait) Check(ctx *Context, node *shimast.Node) {
 // class-body, block, or module-block boundary, which would push the call
 // out of module scope.
 func unicornPreferTopLevelAwaitIsTopLevel(node *shimast.Node) bool {
-	for cur := node.Parent; cur != nil; cur = cur.Parent {
-		switch cur.Kind {
-		case shimast.KindSourceFile:
-			return true
-		case shimast.KindFunctionDeclaration,
-			shimast.KindFunctionExpression,
-			shimast.KindArrowFunction,
-			shimast.KindMethodDeclaration,
-			shimast.KindGetAccessor,
-			shimast.KindSetAccessor,
-			shimast.KindConstructor,
-			shimast.KindClassDeclaration,
-			shimast.KindClassExpression,
-			shimast.KindModuleBlock,
-			shimast.KindBlock:
-			return false
-		}
-	}
-	return false
+  for cur := node.Parent; cur != nil; cur = cur.Parent {
+    switch cur.Kind {
+    case shimast.KindSourceFile:
+      return true
+    case shimast.KindFunctionDeclaration,
+      shimast.KindFunctionExpression,
+      shimast.KindArrowFunction,
+      shimast.KindMethodDeclaration,
+      shimast.KindGetAccessor,
+      shimast.KindSetAccessor,
+      shimast.KindConstructor,
+      shimast.KindClassDeclaration,
+      shimast.KindClassExpression,
+      shimast.KindModuleBlock,
+      shimast.KindBlock:
+      return false
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(unicornPreferTopLevelAwait{})
+  Register(unicornPreferTopLevelAwait{})
 }

package/linthost/rules_unicorn_prefer_type_error.go

@@ -22,79 +22,79 @@ type unicornPreferTypeError struct{}
 
 func (unicornPreferTypeError) Name() string { return "unicorn/prefer-type-error" }
 func (unicornPreferTypeError) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIfStatement}
+  return []shimast.Kind{shimast.KindIfStatement}
 }
 func (unicornPreferTypeError) Check(ctx *Context, node *shimast.Node) {
-	stmt := node.AsIfStatement()
-	if stmt == nil || stmt.Expression == nil || stmt.ThenStatement == nil {
-		return
-	}
-	cond := stripParens(stmt.Expression)
-	if cond == nil {
-		return
-	}
-	// Accept either the bare type check (`typeof x !== "number"`) or a
-	// negation of one (`!(x instanceof Foo)`).
-	if cond.Kind == shimast.KindPrefixUnaryExpression {
-		prefix := cond.AsPrefixUnaryExpression()
-		if prefix == nil || prefix.Operator != shimast.KindExclamationToken {
-			return
-		}
-		cond = stripParens(prefix.Operand)
-	}
-	if !unicornPreferTypeErrorIsTypeCheck(cond) {
-		return
-	}
-	throw := unicornPreferTypeErrorSingleThrow(stmt.ThenStatement)
-	if throw == nil {
-		return
-	}
-	throwStmt := throw.AsThrowStatement()
-	if throwStmt == nil {
-		return
-	}
-	expr := stripParens(throwStmt.Expression)
-	if expr == nil || expr.Kind != shimast.KindNewExpression {
-		return
-	}
-	ne := expr.AsNewExpression()
-	if ne == nil || identifierText(ne.Expression) != "Error" {
-		return
-	}
-	ctx.Report(throw, "Throw `TypeError` (not `Error`) when the surrounding check is a runtime type check.")
+  stmt := node.AsIfStatement()
+  if stmt == nil || stmt.Expression == nil || stmt.ThenStatement == nil {
+    return
+  }
+  cond := stripParens(stmt.Expression)
+  if cond == nil {
+    return
+  }
+  // Accept either the bare type check (`typeof x !== "number"`) or a
+  // negation of one (`!(x instanceof Foo)`).
+  if cond.Kind == shimast.KindPrefixUnaryExpression {
+    prefix := cond.AsPrefixUnaryExpression()
+    if prefix == nil || prefix.Operator != shimast.KindExclamationToken {
+      return
+    }
+    cond = stripParens(prefix.Operand)
+  }
+  if !unicornPreferTypeErrorIsTypeCheck(cond) {
+    return
+  }
+  throw := unicornPreferTypeErrorSingleThrow(stmt.ThenStatement)
+  if throw == nil {
+    return
+  }
+  throwStmt := throw.AsThrowStatement()
+  if throwStmt == nil {
+    return
+  }
+  expr := stripParens(throwStmt.Expression)
+  if expr == nil || expr.Kind != shimast.KindNewExpression {
+    return
+  }
+  ne := expr.AsNewExpression()
+  if ne == nil || identifierText(ne.Expression) != "Error" {
+    return
+  }
+  ctx.Report(throw, "Throw `TypeError` (not `Error`) when the surrounding check is a runtime type check.")
 }
 
 // unicornPreferTypeErrorIsTypeCheck reports whether `node` is a
 // `typeof x` expression or `x instanceof Y` BinaryExpression. Both
 // shapes encode a runtime type test, which is what the rule keys off.
 func unicornPreferTypeErrorIsTypeCheck(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	switch node.Kind {
-	case shimast.KindTypeOfExpression:
-		return true
-	case shimast.KindBinaryExpression:
-		bin := node.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil {
-			return false
-		}
-		if bin.OperatorToken.Kind == shimast.KindInstanceOfKeyword {
-			return true
-		}
-		// `typeof x !== "string"` style — covers the common idiom.
-		switch bin.OperatorToken.Kind {
-		case shimast.KindEqualsEqualsEqualsToken,
-			shimast.KindEqualsEqualsToken,
-			shimast.KindExclamationEqualsEqualsToken,
-			shimast.KindExclamationEqualsToken:
-			left := stripParens(bin.Left)
-			right := stripParens(bin.Right)
-			return (left != nil && left.Kind == shimast.KindTypeOfExpression) ||
-				(right != nil && right.Kind == shimast.KindTypeOfExpression)
-		}
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindTypeOfExpression:
+    return true
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return false
+    }
+    if bin.OperatorToken.Kind == shimast.KindInstanceOfKeyword {
+      return true
+    }
+    // `typeof x !== "string"` style — covers the common idiom.
+    switch bin.OperatorToken.Kind {
+    case shimast.KindEqualsEqualsEqualsToken,
+      shimast.KindEqualsEqualsToken,
+      shimast.KindExclamationEqualsEqualsToken,
+      shimast.KindExclamationEqualsToken:
+      left := stripParens(bin.Left)
+      right := stripParens(bin.Right)
+      return (left != nil && left.Kind == shimast.KindTypeOfExpression) ||
+        (right != nil && right.Kind == shimast.KindTypeOfExpression)
+    }
+  }
+  return false
 }
 
 // unicornPreferTypeErrorSingleThrow returns the single `throw`
@@ -102,26 +102,26 @@ func unicornPreferTypeErrorIsTypeCheck(node *shimast.Node) bool {
 // or a Block wrapping exactly one ThrowStatement. Returns nil for any
 // other shape.
 func unicornPreferTypeErrorSingleThrow(branch *shimast.Node) *shimast.Node {
-	if branch == nil {
-		return nil
-	}
-	if branch.Kind == shimast.KindThrowStatement {
-		return branch
-	}
-	if branch.Kind != shimast.KindBlock {
-		return nil
-	}
-	block := branch.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.KindThrowStatement {
-		return nil
-	}
-	return stmt
+  if branch == nil {
+    return nil
+  }
+  if branch.Kind == shimast.KindThrowStatement {
+    return branch
+  }
+  if branch.Kind != shimast.KindBlock {
+    return nil
+  }
+  block := branch.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.KindThrowStatement {
+    return nil
+  }
+  return stmt
 }
 
 func init() {
-	Register(unicornPreferTypeError{})
+  Register(unicornPreferTypeError{})
 }