@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_no_else_return.go

@@ -20,56 +20,56 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noElseReturn struct{}
 
 func (noElseReturn) Name() string { return "no-else-return" }
 func (noElseReturn) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIfStatement}
+  return []shimast.Kind{shimast.KindIfStatement}
 }
 func (noElseReturn) Check(ctx *Context, node *shimast.Node) {
-	ifStmt := node.AsIfStatement()
-	if ifStmt == nil || ifStmt.ElseStatement == nil {
-		return
-	}
-	if !noElseReturnTerminates(ifStmt.ThenStatement) {
-		return
-	}
-	ctx.Report(ifStmt.ElseStatement, "Remove the `else` — the preceding branch already terminates.")
+  ifStmt := node.AsIfStatement()
+  if ifStmt == nil || ifStmt.ElseStatement == nil {
+    return
+  }
+  if !noElseReturnTerminates(ifStmt.ThenStatement) {
+    return
+  }
+  ctx.Report(ifStmt.ElseStatement, "Remove the `else` — the preceding branch already terminates.")
 }
 
 func noElseReturnTerminates(stmt *shimast.Node) bool {
-	if stmt == nil {
-		return false
-	}
-	switch stmt.Kind {
-	case shimast.KindReturnStatement,
-		shimast.KindThrowStatement,
-		shimast.KindBreakStatement,
-		shimast.KindContinueStatement:
-		return true
-	case shimast.KindBlock:
-		block := stmt.AsBlock()
-		if block == nil || block.Statements == nil {
-			return false
-		}
-		stmts := block.Statements.Nodes
-		if len(stmts) == 0 {
-			return false
-		}
-		return noElseReturnTerminates(stmts[len(stmts)-1])
-	case shimast.KindIfStatement:
-		inner := stmt.AsIfStatement()
-		if inner == nil || inner.ElseStatement == nil {
-			return false
-		}
-		return noElseReturnTerminates(inner.ThenStatement) && noElseReturnTerminates(inner.ElseStatement)
-	}
-	return false
+  if stmt == nil {
+    return false
+  }
+  switch stmt.Kind {
+  case shimast.KindReturnStatement,
+    shimast.KindThrowStatement,
+    shimast.KindBreakStatement,
+    shimast.KindContinueStatement:
+    return true
+  case shimast.KindBlock:
+    block := stmt.AsBlock()
+    if block == nil || block.Statements == nil {
+      return false
+    }
+    stmts := block.Statements.Nodes
+    if len(stmts) == 0 {
+      return false
+    }
+    return noElseReturnTerminates(stmts[len(stmts)-1])
+  case shimast.KindIfStatement:
+    inner := stmt.AsIfStatement()
+    if inner == nil || inner.ElseStatement == nil {
+      return false
+    }
+    return noElseReturnTerminates(inner.ThenStatement) && noElseReturnTerminates(inner.ElseStatement)
+  }
+  return false
 }
 
 func init() {
-	Register(noElseReturn{})
+  Register(noElseReturn{})
 }

package/linthost/rules_no_empty_named_blocks.go

@@ -23,15 +23,15 @@ type noEmptyNamedBlocks struct{}
 
 func (noEmptyNamedBlocks) Name() string { return "no-empty-named-blocks" }
 func (noEmptyNamedBlocks) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
+  return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
 }
 func (noEmptyNamedBlocks) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindImportDeclaration:
-		noEmptyNamedBlocksCheckImport(ctx, node)
-	case shimast.KindExportDeclaration:
-		noEmptyNamedBlocksCheckExport(ctx, node)
-	}
+  switch node.Kind {
+  case shimast.KindImportDeclaration:
+    noEmptyNamedBlocksCheckImport(ctx, node)
+  case shimast.KindExportDeclaration:
+    noEmptyNamedBlocksCheckExport(ctx, node)
+  }
 }
 
 // noEmptyNamedBlocksCheckImport flags `import {} from "x"` and
@@ -39,31 +39,31 @@ func (noEmptyNamedBlocks) Check(ctx *Context, node *shimast.Node) {
 // a bare `import "x"`; the default-plus-empty form should drop the
 // empty clause and keep the default binding.
 func noEmptyNamedBlocksCheckImport(ctx *Context, node *shimast.Node) {
-	decl := node.AsImportDeclaration()
-	if decl == nil || decl.ImportClause == nil {
-		return
-	}
-	clause := decl.ImportClause.AsImportClause()
-	if clause == nil {
-		return
-	}
-	if clause.NamedBindings == nil {
-		return
-	}
-	if clause.NamedBindings.Kind != shimast.KindNamedImports {
-		return
-	}
-	named := clause.NamedBindings.AsNamedImports()
-	if named == nil || named.Elements == nil || len(named.Elements.Nodes) > 0 {
-		return
-	}
-	// Two shapes both reach here:
-	//   `import {} from "x"`           — clause.Name() == nil
-	//   `import name, {} from "x"`     — clause.Name() != nil
-	// Either way the empty `{}` is what the rule blames; the report
-	// target is the empty named-imports node so the highlight points at
-	// the `{}` token, not the whole declaration.
-	ctx.Report(clause.NamedBindings, "Unexpected empty named import block.")
+  decl := node.AsImportDeclaration()
+  if decl == nil || decl.ImportClause == nil {
+    return
+  }
+  clause := decl.ImportClause.AsImportClause()
+  if clause == nil {
+    return
+  }
+  if clause.NamedBindings == nil {
+    return
+  }
+  if clause.NamedBindings.Kind != shimast.KindNamedImports {
+    return
+  }
+  named := clause.NamedBindings.AsNamedImports()
+  if named == nil || named.Elements == nil || len(named.Elements.Nodes) > 0 {
+    return
+  }
+  // Two shapes both reach here:
+  //   `import {} from "x"`           — clause.Name() == nil
+  //   `import name, {} from "x"`     — clause.Name() != nil
+  // Either way the empty `{}` is what the rule blames; the report
+  // target is the empty named-imports node so the highlight points at
+  // the `{}` token, not the whole declaration.
+  ctx.Report(clause.NamedBindings, "Unexpected empty named import block.")
 }
 
 // noEmptyNamedBlocksCheckExport flags `export {}` (with or without a
@@ -72,20 +72,20 @@ func noEmptyNamedBlocksCheckImport(ctx *Context, node *shimast.Node) {
 // uniformly across both module and non-module sources, leaving
 // `no-useless-empty-export` to gate the narrower redundant-marker case.
 func noEmptyNamedBlocksCheckExport(ctx *Context, node *shimast.Node) {
-	decl := node.AsExportDeclaration()
-	if decl == nil || decl.ExportClause == nil {
-		return
-	}
-	if decl.ExportClause.Kind != shimast.KindNamedExports {
-		return
-	}
-	named := decl.ExportClause.AsNamedExports()
-	if named == nil || named.Elements == nil || len(named.Elements.Nodes) > 0 {
-		return
-	}
-	ctx.Report(node, "Unexpected empty named export block.")
+  decl := node.AsExportDeclaration()
+  if decl == nil || decl.ExportClause == nil {
+    return
+  }
+  if decl.ExportClause.Kind != shimast.KindNamedExports {
+    return
+  }
+  named := decl.ExportClause.AsNamedExports()
+  if named == nil || named.Elements == nil || len(named.Elements.Nodes) > 0 {
+    return
+  }
+  ctx.Report(node, "Unexpected empty named export block.")
 }
 
 func init() {
-	Register(noEmptyNamedBlocks{})
+  Register(noEmptyNamedBlocks{})
 }

package/linthost/rules_no_import_assign.go

@@ -25,37 +25,37 @@ type noImportAssign struct{}
 func (noImportAssign) Name() string           { return "no-import-assign" }
 func (noImportAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (noImportAssign) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	imported := map[string]bool{}
-	namespaces := map[string]bool{}
-	collectImportedBindings(node, imported, namespaces)
-	if len(imported) == 0 {
-		return
-	}
-	walkDescendants(node, func(n *shimast.Node) {
-		switch n.Kind {
-		case shimast.KindBinaryExpression:
-			expr := n.AsBinaryExpression()
-			if expr == nil || expr.OperatorToken == nil || !isAssignmentOperator(expr.OperatorToken.Kind) {
-				return
-			}
-			reportImportTarget(ctx, expr.Left, imported, namespaces)
-		case shimast.KindPrefixUnaryExpression:
-			pre := n.AsPrefixUnaryExpression()
-			if pre == nil || (pre.Operator != shimast.KindPlusPlusToken && pre.Operator != shimast.KindMinusMinusToken) {
-				return
-			}
-			reportImportTarget(ctx, pre.Operand, imported, namespaces)
-		case shimast.KindPostfixUnaryExpression:
-			post := n.AsPostfixUnaryExpression()
-			if post == nil || (post.Operator != shimast.KindPlusPlusToken && post.Operator != shimast.KindMinusMinusToken) {
-				return
-			}
-			reportImportTarget(ctx, post.Operand, imported, namespaces)
-		}
-	})
+  if node == nil {
+    return
+  }
+  imported := map[string]bool{}
+  namespaces := map[string]bool{}
+  collectImportedBindings(node, imported, namespaces)
+  if len(imported) == 0 {
+    return
+  }
+  walkDescendants(node, func(n *shimast.Node) {
+    switch n.Kind {
+    case shimast.KindBinaryExpression:
+      expr := n.AsBinaryExpression()
+      if expr == nil || expr.OperatorToken == nil || !isAssignmentOperator(expr.OperatorToken.Kind) {
+        return
+      }
+      reportImportTarget(ctx, expr.Left, imported, namespaces)
+    case shimast.KindPrefixUnaryExpression:
+      pre := n.AsPrefixUnaryExpression()
+      if pre == nil || (pre.Operator != shimast.KindPlusPlusToken && pre.Operator != shimast.KindMinusMinusToken) {
+        return
+      }
+      reportImportTarget(ctx, pre.Operand, imported, namespaces)
+    case shimast.KindPostfixUnaryExpression:
+      post := n.AsPostfixUnaryExpression()
+      if post == nil || (post.Operator != shimast.KindPlusPlusToken && post.Operator != shimast.KindMinusMinusToken) {
+        return
+      }
+      reportImportTarget(ctx, post.Operand, imported, namespaces)
+    }
+  })
 }
 
 // collectImportedBindings walks every `import` declaration in `file` and
@@ -63,78 +63,78 @@ func (noImportAssign) Check(ctx *Context, node *shimast.Node) {
 // additionally remembered so callers can flag property mutations like
 // `ns.foo = …`.
 func collectImportedBindings(file *shimast.Node, imported, namespaces map[string]bool) {
-	walkDescendants(file, func(n *shimast.Node) {
-		if n == nil || n.Kind != shimast.KindImportDeclaration {
-			return
-		}
-		decl := n.AsImportDeclaration()
-		if decl == nil || decl.ImportClause == nil {
-			return
-		}
-		clause := decl.ImportClause.AsImportClause()
-		if clause == nil {
-			return
-		}
-		// `import Default from "x"` — default specifier.
-		if name := identifierText(clause.Name()); name != "" {
-			imported[name] = true
-		}
-		if clause.NamedBindings == nil {
-			return
-		}
-		switch clause.NamedBindings.Kind {
-		case shimast.KindNamedImports:
-			named := clause.NamedBindings.AsNamedImports()
-			if named == nil || named.Elements == nil {
-				return
-			}
-			for _, specNode := range named.Elements.Nodes {
-				spec := specNode.AsImportSpecifier()
-				if spec == nil {
-					continue
-				}
-				if name := identifierText(spec.Name()); name != "" {
-					imported[name] = true
-				}
-			}
-		case shimast.KindNamespaceImport:
-			ns := clause.NamedBindings.AsNamespaceImport()
-			if ns == nil {
-				return
-			}
-			if name := identifierText(ns.Name()); name != "" {
-				imported[name] = true
-				namespaces[name] = true
-			}
-		}
-	})
+  walkDescendants(file, func(n *shimast.Node) {
+    if n == nil || n.Kind != shimast.KindImportDeclaration {
+      return
+    }
+    decl := n.AsImportDeclaration()
+    if decl == nil || decl.ImportClause == nil {
+      return
+    }
+    clause := decl.ImportClause.AsImportClause()
+    if clause == nil {
+      return
+    }
+    // `import Default from "x"` — default specifier.
+    if name := identifierText(clause.Name()); name != "" {
+      imported[name] = true
+    }
+    if clause.NamedBindings == nil {
+      return
+    }
+    switch clause.NamedBindings.Kind {
+    case shimast.KindNamedImports:
+      named := clause.NamedBindings.AsNamedImports()
+      if named == nil || named.Elements == nil {
+        return
+      }
+      for _, specNode := range named.Elements.Nodes {
+        spec := specNode.AsImportSpecifier()
+        if spec == nil {
+          continue
+        }
+        if name := identifierText(spec.Name()); name != "" {
+          imported[name] = true
+        }
+      }
+    case shimast.KindNamespaceImport:
+      ns := clause.NamedBindings.AsNamespaceImport()
+      if ns == nil {
+        return
+      }
+      if name := identifierText(ns.Name()); name != "" {
+        imported[name] = true
+        namespaces[name] = true
+      }
+    }
+  })
 }
 
 // reportImportTarget flags `target` when it writes to an imported name.
 // A bare identifier matching an imported binding is always flagged; a
 // `ns.<key>` property access is flagged when `ns` is a namespace import.
 func reportImportTarget(ctx *Context, target *shimast.Node, imported, namespaces map[string]bool) {
-	stripped := stripParens(target)
-	if stripped == nil {
-		return
-	}
-	if name := identifierText(stripped); name != "" {
-		if imported[name] {
-			ctx.Report(target, "'"+name+"' is read-only.")
-		}
-		return
-	}
-	if stripped.Kind == shimast.KindPropertyAccessExpression {
-		access := stripped.AsPropertyAccessExpression()
-		if access == nil || access.Expression == nil {
-			return
-		}
-		if ns := identifierText(stripParens(access.Expression)); ns != "" && namespaces[ns] {
-			ctx.Report(target, "The members of '"+ns+"' are read-only.")
-		}
-	}
+  stripped := stripParens(target)
+  if stripped == nil {
+    return
+  }
+  if name := identifierText(stripped); name != "" {
+    if imported[name] {
+      ctx.Report(target, "'"+name+"' is read-only.")
+    }
+    return
+  }
+  if stripped.Kind == shimast.KindPropertyAccessExpression {
+    access := stripped.AsPropertyAccessExpression()
+    if access == nil || access.Expression == nil {
+      return
+    }
+    if ns := identifierText(stripParens(access.Expression)); ns != "" && namespaces[ns] {
+      ctx.Report(target, "The members of '"+ns+"' are read-only.")
+    }
+  }
 }
 
 func init() {
-	Register(noImportAssign{})
+  Register(noImportAssign{})
 }

package/linthost/rules_no_invalid_this.go

@@ -13,7 +13,7 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noInvalidThis struct{}
@@ -21,10 +21,10 @@ type noInvalidThis struct{}
 func (noInvalidThis) Name() string           { return "no-invalid-this" }
 func (noInvalidThis) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindThisKeyword} }
 func (noInvalidThis) Check(ctx *Context, node *shimast.Node) {
-	if hasThisBindingAncestor(node) {
-		return
-	}
-	ctx.Report(node, "Unexpected 'this'.")
+  if hasThisBindingAncestor(node) {
+    return
+  }
+  ctx.Report(node, "Unexpected 'this'.")
 }
 
 // hasThisBindingAncestor reports whether `node` is lexically enclosed by
@@ -32,21 +32,21 @@ func (noInvalidThis) Check(ctx *Context, node *shimast.Node) {
 // because they capture `this` from the surrounding scope; the walk only
 // stops on a real binding site or at the SourceFile root.
 func hasThisBindingAncestor(node *shimast.Node) bool {
-	for cur := node.Parent; cur != nil; cur = cur.Parent {
-		switch cur.Kind {
-		case shimast.KindFunctionDeclaration,
-			shimast.KindFunctionExpression,
-			shimast.KindMethodDeclaration,
-			shimast.KindGetAccessor,
-			shimast.KindSetAccessor,
-			shimast.KindConstructor,
-			shimast.KindClassStaticBlockDeclaration:
-			return true
-		}
-	}
-	return false
+  for cur := node.Parent; cur != nil; cur = cur.Parent {
+    switch cur.Kind {
+    case shimast.KindFunctionDeclaration,
+      shimast.KindFunctionExpression,
+      shimast.KindMethodDeclaration,
+      shimast.KindGetAccessor,
+      shimast.KindSetAccessor,
+      shimast.KindConstructor,
+      shimast.KindClassStaticBlockDeclaration:
+      return true
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(noInvalidThis{})
+  Register(noInvalidThis{})
 }

package/linthost/rules_no_loop_func.go

@@ -22,64 +22,64 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noLoopFunc struct{}
 
 func (noLoopFunc) Name() string { return "no-loop-func" }
 func (noLoopFunc) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindForStatement,
-		shimast.KindForInStatement,
-		shimast.KindForOfStatement,
-		shimast.KindWhileStatement,
-		shimast.KindDoStatement,
-	}
+  return []shimast.Kind{
+    shimast.KindForStatement,
+    shimast.KindForInStatement,
+    shimast.KindForOfStatement,
+    shimast.KindWhileStatement,
+    shimast.KindDoStatement,
+  }
 }
 func (noLoopFunc) Check(ctx *Context, node *shimast.Node) {
-	var walk func(n *shimast.Node)
-	walk = func(n *shimast.Node) {
-		if n == nil {
-			return
-		}
-		if isFunctionLikeKind(n) {
-			ctx.Report(n, "Function declared in a loop closes over the loop's bindings — hoist it out.")
-			return
-		}
-		if n != node && isLoopKind(n) {
-			// Nested loops report their own contents when visited.
-			return
-		}
-		n.ForEachChild(func(child *shimast.Node) bool {
-			walk(child)
-			return false
-		})
-	}
-	node.ForEachChild(func(child *shimast.Node) bool {
-		walk(child)
-		return false
-	})
+  var walk func(n *shimast.Node)
+  walk = func(n *shimast.Node) {
+    if n == nil {
+      return
+    }
+    if isFunctionLikeKind(n) {
+      ctx.Report(n, "Function declared in a loop closes over the loop's bindings — hoist it out.")
+      return
+    }
+    if n != node && isLoopKind(n) {
+      // Nested loops report their own contents when visited.
+      return
+    }
+    n.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  node.ForEachChild(func(child *shimast.Node) bool {
+    walk(child)
+    return false
+  })
 }
 
 // isLoopKind reports whether n is one of the loop statement kinds this
 // rule visits. Used to stop the walk at a nested loop boundary so each
 // loop reports only the function-likes directly inside its own body.
 func isLoopKind(n *shimast.Node) bool {
-	if n == nil {
-		return false
-	}
-	switch n.Kind {
-	case shimast.KindForStatement,
-		shimast.KindForInStatement,
-		shimast.KindForOfStatement,
-		shimast.KindWhileStatement,
-		shimast.KindDoStatement:
-		return true
-	}
-	return false
+  if n == nil {
+    return false
+  }
+  switch n.Kind {
+  case shimast.KindForStatement,
+    shimast.KindForInStatement,
+    shimast.KindForOfStatement,
+    shimast.KindWhileStatement,
+    shimast.KindDoStatement:
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(noLoopFunc{})
+  Register(noLoopFunc{})
 }