@ttsc/lint 0.7.2 → 0.8.0-dev.20260505

package/plugin/rules_suggestions.go

@@ -4,9 +4,9 @@
 package main
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // no-alert: `alert()` / `confirm()` / `prompt()`. Rarely the right
@@ -16,14 +16,14 @@ type noAlert struct{}
 func (noAlert) Name() string           { return "no-alert" }
 func (noAlert) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noAlert) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil {
-		return
-	}
-	switch callCalleeName(call) {
-	case "alert", "confirm", "prompt":
-		ctx.Report(node, "Unexpected "+callCalleeName(call)+".")
-	}
+  call := node.AsCallExpression()
+  if call == nil {
+    return
+  }
+  switch callCalleeName(call) {
+  case "alert", "confirm", "prompt":
+    ctx.Report(node, "Unexpected "+callCalleeName(call)+".")
+  }
 }
 
 // no-bitwise: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>` — almost always a
@@ -32,38 +32,38 @@ type noBitwise struct{}
 
 func (noBitwise) Name() string { return "no-bitwise" }
 func (noBitwise) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression, shimast.KindPrefixUnaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression, shimast.KindPrefixUnaryExpression}
 }
 func (noBitwise) Check(ctx *Context, node *shimast.Node) {
-	if node.Kind == shimast.KindBinaryExpression {
-		expr := node.AsBinaryExpression()
-		if expr == nil || expr.OperatorToken == nil {
-			return
-		}
-		switch expr.OperatorToken.Kind {
-		case shimast.KindAmpersandToken,
-			shimast.KindBarToken,
-			shimast.KindCaretToken,
-			shimast.KindLessThanLessThanToken,
-			shimast.KindGreaterThanGreaterThanToken,
-			shimast.KindGreaterThanGreaterThanGreaterThanToken,
-			shimast.KindAmpersandEqualsToken,
-			shimast.KindBarEqualsToken,
-			shimast.KindCaretEqualsToken,
-			shimast.KindLessThanLessThanEqualsToken,
-			shimast.KindGreaterThanGreaterThanEqualsToken,
-			shimast.KindGreaterThanGreaterThanGreaterThanEqualsToken:
-			ctx.Report(node, "Unexpected use of bitwise operator.")
-		}
-		return
-	}
-	prefix := node.AsPrefixUnaryExpression()
-	if prefix == nil {
-		return
-	}
-	if prefix.Operator == shimast.KindTildeToken {
-		ctx.Report(node, "Unexpected use of bitwise operator.")
-	}
+  if node.Kind == shimast.KindBinaryExpression {
+    expr := node.AsBinaryExpression()
+    if expr == nil || expr.OperatorToken == nil {
+      return
+    }
+    switch expr.OperatorToken.Kind {
+    case shimast.KindAmpersandToken,
+      shimast.KindBarToken,
+      shimast.KindCaretToken,
+      shimast.KindLessThanLessThanToken,
+      shimast.KindGreaterThanGreaterThanToken,
+      shimast.KindGreaterThanGreaterThanGreaterThanToken,
+      shimast.KindAmpersandEqualsToken,
+      shimast.KindBarEqualsToken,
+      shimast.KindCaretEqualsToken,
+      shimast.KindLessThanLessThanEqualsToken,
+      shimast.KindGreaterThanGreaterThanEqualsToken,
+      shimast.KindGreaterThanGreaterThanGreaterThanEqualsToken:
+      ctx.Report(node, "Unexpected use of bitwise operator.")
+    }
+    return
+  }
+  prefix := node.AsPrefixUnaryExpression()
+  if prefix == nil {
+    return
+  }
+  if prefix.Operator == shimast.KindTildeToken {
+    ctx.Report(node, "Unexpected use of bitwise operator.")
+  }
 }
 
 // no-caller: `arguments.caller` / `arguments.callee` — strict-mode
@@ -73,17 +73,17 @@ type noCaller struct{}
 func (noCaller) Name() string           { return "no-caller" }
 func (noCaller) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindPropertyAccessExpression} }
 func (noCaller) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Expression) != "arguments" {
-		return
-	}
-	switch identifierText(access.Name()) {
-	case "caller", "callee":
-		ctx.Report(node, "Avoid arguments."+identifierText(access.Name())+".")
-	}
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Expression) != "arguments" {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "caller", "callee":
+    ctx.Report(node, "Avoid arguments."+identifierText(access.Name())+".")
+  }
 }
 
 // no-case-declarations: `switch (x) { case 1: let y = 2; break; }` —
@@ -92,29 +92,29 @@ type noCaseDeclarations struct{}
 
 func (noCaseDeclarations) Name() string { return "no-case-declarations" }
 func (noCaseDeclarations) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCaseClause, shimast.KindDefaultClause}
+  return []shimast.Kind{shimast.KindCaseClause, shimast.KindDefaultClause}
 }
 func (noCaseDeclarations) Check(ctx *Context, node *shimast.Node) {
-	clause := node.AsCaseOrDefaultClause()
-	if clause == nil || clause.Statements == nil {
-		return
-	}
-	for _, stmt := range clause.Statements.Nodes {
-		if stmt == nil {
-			continue
-		}
-		if stmt.Kind == shimast.KindVariableStatement {
-			vstmt := stmt.AsVariableStatement()
-			if vstmt != nil && vstmt.DeclarationList != nil && !shimast.IsVar(vstmt.DeclarationList) {
-				ctx.Report(stmt, "Unexpected lexical declaration in case block.")
-				continue
-			}
-		}
-		switch stmt.Kind {
-		case shimast.KindFunctionDeclaration, shimast.KindClassDeclaration:
-			ctx.Report(stmt, "Unexpected lexical declaration in case block.")
-		}
-	}
+  clause := node.AsCaseOrDefaultClause()
+  if clause == nil || clause.Statements == nil {
+    return
+  }
+  for _, stmt := range clause.Statements.Nodes {
+    if stmt == nil {
+      continue
+    }
+    if stmt.Kind == shimast.KindVariableStatement {
+      vstmt := stmt.AsVariableStatement()
+      if vstmt != nil && vstmt.DeclarationList != nil && !shimast.IsVar(vstmt.DeclarationList) {
+        ctx.Report(stmt, "Unexpected lexical declaration in case block.")
+        continue
+      }
+    }
+    switch stmt.Kind {
+    case shimast.KindFunctionDeclaration, shimast.KindClassDeclaration:
+      ctx.Report(stmt, "Unexpected lexical declaration in case block.")
+    }
+  }
 }
 
 // no-continue: `continue` keyword. ESLint flags it as a code-smell
@@ -124,7 +124,7 @@ type noContinue struct{}
 func (noContinue) Name() string           { return "no-continue" }
 func (noContinue) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindContinueStatement} }
 func (noContinue) Check(ctx *Context, node *shimast.Node) {
-	ctx.Report(node, "Unexpected use of continue statement.")
+  ctx.Report(node, "Unexpected use of continue statement.")
 }
 
 // no-delete-var: `delete x` where `x` is a variable. Strict-mode error.
@@ -133,13 +133,13 @@ type noDeleteVar struct{}
 func (noDeleteVar) Name() string           { return "no-delete-var" }
 func (noDeleteVar) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindDeleteExpression} }
 func (noDeleteVar) Check(ctx *Context, node *shimast.Node) {
-	del := node.AsDeleteExpression()
-	if del == nil {
-		return
-	}
-	if del.Expression != nil && del.Expression.Kind == shimast.KindIdentifier {
-		ctx.Report(node, "Variables should not be deleted.")
-	}
+  del := node.AsDeleteExpression()
+  if del == nil {
+    return
+  }
+  if del.Expression != nil && del.Expression.Kind == shimast.KindIdentifier {
+    ctx.Report(node, "Variables should not be deleted.")
+  }
 }
 
 // no-eq-null: `x == null` — ambiguous with eqeqeq's `null` exception
@@ -149,20 +149,20 @@ type noEqNull struct{}
 func (noEqNull) Name() string           { return "no-eq-null" }
 func (noEqNull) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noEqNull) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if expr.OperatorToken.Kind != shimast.KindEqualsEqualsToken && expr.OperatorToken.Kind != shimast.KindExclamationEqualsToken {
-		return
-	}
-	if isNullLiteral(expr.Left) || isNullLiteral(expr.Right) {
-		ctx.Report(node, "Use '===' to compare with null.")
-	}
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindEqualsEqualsToken && expr.OperatorToken.Kind != shimast.KindExclamationEqualsToken {
+    return
+  }
+  if isNullLiteral(expr.Left) || isNullLiteral(expr.Right) {
+    ctx.Report(node, "Use '===' to compare with null.")
+  }
 }
 
 func isNullLiteral(node *shimast.Node) bool {
-	return node != nil && node.Kind == shimast.KindNullKeyword
+  return node != nil && node.Kind == shimast.KindNullKeyword
 }
 
 // no-extra-bind: `(function () {}).bind(this)` where `this` isn't used
@@ -173,60 +173,60 @@ type noExtraBind struct{}
 func (noExtraBind) Name() string           { return "no-extra-bind" }
 func (noExtraBind) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noExtraBind) 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 || identifierText(access.Name()) != "bind" {
-		return
-	}
-	target := stripParens(access.Expression)
-	if target == nil {
-		return
-	}
-	if target.Kind != shimast.KindArrowFunction && target.Kind != shimast.KindFunctionExpression {
-		return
-	}
-	// Arrow functions don't have their own `this`; `.bind` is always
-	// useless on them.
-	if target.Kind == shimast.KindArrowFunction {
-		ctx.Report(node, "The function binding is unnecessary.")
-		return
-	}
-	body := target.Body()
-	if body != nil && !bodyReferencesThis(body) {
-		ctx.Report(node, "The function binding is unnecessary.")
-	}
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "bind" {
+    return
+  }
+  target := stripParens(access.Expression)
+  if target == nil {
+    return
+  }
+  if target.Kind != shimast.KindArrowFunction && target.Kind != shimast.KindFunctionExpression {
+    return
+  }
+  // Arrow functions don't have their own `this`; `.bind` is always
+  // useless on them.
+  if target.Kind == shimast.KindArrowFunction {
+    ctx.Report(node, "The function binding is unnecessary.")
+    return
+  }
+  body := target.Body()
+  if body != nil && !bodyReferencesThis(body) {
+    ctx.Report(node, "The function binding is unnecessary.")
+  }
 }
 
 func bodyReferencesThis(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	if node.Kind == shimast.KindThisKeyword {
-		return true
-	}
-	// Don't descend into nested function-likes — their `this` is
-	// independent.
-	if isFunctionLikeKind(node) && node.Parent != nil {
-		return false
-	}
-	found := false
-	node.ForEachChild(func(child *shimast.Node) bool {
-		if found {
-			return true
-		}
-		if bodyReferencesThis(child) {
-			found = true
-			return true
-		}
-		return false
-	})
-	return found
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindThisKeyword {
+    return true
+  }
+  // Don't descend into nested function-likes — their `this` is
+  // independent.
+  if isFunctionLikeKind(node) && node.Parent != nil {
+    return false
+  }
+  found := false
+  node.ForEachChild(func(child *shimast.Node) bool {
+    if found {
+      return true
+    }
+    if bodyReferencesThis(child) {
+      found = true
+      return true
+    }
+    return false
+  })
+  return found
 }
 
 // no-labels: labels (`outer: for (...) { break outer; }`) are
@@ -236,7 +236,7 @@ type noLabels struct{}
 func (noLabels) Name() string           { return "no-labels" }
 func (noLabels) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindLabeledStatement} }
 func (noLabels) Check(ctx *Context, node *shimast.Node) {
-	ctx.Report(node, "Unexpected labeled statement.")
+  ctx.Report(node, "Unexpected labeled statement.")
 }
 
 // no-lone-blocks: `{ doStuff(); }` outside a control flow context —
@@ -246,45 +246,45 @@ type noLoneBlocks struct{}
 func (noLoneBlocks) Name() string           { return "no-lone-blocks" }
 func (noLoneBlocks) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBlock} }
 func (noLoneBlocks) Check(ctx *Context, node *shimast.Node) {
-	parent := node.Parent
-	if parent == nil {
-		return
-	}
-	switch parent.Kind {
-	case shimast.KindBlock, shimast.KindSourceFile, shimast.KindModuleBlock:
-	default:
-		return
-	}
-	// Skip blocks that are themselves a function/method body — those
-	// are tracked by isFunctionLikeKind on the parent.
-	if isFunctionLikeKind(parent) {
-		return
-	}
-	block := node.AsBlock()
-	if block == nil || block.Statements == nil {
-		return
-	}
-	// Empty block is `no-empty`'s domain.
-	if len(block.Statements.Nodes) == 0 {
-		return
-	}
-	// Allow blocks whose only contents are block-scoped declarations
-	// (`{ const x = 1; }` is occasionally used to limit scope).
-	for _, stmt := range block.Statements.Nodes {
-		if stmt == nil {
-			continue
-		}
-		if stmt.Kind == shimast.KindVariableStatement {
-			vstmt := stmt.AsVariableStatement()
-			if vstmt != nil && vstmt.DeclarationList != nil && !shimast.IsVar(vstmt.DeclarationList) {
-				return
-			}
-		}
-		if stmt.Kind == shimast.KindClassDeclaration || stmt.Kind == shimast.KindFunctionDeclaration {
-			return
-		}
-	}
-	ctx.Report(node, "Block is redundant.")
+  parent := node.Parent
+  if parent == nil {
+    return
+  }
+  switch parent.Kind {
+  case shimast.KindBlock, shimast.KindSourceFile, shimast.KindModuleBlock:
+  default:
+    return
+  }
+  // Skip blocks that are themselves a function/method body — those
+  // are tracked by isFunctionLikeKind on the parent.
+  if isFunctionLikeKind(parent) {
+    return
+  }
+  block := node.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  // Empty block is `no-empty`'s domain.
+  if len(block.Statements.Nodes) == 0 {
+    return
+  }
+  // Allow blocks whose only contents are block-scoped declarations
+  // (`{ const x = 1; }` is occasionally used to limit scope).
+  for _, stmt := range block.Statements.Nodes {
+    if stmt == nil {
+      continue
+    }
+    if stmt.Kind == shimast.KindVariableStatement {
+      vstmt := stmt.AsVariableStatement()
+      if vstmt != nil && vstmt.DeclarationList != nil && !shimast.IsVar(vstmt.DeclarationList) {
+        return
+      }
+    }
+    if stmt.Kind == shimast.KindClassDeclaration || stmt.Kind == shimast.KindFunctionDeclaration {
+      return
+    }
+  }
+  ctx.Report(node, "Block is redundant.")
 }
 
 // no-lonely-if: `else { if (...) {...} }` should be `else if (...)`.
@@ -293,26 +293,26 @@ type noLonelyIf struct{}
 func (noLonelyIf) Name() string           { return "no-lonely-if" }
 func (noLonelyIf) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindIfStatement} }
 func (noLonelyIf) Check(ctx *Context, node *shimast.Node) {
-	parent := node.Parent
-	if parent == nil || parent.Kind != shimast.KindBlock {
-		return
-	}
-	block := parent.AsBlock()
-	if block == nil || block.Statements == nil {
-		return
-	}
-	if len(block.Statements.Nodes) != 1 {
-		return
-	}
-	grand := parent.Parent
-	if grand == nil || grand.Kind != shimast.KindIfStatement {
-		return
-	}
-	gif := grand.AsIfStatement()
-	if gif == nil || gif.ElseStatement != parent {
-		return
-	}
-	ctx.Report(node, "Unexpected if as the only statement in an else block.")
+  parent := node.Parent
+  if parent == nil || parent.Kind != shimast.KindBlock {
+    return
+  }
+  block := parent.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  if len(block.Statements.Nodes) != 1 {
+    return
+  }
+  grand := parent.Parent
+  if grand == nil || grand.Kind != shimast.KindIfStatement {
+    return
+  }
+  gif := grand.AsIfStatement()
+  if gif == nil || gif.ElseStatement != parent {
+    return
+  }
+  ctx.Report(node, "Unexpected if as the only statement in an else block.")
 }
 
 // no-multi-assign: `a = b = 1`. Confusing right-to-left chains.
@@ -321,19 +321,19 @@ type noMultiAssign struct{}
 func (noMultiAssign) Name() string           { return "no-multi-assign" }
 func (noMultiAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noMultiAssign) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if expr.OperatorToken.Kind != shimast.KindEqualsToken {
-		return
-	}
-	if expr.Right != nil && expr.Right.Kind == shimast.KindBinaryExpression {
-		inner := expr.Right.AsBinaryExpression()
-		if inner != nil && inner.OperatorToken != nil && inner.OperatorToken.Kind == shimast.KindEqualsToken {
-			ctx.Report(node, "Unexpected chained assignment.")
-		}
-	}
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindEqualsToken {
+    return
+  }
+  if expr.Right != nil && expr.Right.Kind == shimast.KindBinaryExpression {
+    inner := expr.Right.AsBinaryExpression()
+    if inner != nil && inner.OperatorToken != nil && inner.OperatorToken.Kind == shimast.KindEqualsToken {
+      ctx.Report(node, "Unexpected chained assignment.")
+    }
+  }
 }
 
 // no-negated-condition: `if (!x) {} else {}`. Easier to read with the
@@ -342,53 +342,53 @@ type noNegatedCondition struct{}
 
 func (noNegatedCondition) Name() string { return "no-negated-condition" }
 func (noNegatedCondition) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIfStatement, shimast.KindConditionalExpression}
+  return []shimast.Kind{shimast.KindIfStatement, shimast.KindConditionalExpression}
 }
 func (noNegatedCondition) Check(ctx *Context, node *shimast.Node) {
-	if node.Kind == shimast.KindIfStatement {
-		stmt := node.AsIfStatement()
-		if stmt == nil || stmt.ElseStatement == nil {
-			return
-		}
-		// Allow `else if` chains — the branches aren't symmetric.
-		if stmt.ElseStatement.Kind == shimast.KindIfStatement {
-			return
-		}
-		if isNegatedExpression(stmt.Expression) {
-			ctx.Report(node, "Unexpected negated condition.")
-		}
-		return
-	}
-	cond := node.AsConditionalExpression()
-	if cond == nil {
-		return
-	}
-	if isNegatedExpression(cond.Condition) {
-		ctx.Report(node, "Unexpected negated condition.")
-	}
+  if node.Kind == shimast.KindIfStatement {
+    stmt := node.AsIfStatement()
+    if stmt == nil || stmt.ElseStatement == nil {
+      return
+    }
+    // Allow `else if` chains — the branches aren't symmetric.
+    if stmt.ElseStatement.Kind == shimast.KindIfStatement {
+      return
+    }
+    if isNegatedExpression(stmt.Expression) {
+      ctx.Report(node, "Unexpected negated condition.")
+    }
+    return
+  }
+  cond := node.AsConditionalExpression()
+  if cond == nil {
+    return
+  }
+  if isNegatedExpression(cond.Condition) {
+    ctx.Report(node, "Unexpected negated condition.")
+  }
 }
 
 func isNegatedExpression(node *shimast.Node) bool {
-	expr := stripParens(node)
-	if expr == nil {
-		return false
-	}
-	if expr.Kind == shimast.KindPrefixUnaryExpression {
-		prefix := expr.AsPrefixUnaryExpression()
-		if prefix != nil && prefix.Operator == shimast.KindExclamationToken {
-			return true
-		}
-	}
-	if expr.Kind == shimast.KindBinaryExpression {
-		bin := expr.AsBinaryExpression()
-		if bin != nil && bin.OperatorToken != nil {
-			switch bin.OperatorToken.Kind {
-			case shimast.KindExclamationEqualsToken, shimast.KindExclamationEqualsEqualsToken:
-				return true
-			}
-		}
-	}
-	return false
+  expr := stripParens(node)
+  if expr == nil {
+    return false
+  }
+  if expr.Kind == shimast.KindPrefixUnaryExpression {
+    prefix := expr.AsPrefixUnaryExpression()
+    if prefix != nil && prefix.Operator == shimast.KindExclamationToken {
+      return true
+    }
+  }
+  if expr.Kind == shimast.KindBinaryExpression {
+    bin := expr.AsBinaryExpression()
+    if bin != nil && bin.OperatorToken != nil {
+      switch bin.OperatorToken.Kind {
+      case shimast.KindExclamationEqualsToken, shimast.KindExclamationEqualsEqualsToken:
+        return true
+      }
+    }
+  }
+  return false
 }
 
 // no-nested-ternary: `a ? b : c ? d : e`.
@@ -396,21 +396,21 @@ type noNestedTernary struct{}
 
 func (noNestedTernary) Name() string { return "no-nested-ternary" }
 func (noNestedTernary) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindConditionalExpression}
+  return []shimast.Kind{shimast.KindConditionalExpression}
 }
 func (noNestedTernary) Check(ctx *Context, node *shimast.Node) {
-	cond := node.AsConditionalExpression()
-	if cond == nil {
-		return
-	}
-	if hasConditional(cond.WhenTrue) || hasConditional(cond.WhenFalse) {
-		ctx.Report(node, "Do not nest ternary expressions.")
-	}
+  cond := node.AsConditionalExpression()
+  if cond == nil {
+    return
+  }
+  if hasConditional(cond.WhenTrue) || hasConditional(cond.WhenFalse) {
+    ctx.Report(node, "Do not nest ternary expressions.")
+  }
 }
 
 func hasConditional(node *shimast.Node) bool {
-	expr := stripParens(node)
-	return expr != nil && expr.Kind == shimast.KindConditionalExpression
+  expr := stripParens(node)
+  return expr != nil && expr.Kind == shimast.KindConditionalExpression
 }
 
 // no-new: `new Foo()` whose result is discarded. Either store it or
@@ -420,13 +420,13 @@ type noNew struct{}
 func (noNew) Name() string           { return "no-new" }
 func (noNew) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindExpressionStatement} }
 func (noNew) Check(ctx *Context, node *shimast.Node) {
-	stmt := node.AsExpressionStatement()
-	if stmt == nil || stmt.Expression == nil {
-		return
-	}
-	if stmt.Expression.Kind == shimast.KindNewExpression {
-		ctx.Report(node, "Do not use 'new' for side effects.")
-	}
+  stmt := node.AsExpressionStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return
+  }
+  if stmt.Expression.Kind == shimast.KindNewExpression {
+    ctx.Report(node, "Do not use 'new' for side effects.")
+  }
 }
 
 // no-new-func: `new Function("...")` — a third form of dynamic eval.
@@ -434,18 +434,18 @@ type noNewFunc struct{}
 
 func (noNewFunc) Name() string { return "no-new-func" }
 func (noNewFunc) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
 }
 func (noNewFunc) Check(ctx *Context, node *shimast.Node) {
-	var callee *shimast.Node
-	if node.Kind == shimast.KindNewExpression {
-		callee = node.AsNewExpression().Expression
-	} else {
-		callee = node.AsCallExpression().Expression
-	}
-	if identifierText(callee) == "Function" {
-		ctx.Report(node, "The Function constructor is eval.")
-	}
+  var callee *shimast.Node
+  if node.Kind == shimast.KindNewExpression {
+    callee = node.AsNewExpression().Expression
+  } else {
+    callee = node.AsCallExpression().Expression
+  }
+  if identifierText(callee) == "Function" {
+    ctx.Report(node, "The Function constructor is eval.")
+  }
 }
 
 // no-object-constructor: `new Object()` / `Object()` — same shape as
@@ -454,30 +454,30 @@ type noObjectConstructor struct{}
 
 func (noObjectConstructor) Name() string { return "no-object-constructor" }
 func (noObjectConstructor) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
 }
 func (noObjectConstructor) Check(ctx *Context, node *shimast.Node) {
-	var callee *shimast.Node
-	var argCount int
-	if node.Kind == shimast.KindNewExpression {
-		ne := node.AsNewExpression()
-		callee = ne.Expression
-		if ne.Arguments != nil {
-			argCount = len(ne.Arguments.Nodes)
-		}
-	} else {
-		call := node.AsCallExpression()
-		callee = call.Expression
-		if call.Arguments != nil {
-			argCount = len(call.Arguments.Nodes)
-		}
-	}
-	if argCount != 0 {
-		return // 1+ args is a "make a wrapper", not "make an empty object".
-	}
-	if identifierText(callee) == "Object" {
-		ctx.Report(node, "The object literal notation {} is preferable.")
-	}
+  var callee *shimast.Node
+  var argCount int
+  if node.Kind == shimast.KindNewExpression {
+    ne := node.AsNewExpression()
+    callee = ne.Expression
+    if ne.Arguments != nil {
+      argCount = len(ne.Arguments.Nodes)
+    }
+  } else {
+    call := node.AsCallExpression()
+    callee = call.Expression
+    if call.Arguments != nil {
+      argCount = len(call.Arguments.Nodes)
+    }
+  }
+  if argCount != 0 {
+    return // 1+ args is a "make a wrapper", not "make an empty object".
+  }
+  if identifierText(callee) == "Object" {
+    ctx.Report(node, "The object literal notation {} is preferable.")
+  }
 }
 
 // no-octal-escape: `"\251"` — octal escapes in string literals are
@@ -486,36 +486,36 @@ type noOctalEscape struct{}
 
 func (noOctalEscape) Name() string { return "no-octal-escape" }
 func (noOctalEscape) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+  return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
 }
 func (noOctalEscape) Check(ctx *Context, node *shimast.Node) {
-	src := nodeText(ctx.File, node)
-	if hasOctalEscape(src) {
-		ctx.Report(node, "Don't use octal escape sequences.")
-	}
+  src := nodeText(ctx.File, node)
+  if hasOctalEscape(src) {
+    ctx.Report(node, "Don't use octal escape sequences.")
+  }
 }
 
 func hasOctalEscape(src string) bool {
-	for i := 0; i < len(src)-1; i++ {
-		if src[i] != '\\' {
-			continue
-		}
-		next := src[i+1]
-		// A literal `\0` followed by a non-digit is not an octal
-		// escape, just NUL — those are allowed.
-		if next < '0' || next > '7' {
-			i++
-			continue
-		}
-		if next == '0' {
-			if i+2 >= len(src) || src[i+2] < '0' || src[i+2] > '9' {
-				i++
-				continue
-			}
-		}
-		return true
-	}
-	return false
+  for i := 0; i < len(src)-1; i++ {
+    if src[i] != '\\' {
+      continue
+    }
+    next := src[i+1]
+    // A literal `\0` followed by a non-digit is not an octal
+    // escape, just NUL — those are allowed.
+    if next < '0' || next > '7' {
+      i++
+      continue
+    }
+    if next == '0' {
+      if i+2 >= len(src) || src[i+2] < '0' || src[i+2] > '9' {
+        i++
+        continue
+      }
+    }
+    return true
+  }
+  return false
 }
 
 // no-plusplus: `++x` / `x++`. Equivalent to `x += 1`, considered less
@@ -524,19 +524,19 @@ type noPlusPlus struct{}
 
 func (noPlusPlus) Name() string { return "no-plusplus" }
 func (noPlusPlus) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPrefixUnaryExpression, shimast.KindPostfixUnaryExpression}
+  return []shimast.Kind{shimast.KindPrefixUnaryExpression, shimast.KindPostfixUnaryExpression}
 }
 func (noPlusPlus) Check(ctx *Context, node *shimast.Node) {
-	var op shimast.Kind
-	if node.Kind == shimast.KindPrefixUnaryExpression {
-		op = node.AsPrefixUnaryExpression().Operator
-	} else {
-		op = node.AsPostfixUnaryExpression().Operator
-	}
-	switch op {
-	case shimast.KindPlusPlusToken, shimast.KindMinusMinusToken:
-		ctx.Report(node, "Unary operator '++'/'--' used.")
-	}
+  var op shimast.Kind
+  if node.Kind == shimast.KindPrefixUnaryExpression {
+    op = node.AsPrefixUnaryExpression().Operator
+  } else {
+    op = node.AsPostfixUnaryExpression().Operator
+  }
+  switch op {
+  case shimast.KindPlusPlusToken, shimast.KindMinusMinusToken:
+    ctx.Report(node, "Unary operator '++'/'--' used.")
+  }
 }
 
 // no-regex-spaces: multiple spaces in a regex literal — confusing
@@ -545,50 +545,50 @@ type noRegexSpaces struct{}
 
 func (noRegexSpaces) Name() string { return "no-regex-spaces" }
 func (noRegexSpaces) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindRegularExpressionLiteral}
+  return []shimast.Kind{shimast.KindRegularExpressionLiteral}
 }
 func (noRegexSpaces) Check(ctx *Context, node *shimast.Node) {
-	src := nodeText(ctx.File, node)
-	if regexHasMultipleSpaces(src) {
-		ctx.Report(node, "Spaces are hard to count. Use {N}.")
-	}
+  src := nodeText(ctx.File, node)
+  if regexHasMultipleSpaces(src) {
+    ctx.Report(node, "Spaces are hard to count. Use {N}.")
+  }
 }
 
 func regexHasMultipleSpaces(src string) bool {
-	// Strip trailing flags.
-	end := strings.LastIndex(src, "/")
-	if end <= 0 {
-		return false
-	}
-	body := src[:end]
-	inClass := false
-	run := 0
-	for i := 0; i < len(body); i++ {
-		c := body[i]
-		switch c {
-		case '\\':
-			i++
-			run = 0
-		case '[':
-			inClass = true
-			run = 0
-		case ']':
-			inClass = false
-			run = 0
-		case ' ':
-			if inClass {
-				run = 0
-				continue
-			}
-			run++
-			if run >= 2 {
-				return true
-			}
-		default:
-			run = 0
-		}
-	}
-	return false
+  // Strip trailing flags.
+  end := strings.LastIndex(src, "/")
+  if end <= 0 {
+    return false
+  }
+  body := src[:end]
+  inClass := false
+  run := 0
+  for i := 0; i < len(body); i++ {
+    c := body[i]
+    switch c {
+    case '\\':
+      i++
+      run = 0
+    case '[':
+      inClass = true
+      run = 0
+    case ']':
+      inClass = false
+      run = 0
+    case ' ':
+      if inClass {
+        run = 0
+        continue
+      }
+      run++
+      if run >= 2 {
+        return true
+      }
+    default:
+      run = 0
+    }
+  }
+  return false
 }
 
 // no-return-assign: `return a = b` mixes assignment with return.
@@ -596,27 +596,27 @@ type noReturnAssign struct{}
 
 func (noReturnAssign) Name() string { return "no-return-assign" }
 func (noReturnAssign) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindReturnStatement, shimast.KindArrowFunction}
+  return []shimast.Kind{shimast.KindReturnStatement, shimast.KindArrowFunction}
 }
 func (noReturnAssign) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindReturnStatement:
-		ret := node.AsReturnStatement()
-		if ret == nil || ret.Expression == nil {
-			return
-		}
-		if isAssignmentExpression(stripParens(ret.Expression)) {
-			ctx.Report(node, "Return statement should not contain assignment.")
-		}
-	case shimast.KindArrowFunction:
-		arrow := node.AsArrowFunction()
-		if arrow == nil || arrow.Body == nil || arrow.Body.Kind == shimast.KindBlock {
-			return
-		}
-		if isAssignmentExpression(stripParens(arrow.Body)) {
-			ctx.Report(node, "Arrow function should not return an assignment.")
-		}
-	}
+  switch node.Kind {
+  case shimast.KindReturnStatement:
+    ret := node.AsReturnStatement()
+    if ret == nil || ret.Expression == nil {
+      return
+    }
+    if isAssignmentExpression(stripParens(ret.Expression)) {
+      ctx.Report(node, "Return statement should not contain assignment.")
+    }
+  case shimast.KindArrowFunction:
+    arrow := node.AsArrowFunction()
+    if arrow == nil || arrow.Body == nil || arrow.Body.Kind == shimast.KindBlock {
+      return
+    }
+    if isAssignmentExpression(stripParens(arrow.Body)) {
+      ctx.Report(node, "Arrow function should not return an assignment.")
+    }
+  }
 }
 
 // no-sequences: `(a, b)` — comma operator. Almost always a confusing
@@ -626,25 +626,25 @@ type noSequences struct{}
 func (noSequences) Name() string           { return "no-sequences" }
 func (noSequences) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noSequences) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if expr.OperatorToken.Kind != shimast.KindCommaToken {
-		return
-	}
-	// `for (a; b; c)` headers naturally use the comma operator;
-	// suppress when the parent is a ForStatement initializer/incrementor.
-	parent := node.Parent
-	if parent != nil && parent.Kind == shimast.KindForStatement {
-		return
-	}
-	// Allow when wrapped in parens (the canonical "I really mean it"
-	// idiom).
-	if parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
-		return
-	}
-	ctx.Report(node, "Unexpected use of comma operator.")
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindCommaToken {
+    return
+  }
+  // `for (a; b; c)` headers naturally use the comma operator;
+  // suppress when the parent is a ForStatement initializer/incrementor.
+  parent := node.Parent
+  if parent != nil && parent.Kind == shimast.KindForStatement {
+    return
+  }
+  // Allow when wrapped in parens (the canonical "I really mean it"
+  // idiom).
+  if parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
+    return
+  }
+  ctx.Report(node, "Unexpected use of comma operator.")
 }
 
 // no-shadow-restricted-names: redeclaring `undefined`, `NaN`, `Infinity`,
@@ -653,26 +653,26 @@ type noShadowRestrictedNames struct{}
 
 func (noShadowRestrictedNames) Name() string { return "no-shadow-restricted-names" }
 func (noShadowRestrictedNames) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindVariableDeclaration, shimast.KindParameter, shimast.KindFunctionDeclaration}
+  return []shimast.Kind{shimast.KindVariableDeclaration, shimast.KindParameter, shimast.KindFunctionDeclaration}
 }
 func (noShadowRestrictedNames) Check(ctx *Context, node *shimast.Node) {
-	var nameNode *shimast.Node
-	switch node.Kind {
-	case shimast.KindVariableDeclaration:
-		nameNode = node.AsVariableDeclaration().Name()
-	case shimast.KindParameter:
-		nameNode = node.AsParameterDeclaration().Name()
-	case shimast.KindFunctionDeclaration:
-		nameNode = node.AsFunctionDeclaration().Name()
-	}
-	name := identifierText(nameNode)
-	if name == "" {
-		return
-	}
-	switch name {
-	case "undefined", "NaN", "Infinity", "arguments", "eval":
-		ctx.Report(node, "Shadowing of global property '"+name+"'.")
-	}
+  var nameNode *shimast.Node
+  switch node.Kind {
+  case shimast.KindVariableDeclaration:
+    nameNode = node.AsVariableDeclaration().Name()
+  case shimast.KindParameter:
+    nameNode = node.AsParameterDeclaration().Name()
+  case shimast.KindFunctionDeclaration:
+    nameNode = node.AsFunctionDeclaration().Name()
+  }
+  name := identifierText(nameNode)
+  if name == "" {
+    return
+  }
+  switch name {
+  case "undefined", "NaN", "Infinity", "arguments", "eval":
+    ctx.Report(node, "Shadowing of global property '"+name+"'.")
+  }
 }
 
 // no-undefined: literal `undefined` (vs `void 0`). Easier to misuse
@@ -682,39 +682,39 @@ type noUndefined struct{}
 func (noUndefined) Name() string           { return "no-undefined" }
 func (noUndefined) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindIdentifier} }
 func (noUndefined) Check(ctx *Context, node *shimast.Node) {
-	if identifierText(node) != "undefined" {
-		return
-	}
-	parent := node.Parent
-	if parent == nil {
-		return
-	}
-	// Don't flag a declaration *named* `undefined` (no-shadow-restricted-names
-	// covers that), or a member-access / object-key position
-	// (`x.undefined`, `{ undefined: 1 }`).
-	switch parent.Kind {
-	case shimast.KindParameter:
-		decl := parent.AsParameterDeclaration()
-		if decl != nil && decl.Name() != nil && nodesShareLoc(decl.Name(), node) {
-			return
-		}
-	case shimast.KindVariableDeclaration:
-		decl := parent.AsVariableDeclaration()
-		if decl != nil && decl.Name() != nil && nodesShareLoc(decl.Name(), node) {
-			return
-		}
-	case shimast.KindPropertyAccessExpression:
-		access := parent.AsPropertyAccessExpression()
-		if access != nil && access.Name() != nil && nodesShareLoc(access.Name(), node) {
-			return
-		}
-	case shimast.KindPropertyAssignment:
-		assign := parent.AsPropertyAssignment()
-		if assign != nil && assign.Name() != nil && nodesShareLoc(assign.Name(), node) {
-			return
-		}
-	}
-	ctx.Report(node, "Unexpected use of undefined.")
+  if identifierText(node) != "undefined" {
+    return
+  }
+  parent := node.Parent
+  if parent == nil {
+    return
+  }
+  // Don't flag a declaration *named* `undefined` (no-shadow-restricted-names
+  // covers that), or a member-access / object-key position
+  // (`x.undefined`, `{ undefined: 1 }`).
+  switch parent.Kind {
+  case shimast.KindParameter:
+    decl := parent.AsParameterDeclaration()
+    if decl != nil && decl.Name() != nil && nodesShareLoc(decl.Name(), node) {
+      return
+    }
+  case shimast.KindVariableDeclaration:
+    decl := parent.AsVariableDeclaration()
+    if decl != nil && decl.Name() != nil && nodesShareLoc(decl.Name(), node) {
+      return
+    }
+  case shimast.KindPropertyAccessExpression:
+    access := parent.AsPropertyAccessExpression()
+    if access != nil && access.Name() != nil && nodesShareLoc(access.Name(), node) {
+      return
+    }
+  case shimast.KindPropertyAssignment:
+    assign := parent.AsPropertyAssignment()
+    if assign != nil && assign.Name() != nil && nodesShareLoc(assign.Name(), node) {
+      return
+    }
+  }
+  ctx.Report(node, "Unexpected use of undefined.")
 }
 
 // nodesShareLoc reports whether two `*ast.Node` references describe the
@@ -722,10 +722,10 @@ func (noUndefined) Check(ctx *Context, node *shimast.Node) {
 // parser exposes its fields through accessor methods that may return
 // fresh wrappers; comparing positions works regardless.
 func nodesShareLoc(a, b *shimast.Node) bool {
-	if a == nil || b == nil {
-		return false
-	}
-	return a == b || (a.Pos() == b.Pos() && a.End() == b.End())
+  if a == nil || b == nil {
+    return false
+  }
+  return a == b || (a.Pos() == b.Pos() && a.End() == b.End())
 }
 
 // no-unneeded-ternary: `x ? true : false` → `Boolean(x)` / `!!x`.
@@ -733,20 +733,20 @@ type noUnneededTernary struct{}
 
 func (noUnneededTernary) Name() string { return "no-unneeded-ternary" }
 func (noUnneededTernary) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindConditionalExpression}
+  return []shimast.Kind{shimast.KindConditionalExpression}
 }
 func (noUnneededTernary) Check(ctx *Context, node *shimast.Node) {
-	cond := node.AsConditionalExpression()
-	if cond == nil {
-		return
-	}
-	t := stripParens(cond.WhenTrue)
-	f := stripParens(cond.WhenFalse)
-	tBool, tOk := isLiteralBoolean(t)
-	fBool, fOk := isLiteralBoolean(f)
-	if tOk && fOk && tBool != fBool {
-		ctx.Report(node, "Unnecessary use of conditional expression for boolean.")
-	}
+  cond := node.AsConditionalExpression()
+  if cond == nil {
+    return
+  }
+  t := stripParens(cond.WhenTrue)
+  f := stripParens(cond.WhenFalse)
+  tBool, tOk := isLiteralBoolean(t)
+  fBool, fOk := isLiteralBoolean(f)
+  if tOk && fOk && tBool != fBool {
+    ctx.Report(node, "Unnecessary use of conditional expression for boolean.")
+  }
 }
 
 // no-unused-expressions: an expression statement whose value isn't used.
@@ -755,61 +755,61 @@ type noUnusedExpressions struct{}
 
 func (noUnusedExpressions) Name() string { return "no-unused-expressions" }
 func (noUnusedExpressions) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindExpressionStatement}
+  return []shimast.Kind{shimast.KindExpressionStatement}
 }
 func (noUnusedExpressions) Check(ctx *Context, node *shimast.Node) {
-	stmt := node.AsExpressionStatement()
-	if stmt == nil || stmt.Expression == nil {
-		return
-	}
-	if isProductiveExpression(stmt.Expression) {
-		return
-	}
-	ctx.Report(node, "Expected an assignment or function call and instead saw an expression.")
+  stmt := node.AsExpressionStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return
+  }
+  if isProductiveExpression(stmt.Expression) {
+    return
+  }
+  ctx.Report(node, "Expected an assignment or function call and instead saw an expression.")
 }
 
 func isProductiveExpression(node *shimast.Node) bool {
-	expr := stripParens(node)
-	if expr == nil {
-		return false
-	}
-	switch expr.Kind {
-	case shimast.KindCallExpression,
-		shimast.KindNewExpression,
-		shimast.KindAwaitExpression,
-		shimast.KindYieldExpression,
-		shimast.KindDeleteExpression,
-		shimast.KindBinaryExpression,
-		shimast.KindPrefixUnaryExpression,
-		shimast.KindPostfixUnaryExpression,
-		shimast.KindTaggedTemplateExpression:
-		// These can have side effects. The narrower checks
-		// (no-cond-assign, no-bitwise) handle the suspicious shapes.
-		switch expr.Kind {
-		case shimast.KindBinaryExpression:
-			bin := expr.AsBinaryExpression()
-			if bin != nil && bin.OperatorToken != nil && isAssignmentOperator(bin.OperatorToken.Kind) {
-				return true
-			}
-			return false
-		case shimast.KindPrefixUnaryExpression:
-			prefix := expr.AsPrefixUnaryExpression()
-			if prefix != nil && (prefix.Operator == shimast.KindPlusPlusToken || prefix.Operator == shimast.KindMinusMinusToken) {
-				return true
-			}
-			return false
-		case shimast.KindPostfixUnaryExpression:
-			return true
-		}
-		return true
-	case shimast.KindStringLiteral:
-		// "use strict" prologue.
-		text := expr.AsStringLiteral()
-		if text != nil && (text.Text == "use strict" || text.Text == "use asm") {
-			return true
-		}
-	}
-	return false
+  expr := stripParens(node)
+  if expr == nil {
+    return false
+  }
+  switch expr.Kind {
+  case shimast.KindCallExpression,
+    shimast.KindNewExpression,
+    shimast.KindAwaitExpression,
+    shimast.KindYieldExpression,
+    shimast.KindDeleteExpression,
+    shimast.KindBinaryExpression,
+    shimast.KindPrefixUnaryExpression,
+    shimast.KindPostfixUnaryExpression,
+    shimast.KindTaggedTemplateExpression:
+    // These can have side effects. The narrower checks
+    // (no-cond-assign, no-bitwise) handle the suspicious shapes.
+    switch expr.Kind {
+    case shimast.KindBinaryExpression:
+      bin := expr.AsBinaryExpression()
+      if bin != nil && bin.OperatorToken != nil && isAssignmentOperator(bin.OperatorToken.Kind) {
+        return true
+      }
+      return false
+    case shimast.KindPrefixUnaryExpression:
+      prefix := expr.AsPrefixUnaryExpression()
+      if prefix != nil && (prefix.Operator == shimast.KindPlusPlusToken || prefix.Operator == shimast.KindMinusMinusToken) {
+        return true
+      }
+      return false
+    case shimast.KindPostfixUnaryExpression:
+      return true
+    }
+    return true
+  case shimast.KindStringLiteral:
+    // "use strict" prologue.
+    text := expr.AsStringLiteral()
+    if text != nil && (text.Text == "use strict" || text.Text == "use asm") {
+      return true
+    }
+  }
+  return false
 }
 
 // no-useless-call: `func.call(undefined, ...args)` / `func.apply(undefined, args)`
@@ -819,26 +819,26 @@ type noUselessCall struct{}
 func (noUselessCall) Name() string           { return "no-useless-call" }
 func (noUselessCall) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noUselessCall) 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()
-	method := identifierText(access.Name())
-	if method != "call" && method != "apply" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
-		return
-	}
-	first := call.Arguments.Nodes[0]
-	first = stripParens(first)
-	if first == nil {
-		return
-	}
-	if first.Kind == shimast.KindNullKeyword || identifierText(first) == "undefined" {
-		ctx.Report(node, "Unnecessary "+method+"().")
-	}
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  method := identifierText(access.Name())
+  if method != "call" && method != "apply" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return
+  }
+  first := call.Arguments.Nodes[0]
+  first = stripParens(first)
+  if first == nil {
+    return
+  }
+  if first.Kind == shimast.KindNullKeyword || identifierText(first) == "undefined" {
+    ctx.Report(node, "Unnecessary "+method+"().")
+  }
 }
 
 // no-useless-computed-key: `{ ["foo"]: 1 }` could be `{ foo: 1 }`.
@@ -846,34 +846,34 @@ type noUselessComputedKey struct{}
 
 func (noUselessComputedKey) Name() string { return "no-useless-computed-key" }
 func (noUselessComputedKey) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAssignment, shimast.KindMethodDeclaration}
+  return []shimast.Kind{shimast.KindPropertyAssignment, shimast.KindMethodDeclaration}
 }
 func (noUselessComputedKey) Check(ctx *Context, node *shimast.Node) {
-	var name *shimast.Node
-	switch node.Kind {
-	case shimast.KindPropertyAssignment:
-		name = node.AsPropertyAssignment().Name()
-	case shimast.KindMethodDeclaration:
-		name = node.AsMethodDeclaration().Name()
-	}
-	if name == nil || name.Kind != shimast.KindComputedPropertyName {
-		return
-	}
-	computed := name.AsComputedPropertyName()
-	if computed == nil || computed.Expression == nil {
-		return
-	}
-	// Only fire when the computed key is a string / numeric / template
-	// literal — a bare identifier inside `[ ]` reads its *value* and is
-	// not equivalent to the same identifier as a static key.
-	expr := stripParens(computed.Expression)
-	switch expr.Kind {
-	case shimast.KindStringLiteral,
-		shimast.KindNoSubstitutionTemplateLiteral,
-		shimast.KindNumericLiteral,
-		shimast.KindBigIntLiteral:
-		ctx.Report(name, "Unnecessarily computed property key.")
-	}
+  var name *shimast.Node
+  switch node.Kind {
+  case shimast.KindPropertyAssignment:
+    name = node.AsPropertyAssignment().Name()
+  case shimast.KindMethodDeclaration:
+    name = node.AsMethodDeclaration().Name()
+  }
+  if name == nil || name.Kind != shimast.KindComputedPropertyName {
+    return
+  }
+  computed := name.AsComputedPropertyName()
+  if computed == nil || computed.Expression == nil {
+    return
+  }
+  // Only fire when the computed key is a string / numeric / template
+  // literal — a bare identifier inside `[ ]` reads its *value* and is
+  // not equivalent to the same identifier as a static key.
+  expr := stripParens(computed.Expression)
+  switch expr.Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral:
+    ctx.Report(name, "Unnecessarily computed property key.")
+  }
 }
 
 // no-useless-rename: `import { x as x } from ...` / `const { x: x } = obj`
@@ -882,35 +882,35 @@ type noUselessRename struct{}
 
 func (noUselessRename) Name() string { return "no-useless-rename" }
 func (noUselessRename) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindImportSpecifier, shimast.KindExportSpecifier, shimast.KindBindingElement}
+  return []shimast.Kind{shimast.KindImportSpecifier, shimast.KindExportSpecifier, shimast.KindBindingElement}
 }
 func (noUselessRename) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindImportSpecifier:
-		spec := node.AsImportSpecifier()
-		if spec == nil || spec.PropertyName == nil {
-			return
-		}
-		if identifierText(spec.PropertyName) == identifierText(spec.Name()) {
-			ctx.Report(node, "Import { x as x } is redundant.")
-		}
-	case shimast.KindExportSpecifier:
-		spec := node.AsExportSpecifier()
-		if spec == nil || spec.PropertyName == nil {
-			return
-		}
-		if identifierText(spec.PropertyName) == identifierText(spec.Name()) {
-			ctx.Report(node, "Export { x as x } is redundant.")
-		}
-	case shimast.KindBindingElement:
-		el := node.AsBindingElement()
-		if el == nil || el.PropertyName == nil {
-			return
-		}
-		if identifierText(el.PropertyName) == identifierText(el.Name()) {
-			ctx.Report(node, "Destructuring rename to the same name is redundant.")
-		}
-	}
+  switch node.Kind {
+  case shimast.KindImportSpecifier:
+    spec := node.AsImportSpecifier()
+    if spec == nil || spec.PropertyName == nil {
+      return
+    }
+    if identifierText(spec.PropertyName) == identifierText(spec.Name()) {
+      ctx.Report(node, "Import { x as x } is redundant.")
+    }
+  case shimast.KindExportSpecifier:
+    spec := node.AsExportSpecifier()
+    if spec == nil || spec.PropertyName == nil {
+      return
+    }
+    if identifierText(spec.PropertyName) == identifierText(spec.Name()) {
+      ctx.Report(node, "Export { x as x } is redundant.")
+    }
+  case shimast.KindBindingElement:
+    el := node.AsBindingElement()
+    if el == nil || el.PropertyName == nil {
+      return
+    }
+    if identifierText(el.PropertyName) == identifierText(el.Name()) {
+      ctx.Report(node, "Destructuring rename to the same name is redundant.")
+    }
+  }
 }
 
 // object-shorthand: `{ x: x }` → `{ x }`.
@@ -919,18 +919,18 @@ type objectShorthand struct{}
 func (objectShorthand) Name() string           { return "object-shorthand" }
 func (objectShorthand) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindPropertyAssignment} }
 func (objectShorthand) Check(ctx *Context, node *shimast.Node) {
-	prop := node.AsPropertyAssignment()
-	if prop == nil || prop.Name() == nil || prop.Initializer == nil {
-		return
-	}
-	keyName := identifierText(prop.Name())
-	valueName := identifierText(prop.Initializer)
-	if keyName == "" || valueName == "" {
-		return
-	}
-	if keyName == valueName {
-		ctx.Report(node, "Expected property shorthand.")
-	}
+  prop := node.AsPropertyAssignment()
+  if prop == nil || prop.Name() == nil || prop.Initializer == nil {
+    return
+  }
+  keyName := identifierText(prop.Name())
+  valueName := identifierText(prop.Initializer)
+  if keyName == "" || valueName == "" {
+    return
+  }
+  if keyName == valueName {
+    ctx.Report(node, "Expected property shorthand.")
+  }
 }
 
 // operator-assignment: `x = x + 1` → `x += 1`.
@@ -938,39 +938,39 @@ type operatorAssignment struct{}
 
 func (operatorAssignment) Name() string { return "operator-assignment" }
 func (operatorAssignment) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (operatorAssignment) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if expr.OperatorToken.Kind != shimast.KindEqualsToken {
-		return
-	}
-	if expr.Right == nil || expr.Right.Kind != shimast.KindBinaryExpression {
-		return
-	}
-	right := expr.Right.AsBinaryExpression()
-	if right == nil || right.OperatorToken == nil {
-		return
-	}
-	if !isCompoundEligibleOperator(right.OperatorToken.Kind) {
-		return
-	}
-	if nodeText(ctx.File, expr.Left) == nodeText(ctx.File, right.Left) {
-		ctx.Report(node, "Assignment can be replaced with compound operator.")
-	}
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindEqualsToken {
+    return
+  }
+  if expr.Right == nil || expr.Right.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  right := expr.Right.AsBinaryExpression()
+  if right == nil || right.OperatorToken == nil {
+    return
+  }
+  if !isCompoundEligibleOperator(right.OperatorToken.Kind) {
+    return
+  }
+  if nodeText(ctx.File, expr.Left) == nodeText(ctx.File, right.Left) {
+    ctx.Report(node, "Assignment can be replaced with compound operator.")
+  }
 }
 
 func isCompoundEligibleOperator(kind shimast.Kind) bool {
-	switch kind {
-	case shimast.KindPlusToken, shimast.KindAsteriskToken, shimast.KindSlashToken,
-		shimast.KindAsteriskAsteriskToken, shimast.KindAmpersandToken, shimast.KindBarToken,
-		shimast.KindCaretToken:
-		return true
-	}
-	return false
+  switch kind {
+  case shimast.KindPlusToken, shimast.KindAsteriskToken, shimast.KindSlashToken,
+    shimast.KindAsteriskAsteriskToken, shimast.KindAmpersandToken, shimast.KindBarToken,
+    shimast.KindCaretToken:
+    return true
+  }
+  return false
 }
 
 // prefer-exponentiation-operator: `Math.pow(a, b)` → `a ** b`.
@@ -978,17 +978,17 @@ type preferExponentiationOperator struct{}
 
 func (preferExponentiationOperator) Name() string { return "prefer-exponentiation-operator" }
 func (preferExponentiationOperator) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (preferExponentiationOperator) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil {
-		return
-	}
-	if !isMatchingPropertyAccess(call.Expression, "Math", "pow") {
-		return
-	}
-	ctx.Report(node, "Use the '**' operator instead of 'Math.pow'.")
+  call := node.AsCallExpression()
+  if call == nil {
+    return
+  }
+  if !isMatchingPropertyAccess(call.Expression, "Math", "pow") {
+    return
+  }
+  ctx.Report(node, "Use the '**' operator instead of 'Math.pow'.")
 }
 
 // prefer-spread: `fn.apply(null, args)` → `fn(...args)`.
@@ -997,29 +997,29 @@ type preferSpread struct{}
 func (preferSpread) Name() string           { return "prefer-spread" }
 func (preferSpread) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (preferSpread) 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 || identifierText(access.Name()) != "apply" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
-		return
-	}
-	first := stripParens(call.Arguments.Nodes[0])
-	if first == nil {
-		return
-	}
-	// ESLint default: only fire when the `this` arg is null/undefined,
-	// which is the canonical "I just want to spread" pattern.
-	if first.Kind == shimast.KindNullKeyword || identifierText(first) == "undefined" {
-		ctx.Report(node, "Use the spread operator instead of '.apply()'.")
-	}
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "apply" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+    return
+  }
+  first := stripParens(call.Arguments.Nodes[0])
+  if first == nil {
+    return
+  }
+  // ESLint default: only fire when the `this` arg is null/undefined,
+  // which is the canonical "I just want to spread" pattern.
+  if first.Kind == shimast.KindNullKeyword || identifierText(first) == "undefined" {
+    ctx.Report(node, "Use the spread operator instead of '.apply()'.")
+  }
 }
 
 // prefer-template: string concatenation that would read better as a
@@ -1030,44 +1030,44 @@ type preferTemplate struct{}
 func (preferTemplate) Name() string           { return "prefer-template" }
 func (preferTemplate) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (preferTemplate) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if expr.OperatorToken.Kind != shimast.KindPlusToken {
-		return
-	}
-	// Skip when the parent is also a string-concat — only the topmost
-	// `+` chain emits one finding.
-	parent := node.Parent
-	if parent != nil && parent.Kind == shimast.KindBinaryExpression {
-		parentBin := parent.AsBinaryExpression()
-		if parentBin != nil && parentBin.OperatorToken != nil && parentBin.OperatorToken.Kind == shimast.KindPlusToken {
-			return
-		}
-	}
-	hasString, hasOther := concatChainShape(node)
-	if hasString && hasOther {
-		ctx.Report(node, "Unexpected string concatenation.")
-	}
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindPlusToken {
+    return
+  }
+  // Skip when the parent is also a string-concat — only the topmost
+  // `+` chain emits one finding.
+  parent := node.Parent
+  if parent != nil && parent.Kind == shimast.KindBinaryExpression {
+    parentBin := parent.AsBinaryExpression()
+    if parentBin != nil && parentBin.OperatorToken != nil && parentBin.OperatorToken.Kind == shimast.KindPlusToken {
+      return
+    }
+  }
+  hasString, hasOther := concatChainShape(node)
+  if hasString && hasOther {
+    ctx.Report(node, "Unexpected string concatenation.")
+  }
 }
 
 func concatChainShape(node *shimast.Node) (hasString bool, hasOther bool) {
-	if node == nil {
-		return false, false
-	}
-	if node.Kind == shimast.KindBinaryExpression {
-		bin := node.AsBinaryExpression()
-		if bin != nil && bin.OperatorToken != nil && bin.OperatorToken.Kind == shimast.KindPlusToken {
-			ls, lo := concatChainShape(bin.Left)
-			rs, ro := concatChainShape(bin.Right)
-			return ls || rs, lo || ro
-		}
-	}
-	if isStringLikeLiteral(stripParens(node)) {
-		return true, false
-	}
-	return false, true
+  if node == nil {
+    return false, false
+  }
+  if node.Kind == shimast.KindBinaryExpression {
+    bin := node.AsBinaryExpression()
+    if bin != nil && bin.OperatorToken != nil && bin.OperatorToken.Kind == shimast.KindPlusToken {
+      ls, lo := concatChainShape(bin.Left)
+      rs, ro := concatChainShape(bin.Right)
+      return ls || rs, lo || ro
+    }
+  }
+  if isStringLikeLiteral(stripParens(node)) {
+    return true, false
+  }
+  return false, true
 }
 
 // require-yield: `function* gen() { return 1; }` — generators that
@@ -1076,58 +1076,58 @@ type requireYield struct{}
 
 func (requireYield) Name() string { return "require-yield" }
 func (requireYield) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindFunctionDeclaration, shimast.KindFunctionExpression, shimast.KindMethodDeclaration}
+  return []shimast.Kind{shimast.KindFunctionDeclaration, shimast.KindFunctionExpression, shimast.KindMethodDeclaration}
 }
 func (requireYield) Check(ctx *Context, node *shimast.Node) {
-	if !hasAsteriskModifier(node) {
-		return
-	}
-	body := node.Body()
-	if body == nil {
-		return
-	}
-	if !subtreeContainsYield(body) {
-		ctx.Report(node, "This generator function does not have 'yield'.")
-	}
+  if !hasAsteriskModifier(node) {
+    return
+  }
+  body := node.Body()
+  if body == nil {
+    return
+  }
+  if !subtreeContainsYield(body) {
+    ctx.Report(node, "This generator function does not have 'yield'.")
+  }
 }
 
 func hasAsteriskModifier(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	switch node.Kind {
-	case shimast.KindFunctionDeclaration:
-		decl := node.AsFunctionDeclaration()
-		return decl != nil && decl.AsteriskToken != nil
-	case shimast.KindFunctionExpression:
-		decl := node.AsFunctionExpression()
-		return decl != nil && decl.AsteriskToken != nil
-	case shimast.KindMethodDeclaration:
-		decl := node.AsMethodDeclaration()
-		return decl != nil && decl.AsteriskToken != nil
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindFunctionDeclaration:
+    decl := node.AsFunctionDeclaration()
+    return decl != nil && decl.AsteriskToken != nil
+  case shimast.KindFunctionExpression:
+    decl := node.AsFunctionExpression()
+    return decl != nil && decl.AsteriskToken != nil
+  case shimast.KindMethodDeclaration:
+    decl := node.AsMethodDeclaration()
+    return decl != nil && decl.AsteriskToken != nil
+  }
+  return false
 }
 
 func subtreeContainsYield(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	if node.Kind == shimast.KindYieldExpression {
-		return true
-	}
-	if isFunctionLikeKind(node) && node.Parent != nil {
-		return false
-	}
-	found := false
-	node.ForEachChild(func(child *shimast.Node) bool {
-		if subtreeContainsYield(child) {
-			found = true
-			return true
-		}
-		return false
-	})
-	return found
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindYieldExpression {
+    return true
+  }
+  if isFunctionLikeKind(node) && node.Parent != nil {
+    return false
+  }
+  found := false
+  node.ForEachChild(func(child *shimast.Node) bool {
+    if subtreeContainsYield(child) {
+      found = true
+      return true
+    }
+    return false
+  })
+  return found
 }
 
 // vars-on-top: `var` declarations should appear at the top of their
@@ -1137,65 +1137,65 @@ type varsOnTop struct{}
 func (varsOnTop) Name() string           { return "vars-on-top" }
 func (varsOnTop) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindVariableStatement} }
 func (varsOnTop) Check(ctx *Context, node *shimast.Node) {
-	stmt := node.AsVariableStatement()
-	if stmt == nil || stmt.DeclarationList == nil {
-		return
-	}
-	if !shimast.IsVar(stmt.DeclarationList) {
-		return
-	}
-	parent := node.Parent
-	if parent == nil {
-		return
-	}
-	switch parent.Kind {
-	case shimast.KindSourceFile, shimast.KindModuleBlock:
-	case shimast.KindBlock:
-		grand := parent.Parent
-		if grand == nil || !isFunctionLikeKind(grand) {
-			ctx.Report(node, "All 'var' declarations must be at the top of the function scope.")
-			return
-		}
-	default:
-		ctx.Report(node, "All 'var' declarations must be at the top of the function scope.")
-		return
-	}
-	// Same-block: must be the first non-trivial statement.
-	siblings := parentStatements(parent)
-	for _, sib := range siblings {
-		if sib == node {
-			return
-		}
-		if sib.Kind == shimast.KindVariableStatement {
-			continue
-		}
-		ctx.Report(node, "All 'var' declarations must be at the top of the function scope.")
-		return
-	}
+  stmt := node.AsVariableStatement()
+  if stmt == nil || stmt.DeclarationList == nil {
+    return
+  }
+  if !shimast.IsVar(stmt.DeclarationList) {
+    return
+  }
+  parent := node.Parent
+  if parent == nil {
+    return
+  }
+  switch parent.Kind {
+  case shimast.KindSourceFile, shimast.KindModuleBlock:
+  case shimast.KindBlock:
+    grand := parent.Parent
+    if grand == nil || !isFunctionLikeKind(grand) {
+      ctx.Report(node, "All 'var' declarations must be at the top of the function scope.")
+      return
+    }
+  default:
+    ctx.Report(node, "All 'var' declarations must be at the top of the function scope.")
+    return
+  }
+  // Same-block: must be the first non-trivial statement.
+  siblings := parentStatements(parent)
+  for _, sib := range siblings {
+    if sib == node {
+      return
+    }
+    if sib.Kind == shimast.KindVariableStatement {
+      continue
+    }
+    ctx.Report(node, "All 'var' declarations must be at the top of the function scope.")
+    return
+  }
 }
 
 func parentStatements(parent *shimast.Node) []*shimast.Node {
-	if parent == nil {
-		return nil
-	}
-	switch parent.Kind {
-	case shimast.KindBlock:
-		block := parent.AsBlock()
-		if block != nil && block.Statements != nil {
-			return block.Statements.Nodes
-		}
-	case shimast.KindSourceFile:
-		file := parent.AsSourceFile()
-		if file != nil && file.Statements != nil {
-			return file.Statements.Nodes
-		}
-	case shimast.KindModuleBlock:
-		mb := parent.AsModuleBlock()
-		if mb != nil && mb.Statements != nil {
-			return mb.Statements.Nodes
-		}
-	}
-	return nil
+  if parent == nil {
+    return nil
+  }
+  switch parent.Kind {
+  case shimast.KindBlock:
+    block := parent.AsBlock()
+    if block != nil && block.Statements != nil {
+      return block.Statements.Nodes
+    }
+  case shimast.KindSourceFile:
+    file := parent.AsSourceFile()
+    if file != nil && file.Statements != nil {
+      return file.Statements.Nodes
+    }
+  case shimast.KindModuleBlock:
+    mb := parent.AsModuleBlock()
+    if mb != nil && mb.Statements != nil {
+      return mb.Statements.Nodes
+    }
+  }
+  return nil
 }
 
 // yoda: `if (1 === x)` — ESLint flags literals on the left of a
@@ -1205,54 +1205,54 @@ type yoda struct{}
 func (yoda) Name() string           { return "yoda" }
 func (yoda) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (yoda) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if !isComparisonOperator(expr.OperatorToken.Kind) {
-		return
-	}
-	if isLiteralExpression(stripParens(expr.Left)) && !isLiteralExpression(stripParens(expr.Right)) {
-		ctx.Report(node, "Expected literal to be on the right side of comparison.")
-	}
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if !isComparisonOperator(expr.OperatorToken.Kind) {
+    return
+  }
+  if isLiteralExpression(stripParens(expr.Left)) && !isLiteralExpression(stripParens(expr.Right)) {
+    ctx.Report(node, "Expected literal to be on the right side of comparison.")
+  }
 }
 
 func init() {
-	Register(noAlert{})
-	Register(noBitwise{})
-	Register(noCaller{})
-	Register(noCaseDeclarations{})
-	Register(noContinue{})
-	Register(noDeleteVar{})
-	Register(noEqNull{})
-	Register(noExtraBind{})
-	Register(noLabels{})
-	Register(noLoneBlocks{})
-	Register(noLonelyIf{})
-	Register(noMultiAssign{})
-	Register(noNegatedCondition{})
-	Register(noNestedTernary{})
-	Register(noNew{})
-	Register(noNewFunc{})
-	Register(noObjectConstructor{})
-	Register(noOctalEscape{})
-	Register(noPlusPlus{})
-	Register(noRegexSpaces{})
-	Register(noReturnAssign{})
-	Register(noSequences{})
-	Register(noShadowRestrictedNames{})
-	Register(noUndefined{})
-	Register(noUnneededTernary{})
-	Register(noUnusedExpressions{})
-	Register(noUselessCall{})
-	Register(noUselessComputedKey{})
-	Register(noUselessRename{})
-	Register(objectShorthand{})
-	Register(operatorAssignment{})
-	Register(preferExponentiationOperator{})
-	Register(preferSpread{})
-	Register(preferTemplate{})
-	Register(requireYield{})
-	Register(varsOnTop{})
-	Register(yoda{})
+  Register(noAlert{})
+  Register(noBitwise{})
+  Register(noCaller{})
+  Register(noCaseDeclarations{})
+  Register(noContinue{})
+  Register(noDeleteVar{})
+  Register(noEqNull{})
+  Register(noExtraBind{})
+  Register(noLabels{})
+  Register(noLoneBlocks{})
+  Register(noLonelyIf{})
+  Register(noMultiAssign{})
+  Register(noNegatedCondition{})
+  Register(noNestedTernary{})
+  Register(noNew{})
+  Register(noNewFunc{})
+  Register(noObjectConstructor{})
+  Register(noOctalEscape{})
+  Register(noPlusPlus{})
+  Register(noRegexSpaces{})
+  Register(noReturnAssign{})
+  Register(noSequences{})
+  Register(noShadowRestrictedNames{})
+  Register(noUndefined{})
+  Register(noUnneededTernary{})
+  Register(noUnusedExpressions{})
+  Register(noUselessCall{})
+  Register(noUselessComputedKey{})
+  Register(noUselessRename{})
+  Register(objectShorthand{})
+  Register(operatorAssignment{})
+  Register(preferExponentiationOperator{})
+  Register(preferSpread{})
+  Register(preferTemplate{})
+  Register(requireYield{})
+  Register(varsOnTop{})
+  Register(yoda{})
 }