@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_ts_no_unsafe_unary_minus.go

@@ -15,35 +15,35 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
 )
 
 type noUnsafeUnaryMinus struct{}
 
 func (noUnsafeUnaryMinus) Name() string { return "typescript/no-unsafe-unary-minus" }
 func (noUnsafeUnaryMinus) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnsafeUnaryMinus) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPrefixUnaryExpression}
+  return []shimast.Kind{shimast.KindPrefixUnaryExpression}
 }
 func (noUnsafeUnaryMinus) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	expr := node.AsPrefixUnaryExpression()
-	if expr == nil || expr.Operator != shimast.KindMinusToken || expr.Operand == nil {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(expr.Operand)
-	if t == nil {
-		return
-	}
-	if noUnsafeUnaryMinusIsNumeric(t) {
-		return
-	}
-	ctx.Report(node, "Unary `-` requires a number-like or bigint-like operand. Other shapes are silently coerced via `Number(x)` and almost always indicate a bug.")
+  if ctx.Checker == nil {
+    return
+  }
+  expr := node.AsPrefixUnaryExpression()
+  if expr == nil || expr.Operator != shimast.KindMinusToken || expr.Operand == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(expr.Operand)
+  if t == nil {
+    return
+  }
+  if noUnsafeUnaryMinusIsNumeric(t) {
+    return
+  }
+  ctx.Report(node, "Unary `-` requires a number-like or bigint-like operand. Other shapes are silently coerced via `Number(x)` and almost always indicate a bug.")
 }
 
 // noUnsafeUnaryMinusIsNumeric reports whether t is provably number-like
@@ -52,30 +52,30 @@ func (noUnsafeUnaryMinus) Check(ctx *Context, node *shimast.Node) {
 // matching the upstream `allowAny` posture. Unions and intersections
 // must have every constituent numeric for the whole type to count.
 func noUnsafeUnaryMinusIsNumeric(t *shimchecker.Type) bool {
-	if t == nil {
-		return true
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
-		return true
-	}
-	if flags&(shimchecker.TypeFlagsNumberLike|shimchecker.TypeFlagsBigIntLike) != 0 {
-		return true
-	}
-	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			if !noUnsafeUnaryMinusIsNumeric(part) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
+  if t == nil {
+    return true
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsNumberLike|shimchecker.TypeFlagsBigIntLike) != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if !noUnsafeUnaryMinusIsNumeric(part) {
+        return false
+      }
+    }
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(noUnsafeUnaryMinus{})
+  Register(noUnsafeUnaryMinus{})
 }

package/linthost/rules_ts_no_useless_constructor.go

@@ -18,35 +18,35 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type tsNoUselessConstructor struct{}
 
 func (tsNoUselessConstructor) Name() string { return "typescript/no-useless-constructor" }
 func (tsNoUselessConstructor) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindConstructor}
+  return []shimast.Kind{shimast.KindConstructor}
 }
 func (tsNoUselessConstructor) Check(ctx *Context, node *shimast.Node) {
-	ctor := node.AsConstructorDeclaration()
-	if ctor == nil || ctor.Body == nil {
-		return
-	}
-	body := ctor.Body.AsBlock()
-	if body == nil || body.Statements == nil || len(body.Statements.Nodes) != 0 {
-		return
-	}
-	// Any parameter property keeps the constructor meaningful: the
-	// shorthand IS the field declaration. Removing the constructor
-	// would silently delete the field, so this is not "useless".
-	for _, param := range node.Parameters() {
-		if isParameterProperty(param) {
-			return
-		}
-	}
-	ctx.Report(node, "Useless constructor with no parameter properties.")
+  ctor := node.AsConstructorDeclaration()
+  if ctor == nil || ctor.Body == nil {
+    return
+  }
+  body := ctor.Body.AsBlock()
+  if body == nil || body.Statements == nil || len(body.Statements.Nodes) != 0 {
+    return
+  }
+  // Any parameter property keeps the constructor meaningful: the
+  // shorthand IS the field declaration. Removing the constructor
+  // would silently delete the field, so this is not "useless".
+  for _, param := range node.Parameters() {
+    if isParameterProperty(param) {
+      return
+    }
+  }
+  ctx.Report(node, "Useless constructor with no parameter properties.")
 }
 
 func init() {
-	Register(tsNoUselessConstructor{})
+  Register(tsNoUselessConstructor{})
 }

package/linthost/rules_ts_non_nullable_type_assertion_style.go

@@ -8,8 +8,8 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
 )
 
 // nonNullableTypeAssertionStyle reports `expr as T` where `T` equals the
@@ -32,77 +32,77 @@ import (
 type nonNullableTypeAssertionStyle struct{}
 
 func (nonNullableTypeAssertionStyle) Name() string {
-	return "typescript/non-nullable-type-assertion-style"
+  return "typescript/non-nullable-type-assertion-style"
 }
 func (nonNullableTypeAssertionStyle) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (nonNullableTypeAssertionStyle) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindAsExpression}
+  return []shimast.Kind{shimast.KindAsExpression}
 }
 func (nonNullableTypeAssertionStyle) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	as := node.AsAsExpression()
-	if as == nil || as.Expression == nil || as.Type == nil {
-		return
-	}
-	sourceType := ctx.Checker.GetTypeAtLocation(as.Expression)
-	if sourceType == nil {
-		return
-	}
-	// Only consider expressions whose static type actually carries
-	// `null` or `undefined`; otherwise `x!` is not the same as `x as T`.
-	if !nonNullableTypeAssertionStyleIsNullable(sourceType) {
-		return
-	}
-	nonNullable := ctx.Checker.GetNonNullableType(sourceType)
-	if nonNullable == nil {
-		return
-	}
-	assertedType := ctx.Checker.GetTypeFromTypeNode(as.Type)
-	if assertedType == nil {
-		return
-	}
-	// Bidirectional assignability stands in for type identity: the
-	// stripped source type must coincide with the asserted type up to
-	// structural equivalence. Both sides have to hold so that
-	// `x as SomeSupertype` or `x as SomeSubtype` does not get rewritten
-	// to `x!` and silently lose information.
-	if !ctx.Checker.IsTypeAssignableTo(nonNullable, assertedType) {
-		return
-	}
-	if !ctx.Checker.IsTypeAssignableTo(assertedType, nonNullable) {
-		return
-	}
-	ctx.Report(node, "Use a `!` assertion to more succinctly remove `null` and `undefined` from the type.")
+  if ctx.Checker == nil {
+    return
+  }
+  as := node.AsAsExpression()
+  if as == nil || as.Expression == nil || as.Type == nil {
+    return
+  }
+  sourceType := ctx.Checker.GetTypeAtLocation(as.Expression)
+  if sourceType == nil {
+    return
+  }
+  // Only consider expressions whose static type actually carries
+  // `null` or `undefined`; otherwise `x!` is not the same as `x as T`.
+  if !nonNullableTypeAssertionStyleIsNullable(sourceType) {
+    return
+  }
+  nonNullable := ctx.Checker.GetNonNullableType(sourceType)
+  if nonNullable == nil {
+    return
+  }
+  assertedType := ctx.Checker.GetTypeFromTypeNode(as.Type)
+  if assertedType == nil {
+    return
+  }
+  // Bidirectional assignability stands in for type identity: the
+  // stripped source type must coincide with the asserted type up to
+  // structural equivalence. Both sides have to hold so that
+  // `x as SomeSupertype` or `x as SomeSubtype` does not get rewritten
+  // to `x!` and silently lose information.
+  if !ctx.Checker.IsTypeAssignableTo(nonNullable, assertedType) {
+    return
+  }
+  if !ctx.Checker.IsTypeAssignableTo(assertedType, nonNullable) {
+    return
+  }
+  ctx.Report(node, "Use a `!` assertion to more succinctly remove `null` and `undefined` from the type.")
 }
 
 // nonNullableTypeAssertionStyleIsNullable reports whether t carries
 // `null` or `undefined` either at the top level (for direct
 // `T | null` / `T | undefined` shapes) or inside a union constituent.
 func nonNullableTypeAssertionStyleIsNullable(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsNull|shimchecker.TypeFlagsUndefined) != 0 {
-		return true
-	}
-	if flags&shimchecker.TypeFlagsUnion != 0 {
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			if nonNullableTypeAssertionStyleIsNullable(part) {
-				return true
-			}
-		}
-	}
-	return false
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsNull|shimchecker.TypeFlagsUndefined) != 0 {
+    return true
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if nonNullableTypeAssertionStyleIsNullable(part) {
+        return true
+      }
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(nonNullableTypeAssertionStyle{})
+  Register(nonNullableTypeAssertionStyle{})
 }

package/linthost/rules_ts_parameter_properties.go

@@ -14,25 +14,25 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type parameterProperties struct{}
 
 func (parameterProperties) Name() string { return "typescript/parameter-properties" }
 func (parameterProperties) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindParameter}
+  return []shimast.Kind{shimast.KindParameter}
 }
 func (parameterProperties) Check(ctx *Context, node *shimast.Node) {
-	if node == nil || node.Parent == nil || node.Parent.Kind != shimast.KindConstructor {
-		return
-	}
-	if !isParameterProperty(node) {
-		return
-	}
-	ctx.Report(node, "Prefer a plain class field declaration over a constructor parameter property.")
+  if node == nil || node.Parent == nil || node.Parent.Kind != shimast.KindConstructor {
+    return
+  }
+  if !isParameterProperty(node) {
+    return
+  }
+  ctx.Report(node, "Prefer a plain class field declaration over a constructor parameter property.")
 }
 
 func init() {
-	Register(parameterProperties{})
+  Register(parameterProperties{})
 }

package/linthost/rules_ts_prefer_find.go

@@ -16,61 +16,61 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
 )
 
 type preferFind struct{}
 
 func (preferFind) Name() string { return "typescript/prefer-find" }
 func (preferFind) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (preferFind) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindElementAccessExpression,
-		shimast.KindCallExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindElementAccessExpression,
+    shimast.KindCallExpression,
+  }
 }
 func (preferFind) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindElementAccessExpression:
-		access := node.AsElementAccessExpression()
-		if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
-			return
-		}
-		// Index must be the literal `0`.
-		if !preferFindIsZeroLiteral(access.ArgumentExpression) {
-			return
-		}
-		if !preferFindIsArrayFilterCall(ctx, access.Expression) {
-			return
-		}
-		ctx.Report(node, preferFindMessage)
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil || call.Expression == nil {
-			return
-		}
-		// Match `<filter-call>.at(0)`.
-		receiver, method, ok := promisePropertyAccessParts(call.Expression)
-		if !ok || method != "at" {
-			return
-		}
-		if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-			return
-		}
-		if !preferFindIsZeroLiteral(call.Arguments.Nodes[0]) {
-			return
-		}
-		if !preferFindIsArrayFilterCall(ctx, receiver) {
-			return
-		}
-		ctx.Report(node, preferFindMessage)
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindElementAccessExpression:
+    access := node.AsElementAccessExpression()
+    if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
+      return
+    }
+    // Index must be the literal `0`.
+    if !preferFindIsZeroLiteral(access.ArgumentExpression) {
+      return
+    }
+    if !preferFindIsArrayFilterCall(ctx, access.Expression) {
+      return
+    }
+    ctx.Report(node, preferFindMessage)
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil || call.Expression == nil {
+      return
+    }
+    // Match `<filter-call>.at(0)`.
+    receiver, method, ok := promisePropertyAccessParts(call.Expression)
+    if !ok || method != "at" {
+      return
+    }
+    if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+      return
+    }
+    if !preferFindIsZeroLiteral(call.Arguments.Nodes[0]) {
+      return
+    }
+    if !preferFindIsArrayFilterCall(ctx, receiver) {
+      return
+    }
+    ctx.Report(node, preferFindMessage)
+  }
 }
 
 const preferFindMessage = "Prefer `.find(predicate)` over `.filter(predicate)[0]` / `.filter(predicate).at(0)` — `find` short-circuits on the first match and avoids materializing the full filtered array."
@@ -81,25 +81,25 @@ const preferFindMessage = "Prefer `.find(predicate)` over `.filter(predicate)[0]
 // is technically a separate value at the language level even though
 // `arr[-0]` resolves the same. Keeps the rule's noise floor narrow.
 func preferFindIsZeroLiteral(node *shimast.Node) bool {
-	node = stripParens(node)
-	if node == nil {
-		return false
-	}
-	if node.Kind == shimast.KindNumericLiteral {
-		return numericLiteralText(node) == "0"
-	}
-	if node.Kind == shimast.KindPrefixUnaryExpression {
-		prefix := node.AsPrefixUnaryExpression()
-		if prefix == nil || prefix.Operand == nil {
-			return false
-		}
-		if prefix.Operator != shimast.KindPlusToken {
-			return false
-		}
-		return prefix.Operand.Kind == shimast.KindNumericLiteral &&
-			numericLiteralText(prefix.Operand) == "0"
-	}
-	return false
+  node = stripParens(node)
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindNumericLiteral {
+    return numericLiteralText(node) == "0"
+  }
+  if node.Kind == shimast.KindPrefixUnaryExpression {
+    prefix := node.AsPrefixUnaryExpression()
+    if prefix == nil || prefix.Operand == nil {
+      return false
+    }
+    if prefix.Operator != shimast.KindPlusToken {
+      return false
+    }
+    return prefix.Operand.Kind == shimast.KindNumericLiteral &&
+      numericLiteralText(prefix.Operand) == "0"
+  }
+  return false
 }
 
 // preferFindIsArrayFilterCall reports whether `node` (after stripping
@@ -108,32 +108,32 @@ func preferFindIsZeroLiteral(node *shimast.Node) bool {
 // by `prefer-includes` for `.indexOf(x)`: a user type with a custom
 // `filter` method should NOT trigger the rule.
 func preferFindIsArrayFilterCall(ctx *Context, node *shimast.Node) bool {
-	node = stripParens(node)
-	if node == nil || node.Kind != shimast.KindCallExpression {
-		return false
-	}
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return false
-	}
-	receiver, method, ok := promisePropertyAccessParts(call.Expression)
-	if !ok || method != "filter" {
-		return false
-	}
-	if receiver == nil {
-		return false
-	}
-	// `.filter` accepts an optional `thisArg`, so require at least one
-	// argument (the predicate) — a zero-arg call would not parse on the
-	// real lib.es5 declaration and is conservatively skipped.
-	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
-		return false
-	}
-	t := ctx.Checker.GetTypeAtLocation(receiver)
-	if t == nil {
-		return false
-	}
-	return preferFindIsArrayLike(ctx.Checker, t)
+  node = stripParens(node)
+  if node == nil || node.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return false
+  }
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if !ok || method != "filter" {
+    return false
+  }
+  if receiver == nil {
+    return false
+  }
+  // `.filter` accepts an optional `thisArg`, so require at least one
+  // argument (the predicate) — a zero-arg call would not parse on the
+  // real lib.es5 declaration and is conservatively skipped.
+  if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return false
+  }
+  t := ctx.Checker.GetTypeAtLocation(receiver)
+  if t == nil {
+    return false
+  }
+  return preferFindIsArrayLike(ctx.Checker, t)
 }
 
 // preferFindIsArrayLike reports whether t is provably an array or
@@ -146,33 +146,33 @@ func preferFindIsArrayFilterCall(ctx *Context, node *shimast.Node) bool {
 // though they expose a `.filter`-shaped method via lib polyfills,
 // because the upstream rule only fires on the genuine `Array#filter`.
 func preferFindIsArrayLike(checker *shimchecker.Checker, t *shimchecker.Type) bool {
-	if checker == nil || t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
-		return false
-	}
-	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			if !preferFindIsArrayLike(checker, part) {
-				return false
-			}
-		}
-		return true
-	}
-	if shimchecker.Checker_isArrayType(checker, t) {
-		return true
-	}
-	if shimchecker.IsTupleType(t) {
-		return true
-	}
-	return false
+  if checker == nil || t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return false
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if !preferFindIsArrayLike(checker, part) {
+        return false
+      }
+    }
+    return true
+  }
+  if shimchecker.Checker_isArrayType(checker, t) {
+    return true
+  }
+  if shimchecker.IsTupleType(t) {
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(preferFind{})
+  Register(preferFind{})
 }