@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_unicorn_no_process_exit.go

@@ -18,26 +18,26 @@ type unicornNoProcessExit struct{}
 
 func (unicornNoProcessExit) Name() string { return "unicorn/no-process-exit" }
 func (unicornNoProcessExit) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoProcessExit) 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) != "process" {
-		return
-	}
-	if identifierText(access.Name()) != "exit" {
-		return
-	}
-	ctx.Report(node, "Don't use `process.exit()`. Throw an error or return a non-zero status instead.")
+  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) != "process" {
+    return
+  }
+  if identifierText(access.Name()) != "exit" {
+    return
+  }
+  ctx.Report(node, "Don't use `process.exit()`. Throw an error or return a non-zero status instead.")
 }
 
 func init() {
-	Register(unicornNoProcessExit{})
+  Register(unicornNoProcessExit{})
 }

package/linthost/rules_unicorn_no_single_promise_in_promise_methods.go

@@ -20,40 +20,40 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoSinglePromiseInPromiseMethods struct{}
 
 func (unicornNoSinglePromiseInPromiseMethods) Name() string {
-	return "unicorn/no-single-promise-in-promise-methods"
+  return "unicorn/no-single-promise-in-promise-methods"
 }
 func (unicornNoSinglePromiseInPromiseMethods) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoSinglePromiseInPromiseMethods) 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) != "Promise" {
-		return
-	}
-	switch identifierText(access.Name()) {
-	case "all", "allSettled", "race", "any":
-	default:
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := stripParens(call.Arguments.Nodes[0])
-	if arg == nil || arg.Kind != shimast.KindArrayLiteralExpression {
-		return
-	}
-	arr := arg.AsArrayLiteralExpression()
-	if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
-		return
-	}
-	ctx.Report(node, "Don't wrap a single promise in `Promise.<method>([...])` — the wrapper is redundant.")
+  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) != "Promise" {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "all", "allSettled", "race", "any":
+  default:
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  arr := arg.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
+    return
+  }
+  ctx.Report(node, "Don't wrap a single promise in `Promise.<method>([...])` — the wrapper is redundant.")
 }
 
 func init() {
-	Register(unicornNoSinglePromiseInPromiseMethods{})
+  Register(unicornNoSinglePromiseInPromiseMethods{})
 }

package/linthost/rules_unicorn_no_static_only_class.go

@@ -21,36 +21,36 @@ type unicornNoStaticOnlyClass struct{}
 
 func (unicornNoStaticOnlyClass) Name() string { return "unicorn/no-static-only-class" }
 func (unicornNoStaticOnlyClass) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
+  return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
 }
 func (unicornNoStaticOnlyClass) Check(ctx *Context, node *shimast.Node) {
-	if classHasHeritage(node) {
-		return
-	}
-	members := classMembers(node)
-	if len(members) == 0 {
-		// Empty classes are out of scope — separate rule territory.
-		return
-	}
-	for _, member := range members {
-		if member == nil {
-			return
-		}
-		switch member.Kind {
-		case shimast.KindMethodDeclaration,
-			shimast.KindPropertyDeclaration,
-			shimast.KindGetAccessor,
-			shimast.KindSetAccessor:
-			if !hasModifier(member, shimast.KindStaticKeyword) {
-				return
-			}
-		default:
-			return
-		}
-	}
-	ctx.Report(node, "A class with only static members can be replaced by a plain object or module namespace.")
+  if classHasHeritage(node) {
+    return
+  }
+  members := classMembers(node)
+  if len(members) == 0 {
+    // Empty classes are out of scope — separate rule territory.
+    return
+  }
+  for _, member := range members {
+    if member == nil {
+      return
+    }
+    switch member.Kind {
+    case shimast.KindMethodDeclaration,
+      shimast.KindPropertyDeclaration,
+      shimast.KindGetAccessor,
+      shimast.KindSetAccessor:
+      if !hasModifier(member, shimast.KindStaticKeyword) {
+        return
+      }
+    default:
+      return
+    }
+  }
+  ctx.Report(node, "A class with only static members can be replaced by a plain object or module namespace.")
 }
 
 func init() {
-	Register(unicornNoStaticOnlyClass{})
+  Register(unicornNoStaticOnlyClass{})
 }

package/linthost/rules_unicorn_no_thenable.go

@@ -19,56 +19,56 @@ type unicornNoThenable struct{}
 
 func (unicornNoThenable) Name() string { return "unicorn/no-thenable" }
 func (unicornNoThenable) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindPropertyAssignment,
-		shimast.KindMethodDeclaration,
-		shimast.KindShorthandPropertyAssignment,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-	}
+  return []shimast.Kind{
+    shimast.KindPropertyAssignment,
+    shimast.KindMethodDeclaration,
+    shimast.KindShorthandPropertyAssignment,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+  }
 }
 func (unicornNoThenable) Check(ctx *Context, node *shimast.Node) {
-	var name *shimast.Node
-	switch node.Kind {
-	case shimast.KindPropertyAssignment:
-		if a := node.AsPropertyAssignment(); a != nil {
-			name = a.Name()
-		}
-	case shimast.KindMethodDeclaration:
-		if m := node.AsMethodDeclaration(); m != nil {
-			name = m.Name()
-		}
-	case shimast.KindShorthandPropertyAssignment:
-		if s := node.AsShorthandPropertyAssignment(); s != nil {
-			name = s.Name()
-		}
-	case shimast.KindGetAccessor:
-		if g := node.AsGetAccessorDeclaration(); g != nil {
-			name = g.Name()
-		}
-	case shimast.KindSetAccessor:
-		if s := node.AsSetAccessorDeclaration(); s != nil {
-			name = s.Name()
-		}
-	}
-	if name == nil {
-		return
-	}
-	switch name.Kind {
-	case shimast.KindIdentifier:
-		if identifierText(name) != "then" {
-			return
-		}
-	case shimast.KindStringLiteral:
-		if stringLiteralText(name) != "then" {
-			return
-		}
-	default:
-		return
-	}
-	ctx.Report(node, "Don't define a property named `then` — it makes the object accidentally thenable.")
+  var name *shimast.Node
+  switch node.Kind {
+  case shimast.KindPropertyAssignment:
+    if a := node.AsPropertyAssignment(); a != nil {
+      name = a.Name()
+    }
+  case shimast.KindMethodDeclaration:
+    if m := node.AsMethodDeclaration(); m != nil {
+      name = m.Name()
+    }
+  case shimast.KindShorthandPropertyAssignment:
+    if s := node.AsShorthandPropertyAssignment(); s != nil {
+      name = s.Name()
+    }
+  case shimast.KindGetAccessor:
+    if g := node.AsGetAccessorDeclaration(); g != nil {
+      name = g.Name()
+    }
+  case shimast.KindSetAccessor:
+    if s := node.AsSetAccessorDeclaration(); s != nil {
+      name = s.Name()
+    }
+  }
+  if name == nil {
+    return
+  }
+  switch name.Kind {
+  case shimast.KindIdentifier:
+    if identifierText(name) != "then" {
+      return
+    }
+  case shimast.KindStringLiteral:
+    if stringLiteralText(name) != "then" {
+      return
+    }
+  default:
+    return
+  }
+  ctx.Report(node, "Don't define a property named `then` — it makes the object accidentally thenable.")
 }
 
 func init() {
-	Register(unicornNoThenable{})
+  Register(unicornNoThenable{})
 }

package/linthost/rules_unicorn_no_this_assignment.go

@@ -17,19 +17,19 @@ type unicornNoThisAssignment struct{}
 
 func (unicornNoThisAssignment) Name() string { return "unicorn/no-this-assignment" }
 func (unicornNoThisAssignment) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindVariableDeclaration}
+  return []shimast.Kind{shimast.KindVariableDeclaration}
 }
 func (unicornNoThisAssignment) Check(ctx *Context, node *shimast.Node) {
-	decl := node.AsVariableDeclaration()
-	if decl == nil || decl.Initializer == nil {
-		return
-	}
-	if stripParens(decl.Initializer).Kind != shimast.KindThisKeyword {
-		return
-	}
-	ctx.Report(node, "Don't assign `this` to a variable — capture via an arrow function instead.")
+  decl := node.AsVariableDeclaration()
+  if decl == nil || decl.Initializer == nil {
+    return
+  }
+  if stripParens(decl.Initializer).Kind != shimast.KindThisKeyword {
+    return
+  }
+  ctx.Report(node, "Don't assign `this` to a variable — capture via an arrow function instead.")
 }
 
 func init() {
-	Register(unicornNoThisAssignment{})
+  Register(unicornNoThisAssignment{})
 }

package/linthost/rules_unicorn_no_typeof_undefined.go

@@ -19,40 +19,40 @@ type unicornNoTypeofUndefined struct{}
 
 func (unicornNoTypeofUndefined) Name() string { return "unicorn/no-typeof-undefined" }
 func (unicornNoTypeofUndefined) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (unicornNoTypeofUndefined) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	switch expr.OperatorToken.Kind {
-	case shimast.KindEqualsEqualsEqualsToken,
-		shimast.KindEqualsEqualsToken,
-		shimast.KindExclamationEqualsEqualsToken,
-		shimast.KindExclamationEqualsToken:
-	default:
-		return
-	}
-	left := stripParens(expr.Left)
-	right := stripParens(expr.Right)
-	if left == nil || right == nil {
-		return
-	}
-	var literal *shimast.Node
-	if left.Kind == shimast.KindTypeOfExpression {
-		literal = right
-	} else if right.Kind == shimast.KindTypeOfExpression {
-		literal = left
-	} else {
-		return
-	}
-	if stringLiteralText(literal) != "undefined" {
-		return
-	}
-	ctx.Report(node, "Compare with `undefined` directly instead of using `typeof`.")
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  switch expr.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindEqualsEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken:
+  default:
+    return
+  }
+  left := stripParens(expr.Left)
+  right := stripParens(expr.Right)
+  if left == nil || right == nil {
+    return
+  }
+  var literal *shimast.Node
+  if left.Kind == shimast.KindTypeOfExpression {
+    literal = right
+  } else if right.Kind == shimast.KindTypeOfExpression {
+    literal = left
+  } else {
+    return
+  }
+  if stringLiteralText(literal) != "undefined" {
+    return
+  }
+  ctx.Report(node, "Compare with `undefined` directly instead of using `typeof`.")
 }
 
 func init() {
-	Register(unicornNoTypeofUndefined{})
+  Register(unicornNoTypeofUndefined{})
 }

package/linthost/rules_unicorn_no_unnecessary_array_flat_depth.go

@@ -16,34 +16,34 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoUnnecessaryArrayFlatDepth struct{}
 
 func (unicornNoUnnecessaryArrayFlatDepth) Name() string {
-	return "unicorn/no-unnecessary-array-flat-depth"
+  return "unicorn/no-unnecessary-array-flat-depth"
 }
 func (unicornNoUnnecessaryArrayFlatDepth) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoUnnecessaryArrayFlatDepth) 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.Name()) != "flat" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := stripParens(call.Arguments.Nodes[0])
-	if arg == nil || arg.Kind != shimast.KindNumericLiteral {
-		return
-	}
-	if numericLiteralText(arg) != "1" {
-		return
-	}
-	ctx.Report(node, "`Array#flat()` already defaults to depth 1 — omit the argument.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "flat" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  if numericLiteralText(arg) != "1" {
+    return
+  }
+  ctx.Report(node, "`Array#flat()` already defaults to depth 1 — omit the argument.")
 }
 
 func init() {
-	Register(unicornNoUnnecessaryArrayFlatDepth{})
+  Register(unicornNoUnnecessaryArrayFlatDepth{})
 }

package/linthost/rules_unicorn_no_unnecessary_array_splice_count.go

@@ -17,54 +17,54 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoUnnecessaryArraySpliceCount struct{}
 
 func (unicornNoUnnecessaryArraySpliceCount) Name() string {
-	return "unicorn/no-unnecessary-array-splice-count"
+  return "unicorn/no-unnecessary-array-splice-count"
 }
 func (unicornNoUnnecessaryArraySpliceCount) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoUnnecessaryArraySpliceCount) 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 != "splice" && method != "toSpliced" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
-		return
-	}
-	second := stripParens(call.Arguments.Nodes[1])
-	if !unicornUnnecessaryCountArgument(second) {
-		return
-	}
-	ctx.Report(call.Arguments.Nodes[1], "Use `splice(start)` without the count — `.length` / `Infinity` is the default.")
+  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 != "splice" && method != "toSpliced" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
+    return
+  }
+  second := stripParens(call.Arguments.Nodes[1])
+  if !unicornUnnecessaryCountArgument(second) {
+    return
+  }
+  ctx.Report(call.Arguments.Nodes[1], "Use `splice(start)` without the count — `.length` / `Infinity` is the default.")
 }
 
 // unicornUnnecessaryCountArgument reports whether `node` is one of the
 // two redundant "until the end" shapes — a `.length` property access on
 // any receiver, or the bare `Infinity` identifier.
 func unicornUnnecessaryCountArgument(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	if node.Kind == shimast.KindPropertyAccessExpression {
-		access := node.AsPropertyAccessExpression()
-		if access == nil {
-			return false
-		}
-		return identifierText(access.Name()) == "length"
-	}
-	if node.Kind == shimast.KindIdentifier {
-		return identifierText(node) == "Infinity"
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindPropertyAccessExpression {
+    access := node.AsPropertyAccessExpression()
+    if access == nil {
+      return false
+    }
+    return identifierText(access.Name()) == "length"
+  }
+  if node.Kind == shimast.KindIdentifier {
+    return identifierText(node) == "Infinity"
+  }
+  return false
 }
 
 func init() {
-	Register(unicornNoUnnecessaryArraySpliceCount{})
+  Register(unicornNoUnnecessaryArraySpliceCount{})
 }

package/linthost/rules_unicorn_no_unnecessary_await.go

@@ -19,33 +19,33 @@ type unicornNoUnnecessaryAwait struct{}
 
 func (unicornNoUnnecessaryAwait) Name() string { return "unicorn/no-unnecessary-await" }
 func (unicornNoUnnecessaryAwait) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindAwaitExpression}
+  return []shimast.Kind{shimast.KindAwaitExpression}
 }
 func (unicornNoUnnecessaryAwait) Check(ctx *Context, node *shimast.Node) {
-	await := node.AsAwaitExpression()
-	if await == nil || await.Expression == nil {
-		return
-	}
-	operand := stripParens(await.Expression)
-	if operand == nil {
-		return
-	}
-	switch operand.Kind {
-	case shimast.KindStringLiteral,
-		shimast.KindNumericLiteral,
-		shimast.KindBigIntLiteral,
-		shimast.KindNoSubstitutionTemplateLiteral,
-		shimast.KindTemplateExpression,
-		shimast.KindRegularExpressionLiteral,
-		shimast.KindTrueKeyword,
-		shimast.KindFalseKeyword,
-		shimast.KindNullKeyword,
-		shimast.KindArrayLiteralExpression,
-		shimast.KindObjectLiteralExpression:
-		ctx.Report(node, "Don't `await` a non-thenable expression.")
-	}
+  await := node.AsAwaitExpression()
+  if await == nil || await.Expression == nil {
+    return
+  }
+  operand := stripParens(await.Expression)
+  if operand == nil {
+    return
+  }
+  switch operand.Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindTemplateExpression,
+    shimast.KindRegularExpressionLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindArrayLiteralExpression,
+    shimast.KindObjectLiteralExpression:
+    ctx.Report(node, "Don't `await` a non-thenable expression.")
+  }
 }
 
 func init() {
-	Register(unicornNoUnnecessaryAwait{})
+  Register(unicornNoUnnecessaryAwait{})
 }

package/linthost/rules_unicorn_no_unnecessary_slice_end.go

@@ -16,33 +16,33 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoUnnecessarySliceEnd struct{}
 
 func (unicornNoUnnecessarySliceEnd) Name() string {
-	return "unicorn/no-unnecessary-slice-end"
+  return "unicorn/no-unnecessary-slice-end"
 }
 func (unicornNoUnnecessarySliceEnd) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoUnnecessarySliceEnd) 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()) != "slice" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
-		return
-	}
-	second := stripParens(call.Arguments.Nodes[1])
-	if !unicornUnnecessaryCountArgument(second) {
-		return
-	}
-	ctx.Report(call.Arguments.Nodes[1], "Use `slice(start)` without the end — `.length` / `Infinity` is the default.")
+  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()) != "slice" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+    return
+  }
+  second := stripParens(call.Arguments.Nodes[1])
+  if !unicornUnnecessaryCountArgument(second) {
+    return
+  }
+  ctx.Report(call.Arguments.Nodes[1], "Use `slice(start)` without the end — `.length` / `Infinity` is the default.")
 }
 
 func init() {
-	Register(unicornNoUnnecessarySliceEnd{})
+  Register(unicornNoUnnecessarySliceEnd{})
 }