@ttsc/lint 0.18.4 → 0.19.0

package/linthost/rules_problems.go

@@ -8,45 +8,168 @@
 package linthost
 
 import (
-  "strconv"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-// noDupeElseIf: `if (a) {} else if (a) {}` — the second branch is
-// unreachable.
+// noDupeElseIf rejects an else-if branch when earlier conditions in the
+// same chain already cover every path that can make its condition true.
 type noDupeElseIf struct{}
 
 func (noDupeElseIf) Name() string           { return "no-dupe-else-if" }
 func (noDupeElseIf) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindIfStatement} }
 func (noDupeElseIf) Check(ctx *Context, node *shimast.Node) {
-  // Only fire on the *outermost* if; the recursion below scans the
-  // chain once.
-  if parent := node.Parent; parent != nil {
-    if parent.Kind == shimast.KindIfStatement {
-      outer := parent.AsIfStatement()
-      if outer != nil && outer.ElseStatement == node {
-        return
-      }
+  statement := node.AsIfStatement()
+  if statement == nil || statement.Expression == nil {
+    return
+  }
+
+  test := stripParens(statement.Expression)
+  conditionsToCheck := []*shimast.Node{test}
+  if noDupeElseIfLogicalOperator(test) == shimast.KindAmpersandAmpersandToken {
+    conditionsToCheck = append(conditionsToCheck, noDupeElseIfSplit(test, shimast.KindAmpersandAmpersandToken)...)
+  }
+
+  candidates := make([][][]*shimast.Node, 0, len(conditionsToCheck))
+  for _, condition := range conditionsToCheck {
+    orOperands := noDupeElseIfSplit(condition, shimast.KindBarBarToken)
+    conjunctions := make([][]*shimast.Node, 0, len(orOperands))
+    for _, operand := range orOperands {
+      conjunctions = append(conjunctions, noDupeElseIfSplit(operand, shimast.KindAmpersandAmpersandToken))
     }
+    candidates = append(candidates, conjunctions)
   }
-  seen := map[string]bool{}
-  cur := node
-  for cur != nil && cur.Kind == shimast.KindIfStatement {
-    stmt := cur.AsIfStatement()
-    if stmt == nil || stmt.Expression == nil {
+
+  current := node
+  for current.Parent != nil && current.Parent.Kind == shimast.KindIfStatement {
+    parent := current.Parent
+    parentStatement := parent.AsIfStatement()
+    if parentStatement == nil || parentStatement.ElseStatement != current || parentStatement.Expression == nil {
       break
     }
-    key := nodeText(ctx.File, stmt.Expression)
-    if key != "" {
-      if seen[key] {
-        ctx.Report(stmt.Expression, "This branch can never execute. Its condition is a duplicate of an earlier branch.")
-      } else {
-        seen[key] = true
+
+    earlierOrOperands := noDupeElseIfSplit(stripParens(parentStatement.Expression), shimast.KindBarBarToken)
+    earlierConjunctions := make([][]*shimast.Node, 0, len(earlierOrOperands))
+    for _, operand := range earlierOrOperands {
+      earlierConjunctions = append(earlierConjunctions, noDupeElseIfSplit(operand, shimast.KindAmpersandAmpersandToken))
+    }
+
+    for i, disjunction := range candidates {
+      remaining := disjunction[:0]
+      for _, conjunction := range disjunction {
+        covered := false
+        for _, earlier := range earlierConjunctions {
+          if noDupeElseIfSubset(ctx.File, earlier, conjunction) {
+            covered = true
+            break
+          }
+        }
+        if !covered {
+          remaining = append(remaining, conjunction)
+        }
+      }
+      candidates[i] = remaining
+      if len(remaining) == 0 {
+        ctx.Report(statement.Expression, "This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain.")
+        return
       }
     }
-    cur = stmt.ElseStatement
+
+    current = parent
+  }
+}
+
+func noDupeElseIfLogicalOperator(node *shimast.Node) shimast.Kind {
+  node = stripParens(node)
+  if node == nil || node.Kind != shimast.KindBinaryExpression {
+    return shimast.KindUnknown
+  }
+  expression := node.AsBinaryExpression()
+  if expression == nil || expression.OperatorToken == nil {
+    return shimast.KindUnknown
+  }
+  switch expression.OperatorToken.Kind {
+  case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
+    return expression.OperatorToken.Kind
+  default:
+    return shimast.KindUnknown
+  }
+}
+
+func noDupeElseIfSplit(node *shimast.Node, operator shimast.Kind) []*shimast.Node {
+  node = stripParens(node)
+  if noDupeElseIfLogicalOperator(node) != operator {
+    return []*shimast.Node{node}
+  }
+  expression := node.AsBinaryExpression()
+  operands := noDupeElseIfSplit(expression.Left, operator)
+  return append(operands, noDupeElseIfSplit(expression.Right, operator)...)
+}
+
+func noDupeElseIfSubset(file *shimast.SourceFile, subset, set []*shimast.Node) bool {
+  for _, candidate := range subset {
+    matched := false
+    for _, element := range set {
+      if noDupeElseIfEqual(file, candidate, element) {
+        matched = true
+        break
+      }
+    }
+    if !matched {
+      return false
+    }
+  }
+  return true
+}
+
+// noDupeElseIfEqual compares boolean expressions structurally. Logical AND
+// and OR are commutative in a condition's truth table; every other expression
+// must retain the same token kinds and values.
+func noDupeElseIfEqual(file *shimast.SourceFile, left, right *shimast.Node) bool {
+  left = stripParens(left)
+  right = stripParens(right)
+  if left == nil || right == nil || left.Kind != right.Kind {
+    return false
+  }
+
+  operator := noDupeElseIfLogicalOperator(left)
+  if operator != shimast.KindUnknown && operator == noDupeElseIfLogicalOperator(right) {
+    leftExpression := left.AsBinaryExpression()
+    rightExpression := right.AsBinaryExpression()
+    return noDupeElseIfEqual(file, leftExpression.Left, rightExpression.Left) &&
+      noDupeElseIfEqual(file, leftExpression.Right, rightExpression.Right) ||
+      noDupeElseIfEqual(file, leftExpression.Left, rightExpression.Right) &&
+        noDupeElseIfEqual(file, leftExpression.Right, rightExpression.Left)
+  }
+
+  return noDupeElseIfEqualTokens(file, left, right)
+}
+
+func noDupeElseIfEqualTokens(file *shimast.SourceFile, left, right *shimast.Node) bool {
+  leftText := nodeText(file, left)
+  rightText := nodeText(file, right)
+  if leftText == "" || rightText == "" {
+    return false
+  }
+
+  leftScanner := shimscanner.NewScanner()
+  leftScanner.SetText(leftText)
+  leftScanner.SetSkipTrivia(true)
+  rightScanner := shimscanner.NewScanner()
+  rightScanner.SetText(rightText)
+  rightScanner.SetSkipTrivia(true)
+
+  for {
+    leftKind := leftScanner.Scan()
+    rightKind := rightScanner.Scan()
+    if leftKind != rightKind || leftScanner.TokenText() != rightScanner.TokenText() {
+      return false
+    }
+    if leftKind == shimast.KindEndOfFile {
+      return true
+    }
   }
 }
 
@@ -75,9 +198,9 @@ func (noExAssign) Check(ctx *Context, node *shimast.Node) {
 }
 
 // walkAssignments invokes `report` on every `<name> = ...` shape inside
-// `root`. Used by noExAssign to scan a single catch block; the
-// file-wide noFuncAssign / noClassAssign scans go through
-// reportAssignmentsToDeclarations instead.
+// `root`. It is retained for noExAssign's catch-block-local scan; class and
+// function assignment rules require checker binding identity and live in
+// their dedicated files.
 func walkAssignments(root *shimast.Node, name string, report func(*shimast.Node)) {
   if root == nil {
     return
@@ -107,33 +230,12 @@ func (noEmptyCharacterClass) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindRegularExpressionLiteral}
 }
 func (noEmptyCharacterClass) Check(ctx *Context, node *shimast.Node) {
-  src := nodeText(ctx.File, node)
-  if hasEmptyCharClass(src) {
+  parts, ok := parseRegexpLiteralParts(ctx, node)
+  if ok && regexpHasEmptyCharacterClass(parts) {
     ctx.Report(node, "Empty class.")
   }
 }
 
-// hasEmptyCharClass reports whether the regex source text src contains an
-// empty character class (`[]` or `[^]`). Respects backslash escapes.
-func hasEmptyCharClass(src string) bool {
-  // Walk the regex literal source manually, respecting escapes.
-  for i := 0; i < len(src); i++ {
-    switch src[i] {
-    case '\\':
-      i++ // skip escape
-    case '[':
-      j := i + 1
-      if j < len(src) && src[j] == '^' {
-        j++
-      }
-      if j < len(src) && src[j] == ']' {
-        return true
-      }
-    }
-  }
-  return false
-}
-
 // noMisleadingCharacterClass: `/[👍]/` — surrogate pairs in regex.
 type noMisleadingCharacterClass struct{}
 
@@ -179,10 +281,9 @@ func regexHasSurrogatePair(src string) bool {
   return false
 }
 
-// noLossOfPrecision: `9007199254740993` — decimal numeric literal whose
-// source text changes when parsed as a JavaScript Number. We read the source
-// form instead of the parser's normalized .Text, which has already lost
-// precision.
+// noLossOfPrecision: a Number literal whose requested significant digits
+// change during IEEE-754 conversion. We read the source form instead of the
+// parser's normalized .Text, which has already lost spelling and precision.
 type noLossOfPrecision struct{}
 
 func (noLossOfPrecision) Name() string           { return "no-loss-of-precision" }
@@ -197,128 +298,6 @@ func (noLossOfPrecision) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// numericLiteralLosesPrecision reports whether the decimal integer literal text
-// changes when parsed as a JavaScript Number. Non-decimal literals (hex, octal,
-// binary) and literals with exponents or decimal points are exempt because
-// their precision loss is caller-visible and intentional.
-func numericLiteralLosesPrecision(text string) bool {
-  // Strip underscore separators, exponents, decimal/hex/oct/binary
-  // markers — for the simple-base-10 integer case the round-trip
-  // parse → format check is sufficient.
-  clean := strings.ReplaceAll(text, "_", "")
-  if strings.ContainsAny(clean, "eE.xXoObB") {
-    return false
-  }
-  if len(clean) < 16 {
-    return false
-  }
-  // Trim leading zeros for comparison.
-  trimmed := strings.TrimLeft(clean, "0")
-  if trimmed == "" {
-    return false
-  }
-  // 2^53 is unsafe for arithmetic comparisons but still exactly representable.
-  // 2^53+1 is the first plain decimal integer that changes when parsed.
-  const firstPossibleLoss = "9007199254740993"
-  if len(trimmed) < len(firstPossibleLoss) {
-    return false
-  }
-  if len(trimmed) == len(firstPossibleLoss) && trimmed < firstPossibleLoss {
-    return false
-  }
-  // Number.MAX_VALUE is around 1.79e308, so any integer with more than 309
-  // decimal digits cannot round-trip through a finite JavaScript Number.
-  const maxFiniteDecimalDigits = 309
-  if len(trimmed) > maxFiniteDecimalDigits {
-    return true
-  }
-  parsed, err := strconv.ParseFloat(trimmed, 64)
-  if err != nil && parsed == 0 {
-    return false
-  }
-  return strconv.FormatFloat(parsed, 'f', 0, 64) != trimmed
-}
-
-// noClassAssign: assigning to a class declaration's name.
-type noClassAssign struct{}
-
-func (noClassAssign) Name() string           { return "no-class-assign" }
-func (noClassAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
-func (noClassAssign) Check(ctx *Context, node *shimast.Node) {
-  reportAssignmentsToDeclarations(ctx, node, shimast.KindClassDeclaration, "is a class.")
-}
-
-// noFuncAssign: same idea, but for function declarations.
-type noFuncAssign struct{}
-
-func (noFuncAssign) Name() string           { return "no-func-assign" }
-func (noFuncAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
-func (noFuncAssign) Check(ctx *Context, node *shimast.Node) {
-  reportAssignmentsToDeclarations(ctx, node, shimast.KindFunctionDeclaration, "is a function.")
-}
-
-// reportAssignmentsToDeclarations flags every `<name> = …` assignment whose
-// target identifier names a `declKind` declaration found anywhere in the
-// file. It walks the file exactly once — gathering declared names and
-// assignment targets in the same pass — so the cost is linear in file size.
-//
-// The earlier shape registered for `declKind` directly and, on every
-// declaration, re-scanned the whole file for assignments: O(declarations ×
-// file size), which blows up quadratically on a file with many top-level
-// functions. Visiting `KindSourceFile` once and cross-referencing afterward
-// keeps the same findings without the repeated scans.
-func reportAssignmentsToDeclarations(
-  ctx *Context,
-  file *shimast.Node,
-  declKind shimast.Kind,
-  noun string,
-) {
-  if ctx == nil || file == nil {
-    return
-  }
-  declared := map[string]struct{}{}
-  var targets []*shimast.Node
-  walkDescendants(file, func(n *shimast.Node) {
-    switch n.Kind {
-    case declKind:
-      if name := declarationName(n); name != "" {
-        declared[name] = struct{}{}
-      }
-    case shimast.KindBinaryExpression:
-      if expr := n.AsBinaryExpression(); expr != nil &&
-        expr.OperatorToken != nil && isAssignmentOperator(expr.OperatorToken.Kind) &&
-        expr.Left != nil && expr.Left.Kind == shimast.KindIdentifier {
-        targets = append(targets, expr.Left)
-      }
-    }
-  })
-  if len(declared) == 0 || len(targets) == 0 {
-    return
-  }
-  for _, target := range targets {
-    name := identifierText(target)
-    if _, ok := declared[name]; ok {
-      ctx.Report(target, "'"+name+"' "+noun)
-    }
-  }
-}
-
-// declarationName returns the bound name of a class or function declaration
-// node, or "" when the node is neither (or is anonymous).
-func declarationName(n *shimast.Node) string {
-  switch n.Kind {
-  case shimast.KindFunctionDeclaration:
-    if d := n.AsFunctionDeclaration(); d != nil {
-      return identifierText(d.Name())
-    }
-  case shimast.KindClassDeclaration:
-    if d := n.AsClassDeclaration(); d != nil {
-      return identifierText(d.Name())
-    }
-  }
-  return ""
-}
-
 // noPrototypeBuiltins: `obj.hasOwnProperty(x)` — should be
 // `Object.prototype.hasOwnProperty.call(obj, x)` or `Object.hasOwn`.
 type noPrototypeBuiltins struct{}
@@ -371,36 +350,6 @@ func (noAsyncPromiseExecutor) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// noPromiseExecutorReturn: `new Promise(() => 1)` — the value is
-// thrown away.
-type noPromiseExecutorReturn struct{}
-
-func (noPromiseExecutorReturn) Name() string { return "no-promise-executor-return" }
-func (noPromiseExecutorReturn) Visits() []shimast.Kind {
-  return []shimast.Kind{shimast.KindNewExpression}
-}
-func (noPromiseExecutorReturn) Check(ctx *Context, node *shimast.Node) {
-  ne := node.AsNewExpression()
-  if ne == nil || identifierText(ne.Expression) != "Promise" {
-    return
-  }
-  if ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
-    return
-  }
-  executor := ne.Arguments.Nodes[0]
-  if executor == nil || executor.Kind != shimast.KindArrowFunction {
-    return
-  }
-  arrow := executor.AsArrowFunction()
-  if arrow == nil || arrow.Body == nil {
-    return
-  }
-  // Concise arrow body returns the value implicitly.
-  if arrow.Body.Kind != shimast.KindBlock {
-    ctx.Report(arrow.Body, "Return values from promise executor functions cannot be read.")
-  }
-}
-
 // noControlRegex: `/\x00/` — control characters in regex are usually
 // the result of accidentally typing the escape rather than the printable
 // counterpart.
@@ -502,107 +451,6 @@ func isIrregularWhitespace(r rune) bool {
   return false
 }
 
-// noFallthrough: `switch` cases that fall through to the next label
-// without an explicit `break` / `return` / `throw` / `continue`.
-type noFallthrough struct{}
-
-func (noFallthrough) Name() string           { return "no-fallthrough" }
-func (noFallthrough) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSwitchStatement} }
-func (noFallthrough) Check(ctx *Context, node *shimast.Node) {
-  sw := node.AsSwitchStatement()
-  if sw == nil || sw.CaseBlock == nil {
-    return
-  }
-  block := sw.CaseBlock.AsCaseBlock()
-  if block == nil || block.Clauses == nil {
-    return
-  }
-  clauses := block.Clauses.Nodes
-  for i := 0; i+1 < len(clauses); i++ {
-    clause := clauses[i].AsCaseOrDefaultClause()
-    if clause == nil || clause.Statements == nil {
-      continue
-    }
-    stmts := clause.Statements.Nodes
-    if len(stmts) == 0 {
-      continue // empty case is intentional, never a fallthrough.
-    }
-    if !isTerminating(stmts[len(stmts)-1]) {
-      ctx.Report(clauses[i+1], "Expected a 'break' statement before this case.")
-    }
-  }
-}
-
-// isTerminating reports whether stmt is a statement that unconditionally
-// transfers control out of the current block: break, continue, return,
-// throw, or a block whose last statement is terminating.
-func isTerminating(stmt *shimast.Node) bool {
-  if stmt == nil {
-    return false
-  }
-  switch stmt.Kind {
-  case shimast.KindBreakStatement,
-    shimast.KindContinueStatement,
-    shimast.KindReturnStatement,
-    shimast.KindThrowStatement:
-    return true
-  case shimast.KindBlock:
-    block := stmt.AsBlock()
-    if block == nil || block.Statements == nil {
-      return false
-    }
-    nodes := block.Statements.Nodes
-    if len(nodes) == 0 {
-      return false
-    }
-    return isTerminating(nodes[len(nodes)-1])
-  }
-  return false
-}
-
-// noInnerDeclarations: `function foo() { if (x) { function bar() {} } }`
-// — inner function declarations are hoisted differently in strict mode
-// vs sloppy and are confusing.
-type noInnerDeclarations struct{}
-
-func (noInnerDeclarations) Name() string { return "no-inner-declarations" }
-func (noInnerDeclarations) Visits() []shimast.Kind {
-  return []shimast.Kind{shimast.KindFunctionDeclaration, shimast.KindVariableStatement}
-}
-func (noInnerDeclarations) Check(ctx *Context, node *shimast.Node) {
-  if node.Kind == shimast.KindVariableStatement {
-    stmt := node.AsVariableStatement()
-    if stmt == nil || stmt.DeclarationList == nil {
-      return
-    }
-    // Only `var` is hoisted oddly.
-    if !shimast.IsVar(stmt.DeclarationList) {
-      return
-    }
-  }
-  parent := node.Parent
-  if parent == nil {
-    return
-  }
-  switch parent.Kind {
-  case shimast.KindSourceFile, shimast.KindModuleBlock:
-    return
-  case shimast.KindBlock:
-    grand := parent.Parent
-    if grand == nil {
-      return
-    }
-    if isFunctionLikeKind(grand) {
-      return
-    }
-  }
-  what := "function"
-  if node.Kind == shimast.KindVariableStatement {
-    what = "variable"
-  }
-  ctx.Report(node, "Move "+what+" declaration to the function scope.")
-}
-
 // noObjCalls: `Math()`, `JSON()` — these globals are objects, not
 // callables. ESLint catches a small list.
 type noObjCalls struct{}
@@ -656,14 +504,9 @@ func init() {
   Register(noEmptyCharacterClass{})
   Register(noMisleadingCharacterClass{})
   Register(noLossOfPrecision{})
-  Register(noClassAssign{})
-  Register(noFuncAssign{})
   Register(noPrototypeBuiltins{})
   Register(noAsyncPromiseExecutor{})
-  Register(noPromiseExecutorReturn{})
   Register(noControlRegex{})
   Register(noIrregularWhitespace{})
-  Register(noFallthrough{})
-  Register(noInnerDeclarations{})
   Register(noObjCalls{})
 }