@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_gap.go

@@ -244,12 +244,27 @@ func (noWrapperObjectTypes) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
-// fileShadowsWrapperName reports whether the source file declares its own
-// `String`/`Number`/`Boolean`/`Symbol`/`BigInt`/`Object` at top level via
-// `type`, `interface`, or `class`. Walks SourceFile.Statements once; no
+// fileShadowsWrapperName reports whether the source file binds its own
+// `String`/`Number`/`Boolean`/`Symbol`/`BigInt`/`Object` at top level, so
+// the referenced name is NOT the global wrapper and a rewrite to the
+// primitive would change the type. Walks SourceFile.Statements once; no
 // memoization because the rule already runs once per TypeReference and
 // the average statement count per file dominates the cost over the inner
 // loop.
+//
+// The guard is intentionally comprehensive: it returns true when the
+// wrapper name is bound by ANY file-scope declaration, because over-bailing
+// (declining to rewrite a real global wrapper because a same-named binding
+// exists) is safe — it only skips a lint fix — whereas under-bailing
+// silently corrupts the type. A binding shadows the global when it comes
+// from:
+//   - a `type` / `interface` / `class` / `enum` declaration,
+//   - a `function` declaration,
+//   - a `namespace` / `module` declaration,
+//   - a top-level `let` / `const` / `var` value declaration,
+//   - an import binding (default, namespace, or named — including an
+//     aliased `{ X as String }`, where the LOCAL name is what binds), or
+//   - an `import X = require(...)` / `import X = A.B` binding.
 func fileShadowsWrapperName(file *shimast.SourceFile, name string) bool {
   if file == nil || file.Statements == nil {
     return false
@@ -258,24 +273,144 @@ func fileShadowsWrapperName(file *shimast.SourceFile, name string) bool {
     if stmt == nil {
       continue
     }
-    var declName *shimast.Node
     switch stmt.Kind {
     case shimast.KindTypeAliasDeclaration:
-      if alias := stmt.AsTypeAliasDeclaration(); alias != nil {
-        declName = alias.Name()
+      if alias := stmt.AsTypeAliasDeclaration(); alias != nil &&
+        identifierText(alias.Name()) == name {
+        return true
       }
     case shimast.KindInterfaceDeclaration:
-      if iface := stmt.AsInterfaceDeclaration(); iface != nil {
-        declName = iface.Name()
+      if iface := stmt.AsInterfaceDeclaration(); iface != nil &&
+        identifierText(iface.Name()) == name {
+        return true
       }
     case shimast.KindClassDeclaration:
-      if cls := stmt.AsClassDeclaration(); cls != nil {
-        declName = cls.Name()
+      if cls := stmt.AsClassDeclaration(); cls != nil &&
+        identifierText(cls.Name()) == name {
+        return true
+      }
+    case shimast.KindEnumDeclaration:
+      if enm := stmt.AsEnumDeclaration(); enm != nil &&
+        identifierText(enm.Name()) == name {
+        return true
+      }
+    case shimast.KindFunctionDeclaration:
+      if fn := stmt.AsFunctionDeclaration(); fn != nil &&
+        identifierText(fn.Name()) == name {
+        return true
+      }
+    case shimast.KindModuleDeclaration:
+      if mod := stmt.AsModuleDeclaration(); mod != nil &&
+        identifierText(mod.Name()) == name {
+        return true
+      }
+    case shimast.KindVariableStatement:
+      if variableStatementBindsName(stmt, name) {
+        return true
+      }
+    case shimast.KindImportDeclaration:
+      if importDeclarationBindsName(stmt, name) {
+        return true
+      }
+    case shimast.KindImportEqualsDeclaration:
+      if imp := stmt.AsImportEqualsDeclaration(); imp != nil &&
+        identifierText(imp.Name()) == name {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+// variableStatementBindsName reports whether a top-level `let`/`const`/`var`
+// statement binds `name` through a (possibly destructured) declaration.
+func variableStatementBindsName(stmt *shimast.Node, name string) bool {
+  vs := stmt.AsVariableStatement()
+  if vs == nil || vs.DeclarationList == nil {
+    return false
+  }
+  list := vs.DeclarationList.AsVariableDeclarationList()
+  if list == nil || list.Declarations == nil {
+    return false
+  }
+  for _, declNode := range list.Declarations.Nodes {
+    if declNode == nil {
+      continue
+    }
+    decl := declNode.AsVariableDeclaration()
+    if decl != nil && bindingNameContains(decl.Name(), name) {
+      return true
+    }
+  }
+  return false
+}
+
+// bindingNameContains reports whether a binding name (a plain identifier or
+// an object/array binding pattern) introduces `name`.
+func bindingNameContains(binding *shimast.Node, name string) bool {
+  if binding == nil {
+    return false
+  }
+  if binding.Kind == shimast.KindIdentifier {
+    return identifierText(binding) == name
+  }
+  found := false
+  binding.ForEachChild(func(child *shimast.Node) bool {
+    if child == nil {
+      return false
+    }
+    if child.Kind == shimast.KindBindingElement {
+      if elem := child.AsBindingElement(); elem != nil &&
+        bindingNameContains(elem.Name(), name) {
+        found = true
+        return true
       }
     }
-    if declName != nil && identifierText(declName) == name {
+    return false
+  })
+  return found
+}
+
+// importDeclarationBindsName reports whether a top-level import statement
+// introduces `name` as a local binding: a default import, a namespace
+// import, or a named import (using the LOCAL name, so `{ X as String }`
+// binds `String`).
+func importDeclarationBindsName(stmt *shimast.Node, name string) bool {
+  decl := stmt.AsImportDeclaration()
+  if decl == nil || decl.ImportClause == nil {
+    return false
+  }
+  clause := decl.ImportClause.AsImportClause()
+  if clause == nil {
+    return false
+  }
+  if identifierText(clause.Name()) == name {
+    return true
+  }
+  bindings := clause.NamedBindings
+  if bindings == nil {
+    return false
+  }
+  switch bindings.Kind {
+  case shimast.KindNamespaceImport:
+    if ns := bindings.AsNamespaceImport(); ns != nil &&
+      identifierText(ns.Name()) == name {
       return true
     }
+  case shimast.KindNamedImports:
+    named := bindings.AsNamedImports()
+    if named == nil || named.Elements == nil {
+      return false
+    }
+    for _, specNode := range named.Elements.Nodes {
+      if specNode == nil {
+        continue
+      }
+      if spec := specNode.AsImportSpecifier(); spec != nil &&
+        identifierText(spec.Name()) == name {
+        return true
+      }
+    }
   }
   return false
 }

package/linthost/rules_grouped_accessor_pairs.go

@@ -19,69 +19,69 @@ type groupedAccessorPairs struct{}
 
 func (groupedAccessorPairs) Name() string { return "grouped-accessor-pairs" }
 func (groupedAccessorPairs) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
+  return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
 }
 func (groupedAccessorPairs) Check(ctx *Context, node *shimast.Node) {
-	members := classMembers(node)
-	if len(members) < 2 {
-		return
-	}
-	type slot struct {
-		name   string
-		static bool
-	}
-	type entry struct {
-		index int
-		kind  shimast.Kind
-		node  *shimast.Node
-	}
-	groups := map[slot][]entry{}
-	for i, member := range members {
-		if member == nil {
-			continue
-		}
-		if member.Kind != shimast.KindGetAccessor && member.Kind != shimast.KindSetAccessor {
-			continue
-		}
-		name := classMemberName(member)
-		if name == "" {
-			continue
-		}
-		key := slot{name: name, static: hasModifier(member, shimast.KindStaticKeyword)}
-		groups[key] = append(groups[key], entry{index: i, kind: member.Kind, node: member})
-	}
-	for _, entries := range groups {
-		if len(entries) < 2 {
-			continue
-		}
-		// Find a getter/setter pair within the group.
-		var get, set *entry
-		for i := range entries {
-			e := &entries[i]
-			if e.kind == shimast.KindGetAccessor && get == nil {
-				get = e
-			} else if e.kind == shimast.KindSetAccessor && set == nil {
-				set = e
-			}
-		}
-		if get == nil || set == nil {
-			continue
-		}
-		// Adjacent indices in the members list satisfy the rule.
-		diff := get.index - set.index
-		if diff == 1 || diff == -1 {
-			continue
-		}
-		// Report on whichever half appears later — the earlier one
-		// reads fine in isolation; the later one is the surprise.
-		later := get
-		if set.index > get.index {
-			later = set
-		}
-		ctx.Report(later.node, "Accessor pair should be grouped.")
-	}
+  members := classMembers(node)
+  if len(members) < 2 {
+    return
+  }
+  type slot struct {
+    name   string
+    static bool
+  }
+  type entry struct {
+    index int
+    kind  shimast.Kind
+    node  *shimast.Node
+  }
+  groups := map[slot][]entry{}
+  for i, member := range members {
+    if member == nil {
+      continue
+    }
+    if member.Kind != shimast.KindGetAccessor && member.Kind != shimast.KindSetAccessor {
+      continue
+    }
+    name := classMemberName(member)
+    if name == "" {
+      continue
+    }
+    key := slot{name: name, static: hasModifier(member, shimast.KindStaticKeyword)}
+    groups[key] = append(groups[key], entry{index: i, kind: member.Kind, node: member})
+  }
+  for _, entries := range groups {
+    if len(entries) < 2 {
+      continue
+    }
+    // Find a getter/setter pair within the group.
+    var get, set *entry
+    for i := range entries {
+      e := &entries[i]
+      if e.kind == shimast.KindGetAccessor && get == nil {
+        get = e
+      } else if e.kind == shimast.KindSetAccessor && set == nil {
+        set = e
+      }
+    }
+    if get == nil || set == nil {
+      continue
+    }
+    // Adjacent indices in the members list satisfy the rule.
+    diff := get.index - set.index
+    if diff == 1 || diff == -1 {
+      continue
+    }
+    // Report on whichever half appears later — the earlier one
+    // reads fine in isolation; the later one is the surprise.
+    later := get
+    if set.index > get.index {
+      later = set
+    }
+    ctx.Report(later.node, "Accessor pair should be grouped.")
+  }
 }
 
 func init() {
-	Register(groupedAccessorPairs{})
+  Register(groupedAccessorPairs{})
 }

package/linthost/rules_guard_for_in.go

@@ -17,7 +17,7 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type guardForIn struct{}
@@ -25,19 +25,19 @@ type guardForIn struct{}
 func (guardForIn) Name() string           { return "guard-for-in" }
 func (guardForIn) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindForInStatement} }
 func (guardForIn) Check(ctx *Context, node *shimast.Node) {
-	stmt := node.AsForInOrOfStatement()
-	if stmt == nil || stmt.Statement == nil {
-		return
-	}
-	first := firstBodyStatement(stmt.Statement)
-	if first == nil {
-		return
-	}
-	key := forInKeyName(stmt.Initializer)
-	if isHasOwnGuard(first, key) {
-		return
-	}
-	ctx.Report(node, "The body of a `for...in` should be wrapped in an `if (Object.hasOwn(...))` statement to filter unwanted properties from the prototype.")
+  stmt := node.AsForInOrOfStatement()
+  if stmt == nil || stmt.Statement == nil {
+    return
+  }
+  first := firstBodyStatement(stmt.Statement)
+  if first == nil {
+    return
+  }
+  key := forInKeyName(stmt.Initializer)
+  if isHasOwnGuard(first, key) {
+    return
+  }
+  ctx.Report(node, "The body of a `for...in` should be wrapped in an `if (Object.hasOwn(...))` statement to filter unwanted properties from the prototype.")
 }
 
 // firstBodyStatement returns the first executable statement inside a
@@ -45,22 +45,22 @@ func (guardForIn) Check(ctx *Context, node *shimast.Node) {
 // non-block body is itself the only statement. Returns nil for an
 // empty block — an empty body cannot leak inherited keys.
 func firstBodyStatement(body *shimast.Node) *shimast.Node {
-	if body == nil {
-		return nil
-	}
-	if body.Kind != shimast.KindBlock {
-		return body
-	}
-	block := body.AsBlock()
-	if block == nil || block.Statements == nil {
-		return nil
-	}
-	for _, s := range block.Statements.Nodes {
-		if s != nil {
-			return s
-		}
-	}
-	return nil
+  if body == nil {
+    return nil
+  }
+  if body.Kind != shimast.KindBlock {
+    return body
+  }
+  block := body.AsBlock()
+  if block == nil || block.Statements == nil {
+    return nil
+  }
+  for _, s := range block.Statements.Nodes {
+    if s != nil {
+      return s
+    }
+  }
+  return nil
 }
 
 // forInKeyName extracts the identifier text of the loop key from a
@@ -69,28 +69,28 @@ func firstBodyStatement(body *shimast.Node) *shimast.Node {
 // or a bare Identifier (`for (key in …)`). Destructuring patterns and
 // other shapes return "" so the rule skips its key-identity check.
 func forInKeyName(init *shimast.Node) string {
-	if init == nil {
-		return ""
-	}
-	if name := identifierText(init); name != "" {
-		return name
-	}
-	if init.Kind != shimast.KindVariableDeclarationList {
-		return ""
-	}
-	list := init.AsVariableDeclarationList()
-	if list == nil || list.Declarations == nil || len(list.Declarations.Nodes) != 1 {
-		return ""
-	}
-	decl := list.Declarations.Nodes[0]
-	if decl == nil {
-		return ""
-	}
-	v := decl.AsVariableDeclaration()
-	if v == nil {
-		return ""
-	}
-	return identifierText(v.Name())
+  if init == nil {
+    return ""
+  }
+  if name := identifierText(init); name != "" {
+    return name
+  }
+  if init.Kind != shimast.KindVariableDeclarationList {
+    return ""
+  }
+  list := init.AsVariableDeclarationList()
+  if list == nil || list.Declarations == nil || len(list.Declarations.Nodes) != 1 {
+    return ""
+  }
+  decl := list.Declarations.Nodes[0]
+  if decl == nil {
+    return ""
+  }
+  v := decl.AsVariableDeclaration()
+  if v == nil {
+    return ""
+  }
+  return identifierText(v.Name())
 }
 
 // isHasOwnGuard reports whether `stmt` is the canonical own-key guard
@@ -110,89 +110,89 @@ func forInKeyName(init *shimast.Node) string {
 // initializer; otherwise any second argument is accepted (the rule
 // has no reliable handle on the key name).
 func isHasOwnGuard(stmt *shimast.Node, key string) bool {
-	if stmt == nil || stmt.Kind != shimast.KindIfStatement {
-		return false
-	}
-	ifStmt := stmt.AsIfStatement()
-	if ifStmt == nil || ifStmt.Expression == nil {
-		return false
-	}
-	cond := stripParens(ifStmt.Expression)
-	if cond == nil {
-		return false
-	}
-	if isHasOwnCall(cond, key) {
-		return true
-	}
-	if cond.Kind != shimast.KindPrefixUnaryExpression {
-		return false
-	}
-	pre := cond.AsPrefixUnaryExpression()
-	if pre == nil || pre.Operator != shimast.KindExclamationToken {
-		return false
-	}
-	if !isHasOwnCall(stripParens(pre.Operand), key) {
-		return false
-	}
-	// Negated guard: require the then branch to be a single `continue`
-	// so the rest of the loop runs only for own keys.
-	return isLoneContinue(ifStmt.ThenStatement)
+  if stmt == nil || stmt.Kind != shimast.KindIfStatement {
+    return false
+  }
+  ifStmt := stmt.AsIfStatement()
+  if ifStmt == nil || ifStmt.Expression == nil {
+    return false
+  }
+  cond := stripParens(ifStmt.Expression)
+  if cond == nil {
+    return false
+  }
+  if isHasOwnCall(cond, key) {
+    return true
+  }
+  if cond.Kind != shimast.KindPrefixUnaryExpression {
+    return false
+  }
+  pre := cond.AsPrefixUnaryExpression()
+  if pre == nil || pre.Operator != shimast.KindExclamationToken {
+    return false
+  }
+  if !isHasOwnCall(stripParens(pre.Operand), key) {
+    return false
+  }
+  // Negated guard: require the then branch to be a single `continue`
+  // so the rest of the loop runs only for own keys.
+  return isLoneContinue(ifStmt.ThenStatement)
 }
 
 // isHasOwnCall reports whether `node` is `Object.hasOwn(obj, key)` or
 // `Object.prototype.hasOwnProperty.call(obj, key)`. The second
 // argument must match `key` when one is supplied.
 func isHasOwnCall(node *shimast.Node, key string) bool {
-	if node == nil || node.Kind != shimast.KindCallExpression {
-		return false
-	}
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Arguments == nil {
-		return false
-	}
-	args := call.Arguments.Nodes
-	if len(args) < 2 {
-		return false
-	}
-	callee := stripParens(call.Expression)
-	switch {
-	case isMatchingPropertyAccess(callee, "Object", "hasOwn"):
-		// `Object.hasOwn(obj, key)` — both arguments belong to the
-		// caller; the key check is the second argument.
-	case isMatchingPropertyAccess(callee, "Object", "prototype", "hasOwnProperty", "call"):
-		// `Object.prototype.hasOwnProperty.call(obj, key)` — same
-		// argument layout because `.call(obj, key)` passes the
-		// receiver explicitly.
-	default:
-		return false
-	}
-	if key == "" {
-		return true
-	}
-	return identifierText(stripParens(args[1])) == key
+  if node == nil || node.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Arguments == nil {
+    return false
+  }
+  args := call.Arguments.Nodes
+  if len(args) < 2 {
+    return false
+  }
+  callee := stripParens(call.Expression)
+  switch {
+  case isMatchingPropertyAccess(callee, "Object", "hasOwn"):
+    // `Object.hasOwn(obj, key)` — both arguments belong to the
+    // caller; the key check is the second argument.
+  case isMatchingPropertyAccess(callee, "Object", "prototype", "hasOwnProperty", "call"):
+    // `Object.prototype.hasOwnProperty.call(obj, key)` — same
+    // argument layout because `.call(obj, key)` passes the
+    // receiver explicitly.
+  default:
+    return false
+  }
+  if key == "" {
+    return true
+  }
+  return identifierText(stripParens(args[1])) == key
 }
 
 // isLoneContinue reports whether `stmt` is a bare `continue;` (or a
 // block containing exactly one `continue;`). Used to validate the
 // then-branch of the negated-guard shape.
 func isLoneContinue(stmt *shimast.Node) bool {
-	if stmt == nil {
-		return false
-	}
-	if stmt.Kind == shimast.KindContinueStatement {
-		return true
-	}
-	if stmt.Kind != shimast.KindBlock {
-		return false
-	}
-	block := stmt.AsBlock()
-	if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
-		return false
-	}
-	return block.Statements.Nodes[0] != nil &&
-		block.Statements.Nodes[0].Kind == shimast.KindContinueStatement
+  if stmt == nil {
+    return false
+  }
+  if stmt.Kind == shimast.KindContinueStatement {
+    return true
+  }
+  if stmt.Kind != shimast.KindBlock {
+    return false
+  }
+  block := stmt.AsBlock()
+  if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+    return false
+  }
+  return block.Statements.Nodes[0] != nil &&
+    block.Statements.Nodes[0].Kind == shimast.KindContinueStatement
 }
 
 func init() {
-	Register(guardForIn{})
+  Register(guardForIn{})
 }