@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_unicorn_consistent_existence_index_check.go

@@ -20,61 +20,61 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornConsistentExistenceIndexCheckMethods = map[string]struct{}{
-	"indexOf":       {},
-	"findIndex":     {},
-	"lastIndexOf":   {},
-	"findLastIndex": {},
+  "indexOf":       {},
+  "findIndex":     {},
+  "lastIndexOf":   {},
+  "findLastIndex": {},
 }
 
 type unicornConsistentExistenceIndexCheck struct{}
 
 func (unicornConsistentExistenceIndexCheck) Name() string {
-	return "unicorn/consistent-existence-index-check"
+  return "unicorn/consistent-existence-index-check"
 }
 func (unicornConsistentExistenceIndexCheck) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (unicornConsistentExistenceIndexCheck) Check(ctx *Context, node *shimast.Node) {
-	bin := node.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
-		return
-	}
-	switch bin.OperatorToken.Kind {
-	case shimast.KindLessThanToken, shimast.KindGreaterThanEqualsToken:
-	default:
-		return
-	}
-	left := stripParens(bin.Left)
-	right := stripParens(bin.Right)
-	if unicornConsistentExistenceIndexCheckMatch(left, right) {
-		ctx.Report(node, "Use a consistent existence-check form for `indexOf` / `findIndex` — prefer `=== -1` / `!== -1` over magnitude comparisons.")
-	}
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindLessThanToken, shimast.KindGreaterThanEqualsToken:
+  default:
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if unicornConsistentExistenceIndexCheckMatch(left, right) {
+    ctx.Report(node, "Use a consistent existence-check form for `indexOf` / `findIndex` — prefer `=== -1` / `!== -1` over magnitude comparisons.")
+  }
 }
 
 func unicornConsistentExistenceIndexCheckMatch(callSide, literalSide *shimast.Node) bool {
-	if callSide == nil || literalSide == nil {
-		return false
-	}
-	if literalSide.Kind != shimast.KindNumericLiteral ||
-		numericLiteralText(literalSide) != "0" {
-		return false
-	}
-	if callSide.Kind != shimast.KindCallExpression {
-		return false
-	}
-	call := callSide.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return false
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return false
-	}
-	_, ok := unicornConsistentExistenceIndexCheckMethods[identifierText(access.Name())]
-	return ok
+  if callSide == nil || literalSide == nil {
+    return false
+  }
+  if literalSide.Kind != shimast.KindNumericLiteral ||
+    numericLiteralText(literalSide) != "0" {
+    return false
+  }
+  if callSide.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := callSide.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return false
+  }
+  _, ok := unicornConsistentExistenceIndexCheckMethods[identifierText(access.Name())]
+  return ok
 }
 
 func init() {
-	Register(unicornConsistentExistenceIndexCheck{})
+  Register(unicornConsistentExistenceIndexCheck{})
 }

package/linthost/rules_unicorn_consistent_function_scoping.go

@@ -12,14 +12,14 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornConsistentFunctionScoping struct{}
 
 func (unicornConsistentFunctionScoping) Name() string {
-	return "unicorn/consistent-function-scoping"
+  return "unicorn/consistent-function-scoping"
 }
 func (unicornConsistentFunctionScoping) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindSourceFile}
 }
 func (unicornConsistentFunctionScoping) Check(ctx *Context, node *shimast.Node) {
 }
 
 func init() {
-	Register(unicornConsistentFunctionScoping{})
+  Register(unicornConsistentFunctionScoping{})
 }

package/linthost/rules_unicorn_consistent_template_literal_escape.go

@@ -12,14 +12,14 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornConsistentTemplateLiteralEscape struct{}
 
 func (unicornConsistentTemplateLiteralEscape) Name() string {
-	return "unicorn/consistent-template-literal-escape"
+  return "unicorn/consistent-template-literal-escape"
 }
 func (unicornConsistentTemplateLiteralEscape) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindSourceFile}
 }
 func (unicornConsistentTemplateLiteralEscape) Check(ctx *Context, node *shimast.Node) {
 }
 
 func init() {
-	Register(unicornConsistentTemplateLiteralEscape{})
+  Register(unicornConsistentTemplateLiteralEscape{})
 }

package/linthost/rules_unicorn_custom_error_definition.go

@@ -17,88 +17,88 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornCustomErrorDefinitionBaseNames = map[string]struct{}{
-	"Error":          {},
-	"EvalError":      {},
-	"RangeError":     {},
-	"ReferenceError": {},
-	"SyntaxError":    {},
-	"TypeError":      {},
-	"URIError":       {},
-	"AggregateError": {},
+  "Error":          {},
+  "EvalError":      {},
+  "RangeError":     {},
+  "ReferenceError": {},
+  "SyntaxError":    {},
+  "TypeError":      {},
+  "URIError":       {},
+  "AggregateError": {},
 }
 
 type unicornCustomErrorDefinition struct{}
 
 func (unicornCustomErrorDefinition) Name() string {
-	return "unicorn/custom-error-definition"
+  return "unicorn/custom-error-definition"
 }
 func (unicornCustomErrorDefinition) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
+  return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
 }
 func (unicornCustomErrorDefinition) Check(ctx *Context, node *shimast.Node) {
-	if !unicornCustomErrorDefinitionExtendsError(node) {
-		return
-	}
-	members := classMembers(node)
-	for _, member := range members {
-		if member == nil || member.Kind != shimast.KindConstructor {
-			continue
-		}
-		ctor := member.AsConstructorDeclaration()
-		if ctor == nil || ctor.Body == nil {
-			continue
-		}
-		if !unicornCustomErrorDefinitionBodyCallsSuper(ctor.Body) {
-			ctx.Report(node, "A custom `Error` subclass should call `super(message)` and set `this.name`.")
-			return
-		}
-	}
+  if !unicornCustomErrorDefinitionExtendsError(node) {
+    return
+  }
+  members := classMembers(node)
+  for _, member := range members {
+    if member == nil || member.Kind != shimast.KindConstructor {
+      continue
+    }
+    ctor := member.AsConstructorDeclaration()
+    if ctor == nil || ctor.Body == nil {
+      continue
+    }
+    if !unicornCustomErrorDefinitionBodyCallsSuper(ctor.Body) {
+      ctx.Report(node, "A custom `Error` subclass should call `super(message)` and set `this.name`.")
+      return
+    }
+  }
 }
 
 // unicornCustomErrorDefinitionExtendsError reports whether `class` has
 // an `extends <Identifier>` heritage clause whose target identifier is
 // one of the built-in Error constructors.
 func unicornCustomErrorDefinitionExtendsError(class *shimast.Node) bool {
-	var clauses []*shimast.Node
-	switch class.Kind {
-	case shimast.KindClassDeclaration:
-		decl := class.AsClassDeclaration()
-		if decl == nil || decl.HeritageClauses == nil {
-			return false
-		}
-		clauses = decl.HeritageClauses.Nodes
-	case shimast.KindClassExpression:
-		expr := class.AsClassExpression()
-		if expr == nil || expr.HeritageClauses == nil {
-			return false
-		}
-		clauses = expr.HeritageClauses.Nodes
-	default:
-		return false
-	}
-	for _, clause := range clauses {
-		if clause == nil {
-			continue
-		}
-		hc := clause.AsHeritageClause()
-		if hc == nil || hc.Token != shimast.KindExtendsKeyword || hc.Types == nil {
-			continue
-		}
-		for _, ty := range hc.Types.Nodes {
-			if ty == nil {
-				continue
-			}
-			expr := ty.AsExpressionWithTypeArguments()
-			if expr == nil {
-				continue
-			}
-			name := identifierText(expr.Expression)
-			if _, ok := unicornCustomErrorDefinitionBaseNames[name]; ok {
-				return true
-			}
-		}
-	}
-	return false
+  var clauses []*shimast.Node
+  switch class.Kind {
+  case shimast.KindClassDeclaration:
+    decl := class.AsClassDeclaration()
+    if decl == nil || decl.HeritageClauses == nil {
+      return false
+    }
+    clauses = decl.HeritageClauses.Nodes
+  case shimast.KindClassExpression:
+    expr := class.AsClassExpression()
+    if expr == nil || expr.HeritageClauses == nil {
+      return false
+    }
+    clauses = expr.HeritageClauses.Nodes
+  default:
+    return false
+  }
+  for _, clause := range clauses {
+    if clause == nil {
+      continue
+    }
+    hc := clause.AsHeritageClause()
+    if hc == nil || hc.Token != shimast.KindExtendsKeyword || hc.Types == nil {
+      continue
+    }
+    for _, ty := range hc.Types.Nodes {
+      if ty == nil {
+        continue
+      }
+      expr := ty.AsExpressionWithTypeArguments()
+      if expr == nil {
+        continue
+      }
+      name := identifierText(expr.Expression)
+      if _, ok := unicornCustomErrorDefinitionBaseNames[name]; ok {
+        return true
+      }
+    }
+  }
+  return false
 }
 
 // unicornCustomErrorDefinitionBodyCallsSuper walks the constructor body
@@ -107,32 +107,32 @@ func unicornCustomErrorDefinitionExtendsError(class *shimast.Node) bool {
 // — a `super(...)` inside a nested arrow does not initialize `Error`'s
 // prototype state.
 func unicornCustomErrorDefinitionBodyCallsSuper(body *shimast.Node) bool {
-	found := false
-	var walk func(*shimast.Node)
-	walk = func(n *shimast.Node) {
-		if n == nil || found {
-			return
-		}
-		if n != body && isFunctionLikeKind(n) {
-			return
-		}
-		if n.Kind == shimast.KindCallExpression {
-			call := n.AsCallExpression()
-			if call != nil && call.Expression != nil &&
-				call.Expression.Kind == shimast.KindSuperKeyword {
-				found = true
-				return
-			}
-		}
-		n.ForEachChild(func(child *shimast.Node) bool {
-			walk(child)
-			return false
-		})
-	}
-	walk(body)
-	return found
+  found := false
+  var walk func(*shimast.Node)
+  walk = func(n *shimast.Node) {
+    if n == nil || found {
+      return
+    }
+    if n != body && isFunctionLikeKind(n) {
+      return
+    }
+    if n.Kind == shimast.KindCallExpression {
+      call := n.AsCallExpression()
+      if call != nil && call.Expression != nil &&
+        call.Expression.Kind == shimast.KindSuperKeyword {
+        found = true
+        return
+      }
+    }
+    n.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(body)
+  return found
 }
 
 func init() {
-	Register(unicornCustomErrorDefinition{})
+  Register(unicornCustomErrorDefinition{})
 }

package/linthost/rules_unicorn_empty_brace_spaces.go

@@ -18,56 +18,56 @@ type unicornEmptyBraceSpaces struct{}
 
 func (unicornEmptyBraceSpaces) Name() string { return "unicorn/empty-brace-spaces" }
 func (unicornEmptyBraceSpaces) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBlock, shimast.KindObjectLiteralExpression}
+  return []shimast.Kind{shimast.KindBlock, shimast.KindObjectLiteralExpression}
 }
 func (unicornEmptyBraceSpaces) Check(ctx *Context, node *shimast.Node) {
-	if ctx.File == nil {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindBlock:
-		block := node.AsBlock()
-		if block == nil || block.Statements == nil || len(block.Statements.Nodes) > 0 {
-			return
-		}
-	case shimast.KindObjectLiteralExpression:
-		obj := node.AsObjectLiteralExpression()
-		if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) > 0 {
-			return
-		}
-	default:
-		return
-	}
-	src := ctx.File.Text()
-	_, end := tokenRange(ctx.File, node)
-	pos := node.Pos()
-	if pos < 0 || end < 0 || end > len(src) {
-		return
-	}
-	// Locate the opening `{` after any leading trivia.
-	open := -1
-	for i := pos; i < end; i++ {
-		if src[i] == '{' {
-			open = i
-			break
-		}
-	}
-	if open < 0 || end-1 <= open {
-		return
-	}
-	// The closing `}` is the byte immediately before End().
-	if src[end-1] != '}' {
-		return
-	}
-	for i := open + 1; i < end-1; i++ {
-		switch src[i] {
-		case ' ', '\t', '\r', '\n':
-			ctx.Report(node, "Empty braces shouldn't contain whitespace.")
-			return
-		}
-	}
+  if ctx.File == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindBlock:
+    block := node.AsBlock()
+    if block == nil || block.Statements == nil || len(block.Statements.Nodes) > 0 {
+      return
+    }
+  case shimast.KindObjectLiteralExpression:
+    obj := node.AsObjectLiteralExpression()
+    if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) > 0 {
+      return
+    }
+  default:
+    return
+  }
+  src := ctx.File.Text()
+  _, end := tokenRange(ctx.File, node)
+  pos := node.Pos()
+  if pos < 0 || end < 0 || end > len(src) {
+    return
+  }
+  // Locate the opening `{` after any leading trivia.
+  open := -1
+  for i := pos; i < end; i++ {
+    if src[i] == '{' {
+      open = i
+      break
+    }
+  }
+  if open < 0 || end-1 <= open {
+    return
+  }
+  // The closing `}` is the byte immediately before End().
+  if src[end-1] != '}' {
+    return
+  }
+  for i := open + 1; i < end-1; i++ {
+    switch src[i] {
+    case ' ', '\t', '\r', '\n':
+      ctx.Report(node, "Empty braces shouldn't contain whitespace.")
+      return
+    }
+  }
 }
 
 func init() {
-	Register(unicornEmptyBraceSpaces{})
+  Register(unicornEmptyBraceSpaces{})
 }

package/linthost/rules_unicorn_error_message.go

@@ -16,49 +16,49 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornErrorMessageBuiltinNames = map[string]struct{}{
-	"Error":          {},
-	"TypeError":      {},
-	"RangeError":     {},
-	"SyntaxError":    {},
-	"ReferenceError": {},
-	"EvalError":      {},
-	"URIError":       {},
-	"AggregateError": {},
+  "Error":          {},
+  "TypeError":      {},
+  "RangeError":     {},
+  "SyntaxError":    {},
+  "ReferenceError": {},
+  "EvalError":      {},
+  "URIError":       {},
+  "AggregateError": {},
 }
 
 type unicornErrorMessage struct{}
 
 func (unicornErrorMessage) Name() string { return "unicorn/error-message" }
 func (unicornErrorMessage) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression}
+  return []shimast.Kind{shimast.KindNewExpression}
 }
 func (unicornErrorMessage) Check(ctx *Context, node *shimast.Node) {
-	ne := node.AsNewExpression()
-	if ne == nil {
-		return
-	}
-	name := identifierText(ne.Expression)
-	if name == "" {
-		return
-	}
-	if _, ok := unicornErrorMessageBuiltinNames[name]; !ok {
-		return
-	}
-	// Zero arguments — `new Error()` / `new Error` — always fires.
-	if ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
-		ctx.Report(node, "Pass an error message to the `Error` constructor.")
-		return
-	}
-	// Single argument — fire only when the argument is an empty string
-	// literal. Dynamic arguments cannot be proven empty statically.
-	if len(ne.Arguments.Nodes) == 1 {
-		arg := stripParens(ne.Arguments.Nodes[0])
-		if arg != nil && arg.Kind == shimast.KindStringLiteral && stringLiteralText(arg) == "" {
-			ctx.Report(node, "Pass an error message to the `Error` constructor.")
-		}
-	}
+  ne := node.AsNewExpression()
+  if ne == nil {
+    return
+  }
+  name := identifierText(ne.Expression)
+  if name == "" {
+    return
+  }
+  if _, ok := unicornErrorMessageBuiltinNames[name]; !ok {
+    return
+  }
+  // Zero arguments — `new Error()` / `new Error` — always fires.
+  if ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
+    ctx.Report(node, "Pass an error message to the `Error` constructor.")
+    return
+  }
+  // Single argument — fire only when the argument is an empty string
+  // literal. Dynamic arguments cannot be proven empty statically.
+  if len(ne.Arguments.Nodes) == 1 {
+    arg := stripParens(ne.Arguments.Nodes[0])
+    if arg != nil && arg.Kind == shimast.KindStringLiteral && stringLiteralText(arg) == "" {
+      ctx.Report(node, "Pass an error message to the `Error` constructor.")
+    }
+  }
 }
 
 func init() {
-	Register(unicornErrorMessage{})
+  Register(unicornErrorMessage{})
 }

package/linthost/rules_unicorn_escape_case.go

@@ -15,9 +15,9 @@
 package linthost
 
 import (
-	"regexp"
+  "regexp"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // unicornEscapeCasePattern matches a hex escape whose hex digits contain
@@ -25,27 +25,27 @@ import (
 // `\u{...}` and rejects matches where every hex digit is already
 // uppercase / 0-9.
 var unicornEscapeCasePattern = regexp.MustCompile(
-	`\\x[0-9A-Fa-f]*[a-f][0-9A-Fa-f]*|` +
-		`\\u\{[0-9A-Fa-f]*[a-f][0-9A-Fa-f]*\}|` +
-		`\\u[0-9A-Fa-f]*[a-f][0-9A-Fa-f]*`,
+  `\\x[0-9A-Fa-f]*[a-f][0-9A-Fa-f]*|` +
+    `\\u\{[0-9A-Fa-f]*[a-f][0-9A-Fa-f]*\}|` +
+    `\\u[0-9A-Fa-f]*[a-f][0-9A-Fa-f]*`,
 )
 
 type unicornEscapeCase struct{}
 
 func (unicornEscapeCase) Name() string { return "unicorn/escape-case" }
 func (unicornEscapeCase) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+  return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
 }
 func (unicornEscapeCase) Check(ctx *Context, node *shimast.Node) {
-	source := nodeText(ctx.File, node)
-	if source == "" {
-		return
-	}
-	if unicornEscapeCasePattern.MatchString(source) {
-		ctx.Report(node, "Use uppercase letters for escape sequence hex digits (`\\xA9` over `\\xa9`).")
-	}
+  source := nodeText(ctx.File, node)
+  if source == "" {
+    return
+  }
+  if unicornEscapeCasePattern.MatchString(source) {
+    ctx.Report(node, "Use uppercase letters for escape sequence hex digits (`\\xA9` over `\\xa9`).")
+  }
 }
 
 func init() {
-	Register(unicornEscapeCase{})
+  Register(unicornEscapeCase{})
 }