@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_no_shadow.go

@@ -26,122 +26,122 @@ type noShadow struct{}
 func (noShadow) Name() string           { return "no-shadow" }
 func (noShadow) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (noShadow) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	// Each frame records the names declared at that lexical level.
-	// `isFunction` marks frames that absorb hoisted `var` bindings.
-	type frame struct {
-		names      map[string]bool
-		isFunction bool
-	}
-	stack := []*frame{{names: map[string]bool{}, isFunction: true}}
+  if node == nil {
+    return
+  }
+  // Each frame records the names declared at that lexical level.
+  // `isFunction` marks frames that absorb hoisted `var` bindings.
+  type frame struct {
+    names      map[string]bool
+    isFunction bool
+  }
+  stack := []*frame{{names: map[string]bool{}, isFunction: true}}
 
-	outerHas := func(name string) bool {
-		for i := len(stack) - 2; i >= 0; i-- {
-			if stack[i].names[name] {
-				return true
-			}
-		}
-		return false
-	}
+  outerHas := func(name string) bool {
+    for i := len(stack) - 2; i >= 0; i-- {
+      if stack[i].names[name] {
+        return true
+      }
+    }
+    return false
+  }
 
-	declare := func(name string, declNode *shimast.Node, hoist bool) {
-		if name == "" {
-			return
-		}
-		target := stack[len(stack)-1]
-		if hoist {
-			for i := len(stack) - 1; i >= 0; i-- {
-				if stack[i].isFunction {
-					target = stack[i]
-					break
-				}
-			}
-		}
-		if outerHas(name) {
-			ctx.Report(declNode, "'"+name+"' is already declared in the upper scope.")
-		}
-		target.names[name] = true
-	}
+  declare := func(name string, declNode *shimast.Node, hoist bool) {
+    if name == "" {
+      return
+    }
+    target := stack[len(stack)-1]
+    if hoist {
+      for i := len(stack) - 1; i >= 0; i-- {
+        if stack[i].isFunction {
+          target = stack[i]
+          break
+        }
+      }
+    }
+    if outerHas(name) {
+      ctx.Report(declNode, "'"+name+"' is already declared in the upper scope.")
+    }
+    target.names[name] = true
+  }
 
-	var walk func(n *shimast.Node)
-	walk = func(n *shimast.Node) {
-		if n == nil {
-			return
-		}
-		// Bind a function declaration's name in the enclosing scope
-		// before descending into its body. `var`-style hoisting takes
-		// the name to the nearest function frame.
-		if n.Kind == shimast.KindFunctionDeclaration {
-			if decl := n.AsFunctionDeclaration(); decl != nil && decl.Body != nil {
-				if name := identifierText(decl.Name()); name != "" {
-					declare(name, n, true)
-				}
-			}
-		}
-		// Push a frame for every scope-introducing node. Function-like
-		// frames also receive their parameter names before descending.
-		if isFunctionLikeKind(n) {
-			stack = append(stack, &frame{names: map[string]bool{}, isFunction: true})
-			for _, name := range parameterBindingNames(n) {
-				declare(name, n, false)
-			}
-			n.ForEachChild(func(child *shimast.Node) bool {
-				walk(child)
-				return false
-			})
-			stack = stack[:len(stack)-1]
-			return
-		}
-		switch n.Kind {
-		case shimast.KindBlock, shimast.KindCatchClause:
-			// Function bodies are blocks too, but the function frame
-			// pushed above already represents that scope — skip the
-			// extra frame so a parameter and a body-level `let` of the
-			// same name still register as a redeclare, not a shadow.
-			if n.Kind == shimast.KindBlock && n.Parent != nil && isFunctionLikeKind(n.Parent) {
-				n.ForEachChild(func(child *shimast.Node) bool {
-					walk(child)
-					return false
-				})
-				return
-			}
-			stack = append(stack, &frame{names: map[string]bool{}})
-			if catch := n.AsCatchClause(); catch != nil && catch.VariableDeclaration != nil {
-				if name := identifierText(catch.VariableDeclaration.Name()); name != "" {
-					declare(name, catch.VariableDeclaration, false)
-				}
-			}
-			n.ForEachChild(func(child *shimast.Node) bool {
-				walk(child)
-				return false
-			})
-			stack = stack[:len(stack)-1]
-			return
-		case shimast.KindVariableStatement:
-			vs := n.AsVariableStatement()
-			if vs != nil && vs.DeclarationList != nil {
-				hoist := shimast.IsVar(vs.DeclarationList)
-				for _, name := range variableStatementBindingNames(n) {
-					declare(name, n, hoist)
-				}
-			}
-		case shimast.KindClassDeclaration:
-			if decl := n.AsClassDeclaration(); decl != nil {
-				if name := identifierText(decl.Name()); name != "" {
-					declare(name, n, false)
-				}
-			}
-		}
-		n.ForEachChild(func(child *shimast.Node) bool {
-			walk(child)
-			return false
-		})
-	}
-	walk(node)
+  var walk func(n *shimast.Node)
+  walk = func(n *shimast.Node) {
+    if n == nil {
+      return
+    }
+    // Bind a function declaration's name in the enclosing scope
+    // before descending into its body. `var`-style hoisting takes
+    // the name to the nearest function frame.
+    if n.Kind == shimast.KindFunctionDeclaration {
+      if decl := n.AsFunctionDeclaration(); decl != nil && decl.Body != nil {
+        if name := identifierText(decl.Name()); name != "" {
+          declare(name, n, true)
+        }
+      }
+    }
+    // Push a frame for every scope-introducing node. Function-like
+    // frames also receive their parameter names before descending.
+    if isFunctionLikeKind(n) {
+      stack = append(stack, &frame{names: map[string]bool{}, isFunction: true})
+      for _, name := range parameterBindingNames(n) {
+        declare(name, n, false)
+      }
+      n.ForEachChild(func(child *shimast.Node) bool {
+        walk(child)
+        return false
+      })
+      stack = stack[:len(stack)-1]
+      return
+    }
+    switch n.Kind {
+    case shimast.KindBlock, shimast.KindCatchClause:
+      // Function bodies are blocks too, but the function frame
+      // pushed above already represents that scope — skip the
+      // extra frame so a parameter and a body-level `let` of the
+      // same name still register as a redeclare, not a shadow.
+      if n.Kind == shimast.KindBlock && n.Parent != nil && isFunctionLikeKind(n.Parent) {
+        n.ForEachChild(func(child *shimast.Node) bool {
+          walk(child)
+          return false
+        })
+        return
+      }
+      stack = append(stack, &frame{names: map[string]bool{}})
+      if catch := n.AsCatchClause(); catch != nil && catch.VariableDeclaration != nil {
+        if name := identifierText(catch.VariableDeclaration.Name()); name != "" {
+          declare(name, catch.VariableDeclaration, false)
+        }
+      }
+      n.ForEachChild(func(child *shimast.Node) bool {
+        walk(child)
+        return false
+      })
+      stack = stack[:len(stack)-1]
+      return
+    case shimast.KindVariableStatement:
+      vs := n.AsVariableStatement()
+      if vs != nil && vs.DeclarationList != nil {
+        hoist := shimast.IsVar(vs.DeclarationList)
+        for _, name := range variableStatementBindingNames(n) {
+          declare(name, n, hoist)
+        }
+      }
+    case shimast.KindClassDeclaration:
+      if decl := n.AsClassDeclaration(); decl != nil {
+        if name := identifierText(decl.Name()); name != "" {
+          declare(name, n, false)
+        }
+      }
+    }
+    n.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(node)
 }
 
 func init() {
-	Register(noShadow{})
+  Register(noShadow{})
 }

package/linthost/rules_no_unreachable.go

@@ -13,54 +13,54 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noUnreachable struct{}
 
 func (noUnreachable) Name() string { return "no-unreachable" }
 func (noUnreachable) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindBlock,
-		shimast.KindSourceFile,
-		shimast.KindModuleBlock,
-	}
+  return []shimast.Kind{
+    shimast.KindBlock,
+    shimast.KindSourceFile,
+    shimast.KindModuleBlock,
+  }
 }
 func (noUnreachable) Check(ctx *Context, node *shimast.Node) {
-	stmts := node.Statements()
-	if len(stmts) < 2 {
-		return
-	}
-	terminated := false
-	for _, stmt := range stmts {
-		if stmt == nil {
-			continue
-		}
-		if terminated && !isHoistableDeclaration(stmt) {
-			ctx.Report(stmt, "Unreachable code.")
-			continue
-		}
-		if isControlFlowTerminator(stmt) {
-			terminated = true
-		}
-	}
+  stmts := node.Statements()
+  if len(stmts) < 2 {
+    return
+  }
+  terminated := false
+  for _, stmt := range stmts {
+    if stmt == nil {
+      continue
+    }
+    if terminated && !isHoistableDeclaration(stmt) {
+      ctx.Report(stmt, "Unreachable code.")
+      continue
+    }
+    if isControlFlowTerminator(stmt) {
+      terminated = true
+    }
+  }
 }
 
 // isControlFlowTerminator reports whether `stmt` is one of the four
 // statement kinds that unconditionally leave the surrounding block:
 // `return`, `throw`, `break`, `continue`.
 func isControlFlowTerminator(stmt *shimast.Node) bool {
-	if stmt == nil {
-		return false
-	}
-	switch stmt.Kind {
-	case shimast.KindReturnStatement,
-		shimast.KindThrowStatement,
-		shimast.KindBreakStatement,
-		shimast.KindContinueStatement:
-		return true
-	}
-	return false
+  if stmt == nil {
+    return false
+  }
+  switch stmt.Kind {
+  case shimast.KindReturnStatement,
+    shimast.KindThrowStatement,
+    shimast.KindBreakStatement,
+    shimast.KindContinueStatement:
+    return true
+  }
+  return false
 }
 
 // isHoistableDeclaration reports whether `stmt` is a declaration whose
@@ -69,9 +69,9 @@ func isControlFlowTerminator(stmt *shimast.Node) bool {
 // `function f() {…}` after a `return` is still callable from earlier
 // statements and is not dead code in the ESLint sense.
 func isHoistableDeclaration(stmt *shimast.Node) bool {
-	return stmt != nil && stmt.Kind == shimast.KindFunctionDeclaration
+  return stmt != nil && stmt.Kind == shimast.KindFunctionDeclaration
 }
 
 func init() {
-	Register(noUnreachable{})
+  Register(noUnreachable{})
 }

package/linthost/rules_no_useless_assignment.go

@@ -13,40 +13,40 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noUselessAssignment struct{}
 
 func (noUselessAssignment) Name() string { return "no-useless-assignment" }
 func (noUselessAssignment) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBlock}
+  return []shimast.Kind{shimast.KindBlock}
 }
 func (noUselessAssignment) Check(ctx *Context, node *shimast.Node) {
-	block := node.AsBlock()
-	if block == nil || block.Statements == nil {
-		return
-	}
-	stmts := block.Statements.Nodes
-	if len(stmts) < 2 {
-		return
-	}
-	for i := 0; i+1 < len(stmts); i++ {
-		firstName, firstAssign := plainAssignmentTarget(stmts[i])
-		if firstName == "" {
-			continue
-		}
-		secondName, _ := plainAssignmentTarget(stmts[i+1])
-		if secondName != firstName {
-			continue
-		}
-		// If the second statement's RHS reads the first target, the
-		// first write is load-bearing — skip.
-		if assignmentRhsReadsIdent(stmts[i+1], firstName) {
-			continue
-		}
-		ctx.Report(firstAssign, "Assignment to `"+firstName+"` is immediately overwritten without being read.")
-	}
+  block := node.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  stmts := block.Statements.Nodes
+  if len(stmts) < 2 {
+    return
+  }
+  for i := 0; i+1 < len(stmts); i++ {
+    firstName, firstAssign := plainAssignmentTarget(stmts[i])
+    if firstName == "" {
+      continue
+    }
+    secondName, _ := plainAssignmentTarget(stmts[i+1])
+    if secondName != firstName {
+      continue
+    }
+    // If the second statement's RHS reads the first target, the
+    // first write is load-bearing — skip.
+    if assignmentRhsReadsIdent(stmts[i+1], firstName) {
+      continue
+    }
+    ctx.Report(firstAssign, "Assignment to `"+firstName+"` is immediately overwritten without being read.")
+  }
 }
 
 // plainAssignmentTarget returns the identifier name on the left-hand
@@ -54,26 +54,26 @@ func (noUselessAssignment) Check(ctx *Context, node *shimast.Node) {
 // `<ident> = <expr>` assignment. Anything else (compound assignment,
 // destructuring target, property access, non-statement) returns "".
 func plainAssignmentTarget(stmt *shimast.Node) (string, *shimast.Node) {
-	if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
-		return "", nil
-	}
-	expr := stmt.AsExpressionStatement()
-	if expr == nil || expr.Expression == nil {
-		return "", nil
-	}
-	inner := stripParens(expr.Expression)
-	if inner == nil || inner.Kind != shimast.KindBinaryExpression {
-		return "", nil
-	}
-	bin := inner.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil || bin.OperatorToken.Kind != shimast.KindEqualsToken {
-		return "", nil
-	}
-	name := identifierText(stripParens(bin.Left))
-	if name == "" {
-		return "", nil
-	}
-	return name, stmt
+  if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+    return "", nil
+  }
+  expr := stmt.AsExpressionStatement()
+  if expr == nil || expr.Expression == nil {
+    return "", nil
+  }
+  inner := stripParens(expr.Expression)
+  if inner == nil || inner.Kind != shimast.KindBinaryExpression {
+    return "", nil
+  }
+  bin := inner.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.OperatorToken.Kind != shimast.KindEqualsToken {
+    return "", nil
+  }
+  name := identifierText(stripParens(bin.Left))
+  if name == "" {
+    return "", nil
+  }
+  return name, stmt
 }
 
 // assignmentRhsReadsIdent reports whether the second statement's
@@ -81,40 +81,40 @@ func plainAssignmentTarget(stmt *shimast.Node) (string, *shimast.Node) {
 // `x = x + 1` style update reads the previous value, so the prior
 // assignment is not actually dead.
 func assignmentRhsReadsIdent(stmt *shimast.Node, name string) bool {
-	if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
-		return false
-	}
-	expr := stmt.AsExpressionStatement()
-	if expr == nil || expr.Expression == nil {
-		return false
-	}
-	inner := stripParens(expr.Expression)
-	if inner == nil || inner.Kind != shimast.KindBinaryExpression {
-		return false
-	}
-	bin := inner.AsBinaryExpression()
-	if bin == nil || bin.Right == nil {
-		return false
-	}
-	found := false
-	var walk func(n *shimast.Node)
-	walk = func(n *shimast.Node) {
-		if found || n == nil {
-			return
-		}
-		if n.Kind == shimast.KindIdentifier && identifierText(n) == name {
-			found = true
-			return
-		}
-		n.ForEachChild(func(child *shimast.Node) bool {
-			walk(child)
-			return false
-		})
-	}
-	walk(bin.Right)
-	return found
+  if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+    return false
+  }
+  expr := stmt.AsExpressionStatement()
+  if expr == nil || expr.Expression == nil {
+    return false
+  }
+  inner := stripParens(expr.Expression)
+  if inner == nil || inner.Kind != shimast.KindBinaryExpression {
+    return false
+  }
+  bin := inner.AsBinaryExpression()
+  if bin == nil || bin.Right == nil {
+    return false
+  }
+  found := false
+  var walk func(n *shimast.Node)
+  walk = func(n *shimast.Node) {
+    if found || n == nil {
+      return
+    }
+    if n.Kind == shimast.KindIdentifier && identifierText(n) == name {
+      found = true
+      return
+    }
+    n.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(bin.Right)
+  return found
 }
 
 func init() {
-	Register(noUselessAssignment{})
+  Register(noUselessAssignment{})
 }