@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_unicorn_no_document_cookie.go

@@ -20,22 +20,22 @@ type unicornNoDocumentCookie struct{}
 
 func (unicornNoDocumentCookie) Name() string { return "unicorn/no-document-cookie" }
 func (unicornNoDocumentCookie) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
 }
 func (unicornNoDocumentCookie) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Expression) != "document" {
-		return
-	}
-	if identifierText(access.Name()) != "cookie" {
-		return
-	}
-	ctx.Report(node, "Don't use `document.cookie` directly; use the Cookie Store API or a wrapper.")
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Expression) != "document" {
+    return
+  }
+  if identifierText(access.Name()) != "cookie" {
+    return
+  }
+  ctx.Report(node, "Don't use `document.cookie` directly; use the Cookie Store API or a wrapper.")
 }
 
 func init() {
-	Register(unicornNoDocumentCookie{})
+  Register(unicornNoDocumentCookie{})
 }

package/linthost/rules_unicorn_no_empty_file.go

@@ -22,23 +22,23 @@ type unicornNoEmptyFile struct{}
 func (unicornNoEmptyFile) Name() string           { return "unicorn/no-empty-file" }
 func (unicornNoEmptyFile) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (unicornNoEmptyFile) Check(ctx *Context, node *shimast.Node) {
-	if ctx.File == nil {
-		return
-	}
-	statements := ctx.File.Statements
-	const message = "Empty files are not allowed."
-	if statements == nil || len(statements.Nodes) == 0 {
-		ctx.ReportRange(0, 0, message)
-		return
-	}
-	for _, stmt := range statements.Nodes {
-		if stmt == nil || stmt.Kind != shimast.KindEmptyStatement {
-			return
-		}
-	}
-	ctx.Report(statements.Nodes[0], message)
+  if ctx.File == nil {
+    return
+  }
+  statements := ctx.File.Statements
+  const message = "Empty files are not allowed."
+  if statements == nil || len(statements.Nodes) == 0 {
+    ctx.ReportRange(0, 0, message)
+    return
+  }
+  for _, stmt := range statements.Nodes {
+    if stmt == nil || stmt.Kind != shimast.KindEmptyStatement {
+      return
+    }
+  }
+  ctx.Report(statements.Nodes[0], message)
 }
 
 func init() {
-	Register(unicornNoEmptyFile{})
+  Register(unicornNoEmptyFile{})
 }

package/linthost/rules_unicorn_no_for_loop.go

@@ -21,41 +21,41 @@ type unicornNoForLoop struct{}
 func (unicornNoForLoop) Name() string           { return "unicorn/no-for-loop" }
 func (unicornNoForLoop) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindForStatement} }
 func (unicornNoForLoop) Check(ctx *Context, node *shimast.Node) {
-	stmt := node.AsForStatement()
-	if stmt == nil || stmt.Initializer == nil || stmt.Condition == nil || stmt.Incrementor == nil {
-		return
-	}
-	indexName := indexInitializerName(stmt.Initializer)
-	if indexName == "" {
-		return
-	}
-	if !isLessThanCondition(stmt.Condition, indexName) {
-		return
-	}
-	if !isPostfixIncrementOf(stmt.Incrementor, indexName) {
-		return
-	}
-	ctx.Report(node, "Use `for…of` over an index-based `for` loop over an array.")
+  stmt := node.AsForStatement()
+  if stmt == nil || stmt.Initializer == nil || stmt.Condition == nil || stmt.Incrementor == nil {
+    return
+  }
+  indexName := indexInitializerName(stmt.Initializer)
+  if indexName == "" {
+    return
+  }
+  if !isLessThanCondition(stmt.Condition, indexName) {
+    return
+  }
+  if !isPostfixIncrementOf(stmt.Incrementor, indexName) {
+    return
+  }
+  ctx.Report(node, "Use `for…of` over an index-based `for` loop over an array.")
 }
 
 // indexInitializerName returns the variable name of a `let i = 0`
 // initializer, or "" when the initializer is anything else.
 func indexInitializerName(init *shimast.Node) string {
-	if init == nil || 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].AsVariableDeclaration()
-	if decl == nil || decl.Initializer == nil {
-		return ""
-	}
-	if numericLiteralText(stripParens(decl.Initializer)) != "0" {
-		return ""
-	}
-	return identifierText(decl.Name())
+  if init == nil || 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].AsVariableDeclaration()
+  if decl == nil || decl.Initializer == nil {
+    return ""
+  }
+  if numericLiteralText(stripParens(decl.Initializer)) != "0" {
+    return ""
+  }
+  return identifierText(decl.Name())
 }
 
 // isLessThanCondition reports whether `cond` has the shape
@@ -64,39 +64,39 @@ func indexInitializerName(init *shimast.Node) string {
 // `for (let i = 0; i < n; i++)` are NOT flagged because the rule's
 // suggested rewrite (`for…of`) only applies to array iteration.
 func isLessThanCondition(cond *shimast.Node, name string) bool {
-	node := stripParens(cond)
-	if node == nil || node.Kind != shimast.KindBinaryExpression {
-		return false
-	}
-	bin := node.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil ||
-		bin.OperatorToken.Kind != shimast.KindLessThanToken {
-		return false
-	}
-	if identifierText(stripParens(bin.Left)) != name {
-		return false
-	}
-	right := stripParens(bin.Right)
-	if right == nil || right.Kind != shimast.KindPropertyAccessExpression {
-		return false
-	}
-	access := right.AsPropertyAccessExpression()
-	return access != nil && identifierText(access.Name()) == "length"
+  node := stripParens(cond)
+  if node == nil || node.Kind != shimast.KindBinaryExpression {
+    return false
+  }
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil ||
+    bin.OperatorToken.Kind != shimast.KindLessThanToken {
+    return false
+  }
+  if identifierText(stripParens(bin.Left)) != name {
+    return false
+  }
+  right := stripParens(bin.Right)
+  if right == nil || right.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := right.AsPropertyAccessExpression()
+  return access != nil && identifierText(access.Name()) == "length"
 }
 
 // isPostfixIncrementOf reports whether `inc` has the shape `<name>++`.
 func isPostfixIncrementOf(inc *shimast.Node, name string) bool {
-	node := stripParens(inc)
-	if node == nil || node.Kind != shimast.KindPostfixUnaryExpression {
-		return false
-	}
-	post := node.AsPostfixUnaryExpression()
-	if post == nil || post.Operator != shimast.KindPlusPlusToken {
-		return false
-	}
-	return identifierText(post.Operand) == name
+  node := stripParens(inc)
+  if node == nil || node.Kind != shimast.KindPostfixUnaryExpression {
+    return false
+  }
+  post := node.AsPostfixUnaryExpression()
+  if post == nil || post.Operator != shimast.KindPlusPlusToken {
+    return false
+  }
+  return identifierText(post.Operand) == name
 }
 
 func init() {
-	Register(unicornNoForLoop{})
+  Register(unicornNoForLoop{})
 }

package/linthost/rules_unicorn_no_hex_escape.go

@@ -14,9 +14,9 @@
 package linthost
 
 import (
-	"regexp"
+  "regexp"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 var unicornNoHexEscapePattern = regexp.MustCompile(`\\x[0-9A-Fa-f]{2}`)
@@ -25,18 +25,18 @@ type unicornNoHexEscape struct{}
 
 func (unicornNoHexEscape) Name() string { return "unicorn/no-hex-escape" }
 func (unicornNoHexEscape) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+  return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
 }
 func (unicornNoHexEscape) Check(ctx *Context, node *shimast.Node) {
-	source := nodeText(ctx.File, node)
-	if source == "" {
-		return
-	}
-	if unicornNoHexEscapePattern.MatchString(source) {
-		ctx.Report(node, "Prefer Unicode escapes (`\\uXXXX`) over hex escapes (`\\xHH`).")
-	}
+  source := nodeText(ctx.File, node)
+  if source == "" {
+    return
+  }
+  if unicornNoHexEscapePattern.MatchString(source) {
+    ctx.Report(node, "Prefer Unicode escapes (`\\uXXXX`) over hex escapes (`\\xHH`).")
+  }
 }
 
 func init() {
-	Register(unicornNoHexEscape{})
+  Register(unicornNoHexEscape{})
 }

package/linthost/rules_unicorn_no_immediate_mutation.go

@@ -18,73 +18,73 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornNoImmediateMutationMethods = map[string]struct{}{
-	"push":       {},
-	"pop":        {},
-	"shift":      {},
-	"unshift":    {},
-	"splice":     {},
-	"sort":       {},
-	"reverse":    {},
-	"copyWithin": {},
-	"fill":       {},
+  "push":       {},
+  "pop":        {},
+  "shift":      {},
+  "unshift":    {},
+  "splice":     {},
+  "sort":       {},
+  "reverse":    {},
+  "copyWithin": {},
+  "fill":       {},
 }
 
 var unicornNoImmediateMutationFreshMethods = map[string]struct{}{
-	"map":     {},
-	"filter":  {},
-	"slice":   {},
-	"concat":  {},
-	"flat":    {},
-	"flatMap": {},
+  "map":     {},
+  "filter":  {},
+  "slice":   {},
+  "concat":  {},
+  "flat":    {},
+  "flatMap": {},
 }
 
 type unicornNoImmediateMutation struct{}
 
 func (unicornNoImmediateMutation) Name() string { return "unicorn/no-immediate-mutation" }
 func (unicornNoImmediateMutation) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoImmediateMutation) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	method := identifierText(access.Name())
-	if _, ok := unicornNoImmediateMutationMethods[method]; !ok {
-		return
-	}
-	receiver := stripParens(access.Expression)
-	if receiver == nil {
-		return
-	}
-	if receiver.Kind == shimast.KindArrayLiteralExpression {
-		ctx.Report(node, "Don't mutate a freshly built array — separate the construction and the mutation, or use a non-mutating method.")
-		return
-	}
-	if receiver.Kind == shimast.KindCallExpression {
-		inner := receiver.AsCallExpression()
-		if inner == nil || inner.Expression == nil ||
-			inner.Expression.Kind != shimast.KindPropertyAccessExpression {
-			return
-		}
-		innerAccess := inner.Expression.AsPropertyAccessExpression()
-		if innerAccess == nil {
-			return
-		}
-		innerName := identifierText(innerAccess.Name())
-		if _, ok := unicornNoImmediateMutationFreshMethods[innerName]; ok {
-			ctx.Report(node, "Don't mutate a freshly built array — separate the construction and the mutation, or use a non-mutating method.")
-		}
-	}
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  method := identifierText(access.Name())
+  if _, ok := unicornNoImmediateMutationMethods[method]; !ok {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil {
+    return
+  }
+  if receiver.Kind == shimast.KindArrayLiteralExpression {
+    ctx.Report(node, "Don't mutate a freshly built array — separate the construction and the mutation, or use a non-mutating method.")
+    return
+  }
+  if receiver.Kind == shimast.KindCallExpression {
+    inner := receiver.AsCallExpression()
+    if inner == nil || inner.Expression == nil ||
+      inner.Expression.Kind != shimast.KindPropertyAccessExpression {
+      return
+    }
+    innerAccess := inner.Expression.AsPropertyAccessExpression()
+    if innerAccess == nil {
+      return
+    }
+    innerName := identifierText(innerAccess.Name())
+    if _, ok := unicornNoImmediateMutationFreshMethods[innerName]; ok {
+      ctx.Report(node, "Don't mutate a freshly built array — separate the construction and the mutation, or use a non-mutating method.")
+    }
+  }
 }
 
 func init() {
-	Register(unicornNoImmediateMutation{})
+  Register(unicornNoImmediateMutation{})
 }

package/linthost/rules_unicorn_no_instanceof_builtins.go

@@ -18,49 +18,49 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornNoInstanceofBuiltinsNames = map[string]struct{}{
-	"Array":          {},
-	"Error":          {},
-	"EvalError":      {},
-	"RangeError":     {},
-	"ReferenceError": {},
-	"SyntaxError":    {},
-	"TypeError":      {},
-	"URIError":       {},
-	"AggregateError": {},
-	"Map":            {},
-	"Set":            {},
-	"WeakMap":        {},
-	"WeakSet":        {},
-	"Date":           {},
-	"RegExp":         {},
-	"Promise":        {},
-	"Function":       {},
+  "Array":          {},
+  "Error":          {},
+  "EvalError":      {},
+  "RangeError":     {},
+  "ReferenceError": {},
+  "SyntaxError":    {},
+  "TypeError":      {},
+  "URIError":       {},
+  "AggregateError": {},
+  "Map":            {},
+  "Set":            {},
+  "WeakMap":        {},
+  "WeakSet":        {},
+  "Date":           {},
+  "RegExp":         {},
+  "Promise":        {},
+  "Function":       {},
 }
 
 type unicornNoInstanceofBuiltins struct{}
 
 func (unicornNoInstanceofBuiltins) Name() string { return "unicorn/no-instanceof-builtins" }
 func (unicornNoInstanceofBuiltins) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (unicornNoInstanceofBuiltins) Check(ctx *Context, node *shimast.Node) {
-	bin := node.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil || bin.Right == nil {
-		return
-	}
-	if bin.OperatorToken.Kind != shimast.KindInstanceOfKeyword {
-		return
-	}
-	name := identifierText(bin.Right)
-	if name == "" {
-		return
-	}
-	if _, ok := unicornNoInstanceofBuiltinsNames[name]; !ok {
-		return
-	}
-	ctx.Report(node, "Don't use `instanceof <Builtin>` — it breaks across realms and for subclasses. Use a type predicate or duck-typing instead.")
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Right == nil {
+    return
+  }
+  if bin.OperatorToken.Kind != shimast.KindInstanceOfKeyword {
+    return
+  }
+  name := identifierText(bin.Right)
+  if name == "" {
+    return
+  }
+  if _, ok := unicornNoInstanceofBuiltinsNames[name]; !ok {
+    return
+  }
+  ctx.Report(node, "Don't use `instanceof <Builtin>` — it breaks across realms and for subclasses. Use a type predicate or duck-typing instead.")
 }
 
 func init() {
-	Register(unicornNoInstanceofBuiltins{})
+  Register(unicornNoInstanceofBuiltins{})
 }

package/linthost/rules_unicorn_no_invalid_fetch_options.go

@@ -12,68 +12,68 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type unicornNoInvalidFetchOptions struct{}
 
 func (unicornNoInvalidFetchOptions) Name() string { return "unicorn/no-invalid-fetch-options" }
 func (unicornNoInvalidFetchOptions) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoInvalidFetchOptions) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil {
-		return
-	}
-	if identifierText(call.Expression) != "fetch" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
-		return
-	}
-	init := stripParens(call.Arguments.Nodes[1])
-	if init == nil || init.Kind != shimast.KindObjectLiteralExpression {
-		return
-	}
-	obj := init.AsObjectLiteralExpression()
-	if obj == nil || obj.Properties == nil {
-		return
-	}
-	hasBody := false
-	methodIsBodyless := false
-	for _, prop := range obj.Properties.Nodes {
-		if prop == nil || prop.Kind != shimast.KindPropertyAssignment {
-			continue
-		}
-		assignment := prop.AsPropertyAssignment()
-		if assignment == nil || assignment.Name() == nil {
-			continue
-		}
-		key := identifierText(assignment.Name())
-		if key == "" && assignment.Name().Kind == shimast.KindStringLiteral {
-			key = stringLiteralText(assignment.Name())
-		}
-		switch key {
-		case "body":
-			hasBody = true
-		case "method":
-			value := stripParens(assignment.Initializer)
-			if value != nil && value.Kind == shimast.KindStringLiteral {
-				m := strings.ToLower(stringLiteralText(value))
-				if m == "get" || m == "head" {
-					methodIsBodyless = true
-				}
-			}
-		}
-	}
-	if hasBody && methodIsBodyless {
-		ctx.Report(node, "Don't pass `body` with GET/HEAD `fetch` — it throws at runtime.")
-	}
+  call := node.AsCallExpression()
+  if call == nil {
+    return
+  }
+  if identifierText(call.Expression) != "fetch" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
+    return
+  }
+  init := stripParens(call.Arguments.Nodes[1])
+  if init == nil || init.Kind != shimast.KindObjectLiteralExpression {
+    return
+  }
+  obj := init.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil {
+    return
+  }
+  hasBody := false
+  methodIsBodyless := false
+  for _, prop := range obj.Properties.Nodes {
+    if prop == nil || prop.Kind != shimast.KindPropertyAssignment {
+      continue
+    }
+    assignment := prop.AsPropertyAssignment()
+    if assignment == nil || assignment.Name() == nil {
+      continue
+    }
+    key := identifierText(assignment.Name())
+    if key == "" && assignment.Name().Kind == shimast.KindStringLiteral {
+      key = stringLiteralText(assignment.Name())
+    }
+    switch key {
+    case "body":
+      hasBody = true
+    case "method":
+      value := stripParens(assignment.Initializer)
+      if value != nil && value.Kind == shimast.KindStringLiteral {
+        m := strings.ToLower(stringLiteralText(value))
+        if m == "get" || m == "head" {
+          methodIsBodyless = true
+        }
+      }
+    }
+  }
+  if hasBody && methodIsBodyless {
+    ctx.Report(node, "Don't pass `body` with GET/HEAD `fetch` — it throws at runtime.")
+  }
 }
 
 func init() {
-	Register(unicornNoInvalidFetchOptions{})
+  Register(unicornNoInvalidFetchOptions{})
 }

package/linthost/rules_unicorn_no_invalid_remove_event_listener.go

@@ -16,36 +16,36 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoInvalidRemoveEventListener struct{}
 
 func (unicornNoInvalidRemoveEventListener) Name() string {
-	return "unicorn/no-invalid-remove-event-listener"
+  return "unicorn/no-invalid-remove-event-listener"
 }
 func (unicornNoInvalidRemoveEventListener) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoInvalidRemoveEventListener) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil || identifierText(access.Name()) != "removeEventListener" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
-		return
-	}
-	handler := stripParens(call.Arguments.Nodes[1])
-	if handler == nil {
-		return
-	}
-	switch handler.Kind {
-	case shimast.KindArrowFunction, shimast.KindFunctionExpression:
-		ctx.Report(node, "Calling `removeEventListener` with a fresh function reference removes nothing — store and reuse the handler.")
-	}
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "removeEventListener" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
+    return
+  }
+  handler := stripParens(call.Arguments.Nodes[1])
+  if handler == nil {
+    return
+  }
+  switch handler.Kind {
+  case shimast.KindArrowFunction, shimast.KindFunctionExpression:
+    ctx.Report(node, "Calling `removeEventListener` with a fresh function reference removes nothing — store and reuse the handler.")
+  }
 }
 
 func init() {
-	Register(unicornNoInvalidRemoveEventListener{})
+  Register(unicornNoInvalidRemoveEventListener{})
 }