@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_no_magic_numbers.go

@@ -26,52 +26,52 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noMagicNumbers struct{}
 
 func (noMagicNumbers) Name() string { return "no-magic-numbers" }
 func (noMagicNumbers) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNumericLiteral}
+  return []shimast.Kind{shimast.KindNumericLiteral}
 }
 func (noMagicNumbers) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	text := numericLiteralText(node)
-	if isIgnoredMagicLiteralText(text) {
-		return
-	}
-	parent := node.Parent
-	if parent == nil {
-		return
-	}
-	// `-N` is a PrefixUnaryExpression whose Operand is the literal. The
-	// `-1` ignore list lives on the unary expression's combined text;
-	// recognize the negated form here so the rule does not flag the `1`
-	// inside `-1`.
-	if parent.Kind == shimast.KindPrefixUnaryExpression {
-		pre := parent.AsPrefixUnaryExpression()
-		if pre != nil && pre.Operator == shimast.KindMinusToken && text == "1" {
-			return
-		}
-	}
-	// Initializer of a `const x = N` declaration: the named binding the
-	// rule wants users to introduce.
-	if isConstVariableInitializer(parent, node) {
-		return
-	}
-	// Enum member value: `enum E { A = 0, B = 1 }` — the literal is
-	// the binding's value position, so leave it alone.
-	if parent.Kind == shimast.KindEnumMember {
-		return
-	}
-	// `arr[0]` / `tuple[3]`: numeric index position of an element access.
-	if isArrayIndexArgument(parent, node) {
-		return
-	}
-	ctx.Report(node, "No magic number: "+text+".")
+  if node == nil {
+    return
+  }
+  text := numericLiteralText(node)
+  if isIgnoredMagicLiteralText(text) {
+    return
+  }
+  parent := node.Parent
+  if parent == nil {
+    return
+  }
+  // `-N` is a PrefixUnaryExpression whose Operand is the literal. The
+  // `-1` ignore list lives on the unary expression's combined text;
+  // recognize the negated form here so the rule does not flag the `1`
+  // inside `-1`.
+  if parent.Kind == shimast.KindPrefixUnaryExpression {
+    pre := parent.AsPrefixUnaryExpression()
+    if pre != nil && pre.Operator == shimast.KindMinusToken && text == "1" {
+      return
+    }
+  }
+  // Initializer of a `const x = N` declaration: the named binding the
+  // rule wants users to introduce.
+  if isConstVariableInitializer(parent, node) {
+    return
+  }
+  // Enum member value: `enum E { A = 0, B = 1 }` — the literal is
+  // the binding's value position, so leave it alone.
+  if parent.Kind == shimast.KindEnumMember {
+    return
+  }
+  // `arr[0]` / `tuple[3]`: numeric index position of an element access.
+  if isArrayIndexArgument(parent, node) {
+    return
+  }
+  ctx.Report(node, "No magic number: "+text+".")
 }
 
 // isIgnoredMagicLiteralText reports whether the literal text falls into
@@ -79,11 +79,11 @@ func (noMagicNumbers) Check(ctx *Context, node *shimast.Node) {
 // minus lives on a PrefixUnaryExpression parent), so the table here only
 // needs the two zero / one shapes.
 func isIgnoredMagicLiteralText(text string) bool {
-	switch text {
-	case "0", "1":
-		return true
-	}
-	return false
+  switch text {
+  case "0", "1":
+    return true
+  }
+  return false
 }
 
 // isConstVariableInitializer reports whether `literal` sits in the
@@ -92,14 +92,14 @@ func isIgnoredMagicLiteralText(text string) bool {
 // reassigned, so the number is still magic in the position it was
 // written.
 func isConstVariableInitializer(parent, literal *shimast.Node) bool {
-	if parent == nil || parent.Kind != shimast.KindVariableDeclaration {
-		return false
-	}
-	decl := parent.AsVariableDeclaration()
-	if decl == nil || decl.Initializer != literal {
-		return false
-	}
-	return shimast.IsConst(parent)
+  if parent == nil || parent.Kind != shimast.KindVariableDeclaration {
+    return false
+  }
+  decl := parent.AsVariableDeclaration()
+  if decl == nil || decl.Initializer != literal {
+    return false
+  }
+  return shimast.IsConst(parent)
 }
 
 // isArrayIndexArgument reports whether `literal` sits in the
@@ -108,16 +108,16 @@ func isConstVariableInitializer(parent, literal *shimast.Node) bool {
 // baseline enables it because mixing numeric subscripts with renamed
 // constants reads worse than the literal.
 func isArrayIndexArgument(parent, literal *shimast.Node) bool {
-	if parent == nil || parent.Kind != shimast.KindElementAccessExpression {
-		return false
-	}
-	access := parent.AsElementAccessExpression()
-	if access == nil {
-		return false
-	}
-	return access.ArgumentExpression == literal
+  if parent == nil || parent.Kind != shimast.KindElementAccessExpression {
+    return false
+  }
+  access := parent.AsElementAccessExpression()
+  if access == nil {
+    return false
+  }
+  return access.ArgumentExpression == literal
 }
 
 func init() {
-	Register(noMagicNumbers{})
+  Register(noMagicNumbers{})
 }

package/linthost/rules_no_mixed_operators.go

@@ -18,63 +18,63 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type noMixedOperators struct{}
 
 const (
-	mixedGroupLogical    = 1
-	mixedGroupBitwise    = 2
-	mixedGroupComparison = 3
+  mixedGroupLogical    = 1
+  mixedGroupBitwise    = 2
+  mixedGroupComparison = 3
 )
 
-func (noMixedOperators) Name() string         { return "no-mixed-operators" }
+func (noMixedOperators) Name() string           { return "no-mixed-operators" }
 func (noMixedOperators) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noMixedOperators) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	parent := noMixedOperatorsGroup(expr.OperatorToken.Kind)
-	if parent == 0 {
-		return
-	}
-	op := expr.OperatorToken.Kind
-	if noMixedOperatorsConflicts(parent, op, expr.Left) ||
-		noMixedOperatorsConflicts(parent, op, expr.Right) {
-		ctx.Report(node, "Unexpected mix of different operators. Wrap the inner expression in parentheses to make the grouping explicit.")
-	}
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  parent := noMixedOperatorsGroup(expr.OperatorToken.Kind)
+  if parent == 0 {
+    return
+  }
+  op := expr.OperatorToken.Kind
+  if noMixedOperatorsConflicts(parent, op, expr.Left) ||
+    noMixedOperatorsConflicts(parent, op, expr.Right) {
+    ctx.Report(node, "Unexpected mix of different operators. Wrap the inner expression in parentheses to make the grouping explicit.")
+  }
 }
 
 // noMixedOperatorsConflicts returns true when `child` is an
 // unparenthesized BinaryExpression whose operator group is confusing
 // next to the parent group. Same operator never conflicts.
 func noMixedOperatorsConflicts(parent int, parentOp shimast.Kind, child *shimast.Node) bool {
-	if child == nil || child.Kind != shimast.KindBinaryExpression {
-		return false
-	}
-	inner := child.AsBinaryExpression()
-	if inner == nil || inner.OperatorToken == nil || inner.OperatorToken.Kind == parentOp {
-		return false
-	}
-	g := noMixedOperatorsGroup(inner.OperatorToken.Kind)
-	if g == 0 {
-		return false
-	}
-	if parent == mixedGroupLogical {
-		return g == mixedGroupLogical || g == mixedGroupBitwise
-	}
-	return parent == mixedGroupBitwise && (g == mixedGroupLogical || g == mixedGroupComparison)
+  if child == nil || child.Kind != shimast.KindBinaryExpression {
+    return false
+  }
+  inner := child.AsBinaryExpression()
+  if inner == nil || inner.OperatorToken == nil || inner.OperatorToken.Kind == parentOp {
+    return false
+  }
+  g := noMixedOperatorsGroup(inner.OperatorToken.Kind)
+  if g == 0 {
+    return false
+  }
+  if parent == mixedGroupLogical {
+    return g == mixedGroupLogical || g == mixedGroupBitwise
+  }
+  return parent == mixedGroupBitwise && (g == mixedGroupLogical || g == mixedGroupComparison)
 }
 
 func noMixedOperatorsGroup(op shimast.Kind) int {
-	switch op {
-	case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken, shimast.KindQuestionQuestionToken:
-		return mixedGroupLogical
-	case shimast.KindAmpersandToken, shimast.KindBarToken, shimast.KindCaretToken:
-		return mixedGroupBitwise
-	case shimast.KindEqualsEqualsToken, shimast.KindEqualsEqualsEqualsToken,
-		shimast.KindExclamationEqualsToken, shimast.KindExclamationEqualsEqualsToken,
-		shimast.KindLessThanToken, shimast.KindLessThanEqualsToken,
-		shimast.KindGreaterThanToken, shimast.KindGreaterThanEqualsToken:
-		return mixedGroupComparison
-	}
-	return 0
+  switch op {
+  case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken, shimast.KindQuestionQuestionToken:
+    return mixedGroupLogical
+  case shimast.KindAmpersandToken, shimast.KindBarToken, shimast.KindCaretToken:
+    return mixedGroupBitwise
+  case shimast.KindEqualsEqualsToken, shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken, shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindLessThanToken, shimast.KindLessThanEqualsToken,
+    shimast.KindGreaterThanToken, shimast.KindGreaterThanEqualsToken:
+    return mixedGroupComparison
+  }
+  return 0
 }
 
 func init() { Register(noMixedOperators{}) }

package/linthost/rules_no_param_reassign.go

@@ -20,79 +20,79 @@ type noParamReassign struct{}
 
 func (noParamReassign) Name() string { return "no-param-reassign" }
 func (noParamReassign) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-		shimast.KindConstructor,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+    shimast.KindConstructor,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+  }
 }
 func (noParamReassign) Check(ctx *Context, node *shimast.Node) {
-	body := node.Body()
-	if body == nil {
-		return
-	}
-	names := map[string]bool{}
-	for _, p := range node.Parameters() {
-		if decl := p.AsParameterDeclaration(); decl != nil {
-			if name := identifierText(decl.Name()); name != "" {
-				names[name] = true
-			}
-		}
-	}
-	if len(names) == 0 {
-		return
-	}
-	walkParamReassignBody(body, names, func(target *shimast.Node) {
-		ctx.Report(target, "Assignment to function parameter.")
-	})
+  body := node.Body()
+  if body == nil {
+    return
+  }
+  names := map[string]bool{}
+  for _, p := range node.Parameters() {
+    if decl := p.AsParameterDeclaration(); decl != nil {
+      if name := identifierText(decl.Name()); name != "" {
+        names[name] = true
+      }
+    }
+  }
+  if len(names) == 0 {
+    return
+  }
+  walkParamReassignBody(body, names, func(target *shimast.Node) {
+    ctx.Report(target, "Assignment to function parameter.")
+  })
 }
 
 // walkParamReassignBody visits every assignment-like write in `root`
 // without crossing nested function-like scopes. The target identifier
 // must be a bare name in `names` for `report` to fire.
 func walkParamReassignBody(root *shimast.Node, names map[string]bool, report func(*shimast.Node)) {
-	if root == nil {
-		return
-	}
-	var walk func(*shimast.Node)
-	hits := func(operand *shimast.Node) bool {
-		name := identifierText(stripParens(operand))
-		return name != "" && names[name]
-	}
-	walk = func(node *shimast.Node) {
-		if node == nil || (node != root && isFunctionLikeKind(node)) {
-			return
-		}
-		switch node.Kind {
-		case shimast.KindBinaryExpression:
-			expr := node.AsBinaryExpression()
-			if expr != nil && expr.OperatorToken != nil &&
-				isAssignmentOperator(expr.OperatorToken.Kind) && hits(expr.Left) {
-				report(node)
-			}
-		case shimast.KindPrefixUnaryExpression:
-			pre := node.AsPrefixUnaryExpression()
-			if pre != nil && (pre.Operator == shimast.KindPlusPlusToken || pre.Operator == shimast.KindMinusMinusToken) && hits(pre.Operand) {
-				report(node)
-			}
-		case shimast.KindPostfixUnaryExpression:
-			post := node.AsPostfixUnaryExpression()
-			if post != nil && (post.Operator == shimast.KindPlusPlusToken || post.Operator == shimast.KindMinusMinusToken) && hits(post.Operand) {
-				report(node)
-			}
-		}
-		node.ForEachChild(func(child *shimast.Node) bool {
-			walk(child)
-			return false
-		})
-	}
-	walk(root)
+  if root == nil {
+    return
+  }
+  var walk func(*shimast.Node)
+  hits := func(operand *shimast.Node) bool {
+    name := identifierText(stripParens(operand))
+    return name != "" && names[name]
+  }
+  walk = func(node *shimast.Node) {
+    if node == nil || (node != root && isFunctionLikeKind(node)) {
+      return
+    }
+    switch node.Kind {
+    case shimast.KindBinaryExpression:
+      expr := node.AsBinaryExpression()
+      if expr != nil && expr.OperatorToken != nil &&
+        isAssignmentOperator(expr.OperatorToken.Kind) && hits(expr.Left) {
+        report(node)
+      }
+    case shimast.KindPrefixUnaryExpression:
+      pre := node.AsPrefixUnaryExpression()
+      if pre != nil && (pre.Operator == shimast.KindPlusPlusToken || pre.Operator == shimast.KindMinusMinusToken) && hits(pre.Operand) {
+        report(node)
+      }
+    case shimast.KindPostfixUnaryExpression:
+      post := node.AsPostfixUnaryExpression()
+      if post != nil && (post.Operator == shimast.KindPlusPlusToken || post.Operator == shimast.KindMinusMinusToken) && hits(post.Operand) {
+        report(node)
+      }
+    }
+    node.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(root)
 }
 
 func init() {
-	Register(noParamReassign{})
+  Register(noParamReassign{})
 }

package/linthost/rules_no_restricted_imports.go

@@ -17,9 +17,9 @@
 package linthost
 
 import (
-	"encoding/json"
+  "encoding/json"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noRestrictedImports struct{}
@@ -29,7 +29,7 @@ type noRestrictedImports struct{}
 // future ESLint-compatible keys (e.g. `patterns`) can be layered in
 // without changing existing configs.
 type noRestrictedImportsOptions struct {
-	Paths []string `json:"paths"`
+  Paths []string `json:"paths"`
 }
 
 // hardCodedRestrictedImports is the default deny list used when the
@@ -42,47 +42,47 @@ var hardCodedRestrictedImports = []string{"lodash", "underscore"}
 
 func (noRestrictedImports) Name() string { return "no-restricted-imports" }
 func (noRestrictedImports) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindImportDeclaration,
-		shimast.KindExportDeclaration,
-	}
+  return []shimast.Kind{
+    shimast.KindImportDeclaration,
+    shimast.KindExportDeclaration,
+  }
 }
 func (noRestrictedImports) Check(ctx *Context, node *shimast.Node) {
-	specifierNode := moduleSpecifierOf(node)
-	if specifierNode == nil {
-		return
-	}
-	specifier := stringLiteralText(specifierNode)
-	if specifier == "" {
-		return
-	}
-	denied := resolveNoRestrictedImportsPaths(ctx)
-	for _, target := range denied {
-		if specifier == target {
-			ctx.Report(specifierNode, "'"+specifier+"' import is restricted from being used.")
-			return
-		}
-	}
+  specifierNode := moduleSpecifierOf(node)
+  if specifierNode == nil {
+    return
+  }
+  specifier := stringLiteralText(specifierNode)
+  if specifier == "" {
+    return
+  }
+  denied := resolveNoRestrictedImportsPaths(ctx)
+  for _, target := range denied {
+    if specifier == target {
+      ctx.Report(specifierNode, "'"+specifier+"' import is restricted from being used.")
+      return
+    }
+  }
 }
 
 // moduleSpecifierOf returns the `from "…"` string-literal node of the
 // import / re-export declaration. `export { x }` (no `from`) and
 // every other shape returns nil so the caller short-circuits.
 func moduleSpecifierOf(node *shimast.Node) *shimast.Node {
-	if node == nil {
-		return nil
-	}
-	switch node.Kind {
-	case shimast.KindImportDeclaration:
-		if imp := node.AsImportDeclaration(); imp != nil {
-			return imp.ModuleSpecifier
-		}
-	case shimast.KindExportDeclaration:
-		if exp := node.AsExportDeclaration(); exp != nil {
-			return exp.ModuleSpecifier
-		}
-	}
-	return nil
+  if node == nil {
+    return nil
+  }
+  switch node.Kind {
+  case shimast.KindImportDeclaration:
+    if imp := node.AsImportDeclaration(); imp != nil {
+      return imp.ModuleSpecifier
+    }
+  case shimast.KindExportDeclaration:
+    if exp := node.AsExportDeclaration(); exp != nil {
+      return exp.ModuleSpecifier
+    }
+  }
+  return nil
 }
 
 // resolveNoRestrictedImportsPaths returns the active deny list for the
@@ -90,16 +90,16 @@ func moduleSpecifierOf(node *shimast.Node) *shimast.Node {
 // empty / missing blob falls back to `hardCodedRestrictedImports` so
 // the AST-layer test fires deterministically.
 func resolveNoRestrictedImportsPaths(ctx *Context) []string {
-	if ctx == nil || len(ctx.Options) == 0 {
-		return hardCodedRestrictedImports
-	}
-	var opts noRestrictedImportsOptions
-	if err := json.Unmarshal(ctx.Options, &opts); err != nil || len(opts.Paths) == 0 {
-		return hardCodedRestrictedImports
-	}
-	return opts.Paths
+  if ctx == nil || len(ctx.Options) == 0 {
+    return hardCodedRestrictedImports
+  }
+  var opts noRestrictedImportsOptions
+  if err := json.Unmarshal(ctx.Options, &opts); err != nil || len(opts.Paths) == 0 {
+    return hardCodedRestrictedImports
+  }
+  return opts.Paths
 }
 
 func init() {
-	Register(noRestrictedImports{})
+  Register(noRestrictedImports{})
 }

package/linthost/rules_no_restricted_syntax.go

@@ -12,38 +12,38 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // noRestrictedSyntaxDefault is the built-in denylist surfaced when no
 // config is supplied. Each entry pairs a banned node kind with the
 // short, actionable message reported at the offending node.
 var noRestrictedSyntaxDefault = map[shimast.Kind]string{
-	shimast.KindWithStatement:    "`with` statements are restricted — use explicit property access instead.",
-	shimast.KindLabeledStatement: "Labeled statements are restricted — refactor the surrounding control flow instead.",
+  shimast.KindWithStatement:    "`with` statements are restricted — use explicit property access instead.",
+  shimast.KindLabeledStatement: "Labeled statements are restricted — refactor the surrounding control flow instead.",
 }
 
 type noRestrictedSyntax struct{}
 
 func (noRestrictedSyntax) Name() string { return "no-restricted-syntax" }
 func (noRestrictedSyntax) Visits() []shimast.Kind {
-	kinds := make([]shimast.Kind, 0, len(noRestrictedSyntaxDefault))
-	for kind := range noRestrictedSyntaxDefault {
-		kinds = append(kinds, kind)
-	}
-	return kinds
+  kinds := make([]shimast.Kind, 0, len(noRestrictedSyntaxDefault))
+  for kind := range noRestrictedSyntaxDefault {
+    kinds = append(kinds, kind)
+  }
+  return kinds
 }
 func (noRestrictedSyntax) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	message, banned := noRestrictedSyntaxDefault[node.Kind]
-	if !banned {
-		return
-	}
-	ctx.Report(node, message)
+  if node == nil {
+    return
+  }
+  message, banned := noRestrictedSyntaxDefault[node.Kind]
+  if !banned {
+    return
+  }
+  ctx.Report(node, message)
 }
 
 func init() {
-	Register(noRestrictedSyntax{})
+  Register(noRestrictedSyntax{})
 }