@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_unicorn_no_anonymous_default_export.go

@@ -24,51 +24,51 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoAnonymousDefaultExport struct{}
 
 func (unicornNoAnonymousDefaultExport) Name() string {
-	return "unicorn/no-anonymous-default-export"
+  return "unicorn/no-anonymous-default-export"
 }
 func (unicornNoAnonymousDefaultExport) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindExportAssignment,
-		shimast.KindFunctionDeclaration,
-		shimast.KindClassDeclaration,
-	}
+  return []shimast.Kind{
+    shimast.KindExportAssignment,
+    shimast.KindFunctionDeclaration,
+    shimast.KindClassDeclaration,
+  }
 }
 func (unicornNoAnonymousDefaultExport) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindExportAssignment:
-		assign := node.AsExportAssignment()
-		if assign == nil || assign.IsExportEquals || assign.Expression == nil {
-			return
-		}
-		expr := stripParens(assign.Expression)
-		if expr == nil {
-			return
-		}
-		switch expr.Kind {
-		case shimast.KindFunctionExpression:
-			if fn := expr.AsFunctionExpression(); fn != nil && fn.Name() == nil {
-				ctx.Report(node, "Give a name to the default export.")
-			}
-		case shimast.KindArrowFunction:
-			// Arrow functions never bind a name; an `export default` of
-			// one is always anonymous.
-			ctx.Report(node, "Give a name to the default export.")
-		case shimast.KindClassExpression:
-			if cls := expr.AsClassExpression(); cls != nil && cls.Name() == nil {
-				ctx.Report(node, "Give a name to the default export.")
-			}
-		}
-	case shimast.KindFunctionDeclaration, shimast.KindClassDeclaration:
-		if !hasModifier(node, shimast.KindExportKeyword) ||
-			!hasModifier(node, shimast.KindDefaultKeyword) {
-			return
-		}
-		if node.Name() == nil {
-			ctx.Report(node, "Give a name to the default export.")
-		}
-	}
+  switch node.Kind {
+  case shimast.KindExportAssignment:
+    assign := node.AsExportAssignment()
+    if assign == nil || assign.IsExportEquals || assign.Expression == nil {
+      return
+    }
+    expr := stripParens(assign.Expression)
+    if expr == nil {
+      return
+    }
+    switch expr.Kind {
+    case shimast.KindFunctionExpression:
+      if fn := expr.AsFunctionExpression(); fn != nil && fn.Name() == nil {
+        ctx.Report(node, "Give a name to the default export.")
+      }
+    case shimast.KindArrowFunction:
+      // Arrow functions never bind a name; an `export default` of
+      // one is always anonymous.
+      ctx.Report(node, "Give a name to the default export.")
+    case shimast.KindClassExpression:
+      if cls := expr.AsClassExpression(); cls != nil && cls.Name() == nil {
+        ctx.Report(node, "Give a name to the default export.")
+      }
+    }
+  case shimast.KindFunctionDeclaration, shimast.KindClassDeclaration:
+    if !hasModifier(node, shimast.KindExportKeyword) ||
+      !hasModifier(node, shimast.KindDefaultKeyword) {
+      return
+    }
+    if node.Name() == nil {
+      ctx.Report(node, "Give a name to the default export.")
+    }
+  }
 }
 
 func init() {
-	Register(unicornNoAnonymousDefaultExport{})
+  Register(unicornNoAnonymousDefaultExport{})
 }

package/linthost/rules_unicorn_no_array_callback_reference.go

@@ -17,49 +17,49 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornNoArrayCallbackReferenceMethods = map[string]struct{}{
-	"every":         {},
-	"filter":        {},
-	"find":          {},
-	"findIndex":     {},
-	"findLast":      {},
-	"findLastIndex": {},
-	"flatMap":       {},
-	"forEach":       {},
-	"map":           {},
-	"some":          {},
+  "every":         {},
+  "filter":        {},
+  "find":          {},
+  "findIndex":     {},
+  "findLast":      {},
+  "findLastIndex": {},
+  "flatMap":       {},
+  "forEach":       {},
+  "map":           {},
+  "some":          {},
 }
 
 type unicornNoArrayCallbackReference struct{}
 
 func (unicornNoArrayCallbackReference) Name() string {
-	return "unicorn/no-array-callback-reference"
+  return "unicorn/no-array-callback-reference"
 }
 func (unicornNoArrayCallbackReference) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoArrayCallbackReference) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	method := identifierText(access.Name())
-	if _, ok := unicornNoArrayCallbackReferenceMethods[method]; !ok {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
-		return
-	}
-	first := call.Arguments.Nodes[0]
-	if first == nil || first.Kind != shimast.KindIdentifier {
-		return
-	}
-	ctx.Report(first, "Don't pass a function reference directly to `Array#"+method+"` — wrap it in an arrow that takes only the value.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  method := identifierText(access.Name())
+  if _, ok := unicornNoArrayCallbackReferenceMethods[method]; !ok {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return
+  }
+  first := call.Arguments.Nodes[0]
+  if first == nil || first.Kind != shimast.KindIdentifier {
+    return
+  }
+  ctx.Report(first, "Don't pass a function reference directly to `Array#"+method+"` — wrap it in an arrow that takes only the value.")
 }
 
 func init() {
-	Register(unicornNoArrayCallbackReference{})
+  Register(unicornNoArrayCallbackReference{})
 }

package/linthost/rules_unicorn_no_array_for_each.go

@@ -18,23 +18,23 @@ type unicornNoArrayForEach struct{}
 
 func (unicornNoArrayForEach) Name() string { return "unicorn/no-array-for-each" }
 func (unicornNoArrayForEach) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoArrayForEach) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Name()) != "forEach" {
-		return
-	}
-	ctx.Report(node, "Use `for…of` instead of `.forEach(…)`.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "forEach" {
+    return
+  }
+  ctx.Report(node, "Use `for…of` instead of `.forEach(…)`.")
 }
 
 func init() {
-	Register(unicornNoArrayForEach{})
+  Register(unicornNoArrayForEach{})
 }

package/linthost/rules_unicorn_no_array_method_this_argument.go

@@ -17,45 +17,45 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornNoArrayMethodThisArgumentMethods = map[string]struct{}{
-	"every":         {},
-	"filter":        {},
-	"find":          {},
-	"findIndex":     {},
-	"findLast":      {},
-	"findLastIndex": {},
-	"flatMap":       {},
-	"forEach":       {},
-	"map":           {},
-	"some":          {},
+  "every":         {},
+  "filter":        {},
+  "find":          {},
+  "findIndex":     {},
+  "findLast":      {},
+  "findLastIndex": {},
+  "flatMap":       {},
+  "forEach":       {},
+  "map":           {},
+  "some":          {},
 }
 
 type unicornNoArrayMethodThisArgument struct{}
 
 func (unicornNoArrayMethodThisArgument) Name() string {
-	return "unicorn/no-array-method-this-argument"
+  return "unicorn/no-array-method-this-argument"
 }
 func (unicornNoArrayMethodThisArgument) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoArrayMethodThisArgument) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	method := identifierText(access.Name())
-	if _, ok := unicornNoArrayMethodThisArgumentMethods[method]; !ok {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
-		return
-	}
-	ctx.Report(node, "Don't use `thisArg` on `Array#"+method+"` — use an explicit closure that captures the value instead.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  method := identifierText(access.Name())
+  if _, ok := unicornNoArrayMethodThisArgumentMethods[method]; !ok {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+    return
+  }
+  ctx.Report(node, "Don't use `thisArg` on `Array#"+method+"` — use an explicit closure that captures the value instead.")
 }
 
 func init() {
-	Register(unicornNoArrayMethodThisArgument{})
+  Register(unicornNoArrayMethodThisArgument{})
 }

package/linthost/rules_unicorn_no_array_reduce.go

@@ -18,24 +18,24 @@ type unicornNoArrayReduce struct{}
 
 func (unicornNoArrayReduce) Name() string { return "unicorn/no-array-reduce" }
 func (unicornNoArrayReduce) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoArrayReduce) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	method := identifierText(access.Name())
-	if method != "reduce" && method != "reduceRight" {
-		return
-	}
-	ctx.Report(node, "Avoid `Array#"+method+"()` — use an explicit loop or `for…of` instead.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  method := identifierText(access.Name())
+  if method != "reduce" && method != "reduceRight" {
+    return
+  }
+  ctx.Report(node, "Avoid `Array#"+method+"()` — use an explicit loop or `for…of` instead.")
 }
 
 func init() {
-	Register(unicornNoArrayReduce{})
+  Register(unicornNoArrayReduce{})
 }

package/linthost/rules_unicorn_no_array_reverse.go

@@ -19,26 +19,26 @@ type unicornNoArrayReverse struct{}
 
 func (unicornNoArrayReverse) Name() string { return "unicorn/no-array-reverse" }
 func (unicornNoArrayReverse) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoArrayReverse) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Name()) != "reverse" {
-		return
-	}
-	if call.Arguments != nil && len(call.Arguments.Nodes) != 0 {
-		return
-	}
-	ctx.Report(node, "Prefer `Array#toReversed()` over the mutating `Array#reverse()`.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "reverse" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) != 0 {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#toReversed()` over the mutating `Array#reverse()`.")
 }
 
 func init() {
-	Register(unicornNoArrayReverse{})
+  Register(unicornNoArrayReverse{})
 }

package/linthost/rules_unicorn_no_array_sort.go

@@ -18,26 +18,26 @@ type unicornNoArraySort struct{}
 
 func (unicornNoArraySort) Name() string { return "unicorn/no-array-sort" }
 func (unicornNoArraySort) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoArraySort) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Name()) != "sort" {
-		return
-	}
-	if call.Arguments != nil && len(call.Arguments.Nodes) > 1 {
-		return
-	}
-	ctx.Report(node, "Prefer `Array#toSorted()` over the mutating `Array#sort()`.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "sort" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 1 {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#toSorted()` over the mutating `Array#sort()`.")
 }
 
 func init() {
-	Register(unicornNoArraySort{})
+  Register(unicornNoArraySort{})
 }

package/linthost/rules_unicorn_no_await_expression_member.go

@@ -18,23 +18,23 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoAwaitExpressionMember struct{}
 
 func (unicornNoAwaitExpressionMember) Name() string {
-	return "unicorn/no-await-expression-member"
+  return "unicorn/no-await-expression-member"
 }
 func (unicornNoAwaitExpressionMember) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
 }
 func (unicornNoAwaitExpressionMember) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	receiver := stripParens(access.Expression)
-	if receiver == nil || receiver.Kind != shimast.KindAwaitExpression {
-		return
-	}
-	ctx.Report(node, "Don't use member access on an `await` expression — assign the awaited value to a variable first.")
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindAwaitExpression {
+    return
+  }
+  ctx.Report(node, "Don't use member access on an `await` expression — assign the awaited value to a variable first.")
 }
 
 func init() {
-	Register(unicornNoAwaitExpressionMember{})
+  Register(unicornNoAwaitExpressionMember{})
 }

package/linthost/rules_unicorn_no_await_in_promise_methods.go

@@ -16,54 +16,54 @@ package linthost
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 var unicornNoAwaitInPromiseMethodsMethods = map[string]struct{}{
-	"all":        {},
-	"allSettled": {},
-	"race":       {},
-	"any":        {},
+  "all":        {},
+  "allSettled": {},
+  "race":       {},
+  "any":        {},
 }
 
 type unicornNoAwaitInPromiseMethods struct{}
 
 func (unicornNoAwaitInPromiseMethods) Name() string {
-	return "unicorn/no-await-in-promise-methods"
+  return "unicorn/no-await-in-promise-methods"
 }
 func (unicornNoAwaitInPromiseMethods) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoAwaitInPromiseMethods) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Expression) != "Promise" {
-		return
-	}
-	method := identifierText(access.Name())
-	if _, ok := unicornNoAwaitInPromiseMethodsMethods[method]; !ok {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := call.Arguments.Nodes[0]
-	if arg == nil || arg.Kind != shimast.KindArrayLiteralExpression {
-		return
-	}
-	arr := arg.AsArrayLiteralExpression()
-	if arr == nil || arr.Elements == nil {
-		return
-	}
-	for _, elem := range arr.Elements.Nodes {
-		if elem != nil && elem.Kind == shimast.KindAwaitExpression {
-			ctx.Report(elem, "Don't `await` inside `Promise."+method+"` array members — the awaits serialize the calls.")
-		}
-	}
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Expression) != "Promise" {
+    return
+  }
+  method := identifierText(access.Name())
+  if _, ok := unicornNoAwaitInPromiseMethodsMethods[method]; !ok {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := call.Arguments.Nodes[0]
+  if arg == nil || arg.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  arr := arg.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil {
+    return
+  }
+  for _, elem := range arr.Elements.Nodes {
+    if elem != nil && elem.Kind == shimast.KindAwaitExpression {
+      ctx.Report(elem, "Don't `await` inside `Promise."+method+"` array members — the awaits serialize the calls.")
+    }
+  }
 }
 
 func init() {
-	Register(unicornNoAwaitInPromiseMethods{})
+  Register(unicornNoAwaitInPromiseMethods{})
 }

package/linthost/rules_unicorn_no_console_spaces.go

@@ -16,46 +16,46 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type unicornNoConsoleSpaces struct{}
 
 func (unicornNoConsoleSpaces) Name() string { return "unicorn/no-console-spaces" }
 func (unicornNoConsoleSpaces) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoConsoleSpaces) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil || identifierText(access.Expression) != "console" {
-		return
-	}
-	switch identifierText(access.Name()) {
-	case "log", "warn", "error", "info", "debug", "trace":
-	default:
-		return
-	}
-	if call.Arguments == nil {
-		return
-	}
-	for _, arg := range call.Arguments.Nodes {
-		if arg == nil || arg.Kind != shimast.KindStringLiteral {
-			continue
-		}
-		text := stringLiteralText(arg)
-		if strings.HasPrefix(text, " ") || strings.HasSuffix(text, " ") {
-			ctx.Report(arg, "Don't include leading or trailing spaces in `console.<method>` arguments.")
-		}
-	}
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Expression) != "console" {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "log", "warn", "error", "info", "debug", "trace":
+  default:
+    return
+  }
+  if call.Arguments == nil {
+    return
+  }
+  for _, arg := range call.Arguments.Nodes {
+    if arg == nil || arg.Kind != shimast.KindStringLiteral {
+      continue
+    }
+    text := stringLiteralText(arg)
+    if strings.HasPrefix(text, " ") || strings.HasSuffix(text, " ") {
+      ctx.Report(arg, "Don't include leading or trailing spaces in `console.<method>` arguments.")
+    }
+  }
 }
 
 func init() {
-	Register(unicornNoConsoleSpaces{})
+  Register(unicornNoConsoleSpaces{})
 }