@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_ts_prefer_readonly.go

@@ -21,37 +21,37 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type preferReadonly struct{}
 
 func (preferReadonly) Name() string { return "typescript/prefer-readonly" }
 func (preferReadonly) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyDeclaration}
+  return []shimast.Kind{shimast.KindPropertyDeclaration}
 }
 func (preferReadonly) Check(ctx *Context, node *shimast.Node) {
-	// Skip non-class-scoped properties; PropertyDeclaration also appears
-	// inside object literals in some grammars, but the readonly modifier
-	// is a class-only concern.
-	parent := node.Parent
-	if parent == nil ||
-		(parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
-		return
-	}
-	if hasModifier(node, shimast.KindReadonlyKeyword) {
-		return
-	}
-	if !preferReadonlyIsPrivate(node) {
-		return
-	}
-	decl := node.AsPropertyDeclaration()
-	if decl == nil || decl.Initializer == nil {
-		return
-	}
-	// Static fields are still candidates — `private static readonly` is
-	// the canonical form for class-scoped constants.
-	ctx.Report(node, "Private field is only initialized at declaration time — mark it `readonly`.")
+  // Skip non-class-scoped properties; PropertyDeclaration also appears
+  // inside object literals in some grammars, but the readonly modifier
+  // is a class-only concern.
+  parent := node.Parent
+  if parent == nil ||
+    (parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
+    return
+  }
+  if hasModifier(node, shimast.KindReadonlyKeyword) {
+    return
+  }
+  if !preferReadonlyIsPrivate(node) {
+    return
+  }
+  decl := node.AsPropertyDeclaration()
+  if decl == nil || decl.Initializer == nil {
+    return
+  }
+  // Static fields are still candidates — `private static readonly` is
+  // the canonical form for class-scoped constants.
+  ctx.Report(node, "Private field is only initialized at declaration time — mark it `readonly`.")
 }
 
 // preferReadonlyIsPrivate reports whether the property is private either
@@ -59,15 +59,15 @@ func (preferReadonly) Check(ctx *Context, node *shimast.Node) {
 // identifier form. Both make the field inaccessible from outside the
 // class, so `readonly` is a safe local refinement.
 func preferReadonlyIsPrivate(node *shimast.Node) bool {
-	if hasModifier(node, shimast.KindPrivateKeyword) {
-		return true
-	}
-	if name := node.Name(); name != nil && name.Kind == shimast.KindPrivateIdentifier {
-		return true
-	}
-	return false
+  if hasModifier(node, shimast.KindPrivateKeyword) {
+    return true
+  }
+  if name := node.Name(); name != nil && name.Kind == shimast.KindPrivateIdentifier {
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(preferReadonly{})
+  Register(preferReadonly{})
 }

package/linthost/rules_ts_prefer_reduce_type_parameter.go

@@ -15,65 +15,65 @@
 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 preferReduceTypeParameter struct{}
 
 func (preferReduceTypeParameter) Name() string {
-	return "typescript/prefer-reduce-type-parameter"
+  return "typescript/prefer-reduce-type-parameter"
 }
 func (preferReduceTypeParameter) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (preferReduceTypeParameter) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (preferReduceTypeParameter) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	// `arr.reduce<T>(...)` already pins the accumulator at the call
-	// site — the rule has nothing left to suggest.
-	if call.TypeArguments != nil && len(call.TypeArguments.Nodes) > 0 {
-		return
-	}
-	// The call must be `<receiver>.reduce(callback, initial)` — the
-	// two-argument form whose seed is the accumulator. The single-
-	// argument `arr.reduce(cb)` shape has no seed to assert against.
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
-		return
-	}
-	receiver, method, ok := promisePropertyAccessParts(call.Expression)
-	if !ok || method != "reduce" {
-		return
-	}
-	initial := stripParens(call.Arguments.Nodes[1])
-	if initial == nil {
-		return
-	}
-	// The initial value must carry an explicit type assertion that the
-	// rule can hoist into the call's type parameter list. Both the
-	// canonical `init as T` form and the legacy `<T>init` form qualify.
-	if initial.Kind != shimast.KindAsExpression && initial.Kind != shimast.KindTypeAssertionExpression {
-		return
-	}
-	if receiver == nil {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(receiver)
-	if t == nil {
-		return
-	}
-	if !preferReduceIsArrayOrTuple(ctx.Checker, t) {
-		return
-	}
-	ctx.Report(initial, preferReduceMessage)
+  if ctx.Checker == nil {
+    return
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  // `arr.reduce<T>(...)` already pins the accumulator at the call
+  // site — the rule has nothing left to suggest.
+  if call.TypeArguments != nil && len(call.TypeArguments.Nodes) > 0 {
+    return
+  }
+  // The call must be `<receiver>.reduce(callback, initial)` — the
+  // two-argument form whose seed is the accumulator. The single-
+  // argument `arr.reduce(cb)` shape has no seed to assert against.
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
+    return
+  }
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if !ok || method != "reduce" {
+    return
+  }
+  initial := stripParens(call.Arguments.Nodes[1])
+  if initial == nil {
+    return
+  }
+  // The initial value must carry an explicit type assertion that the
+  // rule can hoist into the call's type parameter list. Both the
+  // canonical `init as T` form and the legacy `<T>init` form qualify.
+  if initial.Kind != shimast.KindAsExpression && initial.Kind != shimast.KindTypeAssertionExpression {
+    return
+  }
+  if receiver == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(receiver)
+  if t == nil {
+    return
+  }
+  if !preferReduceIsArrayOrTuple(ctx.Checker, t) {
+    return
+  }
+  ctx.Report(initial, preferReduceMessage)
 }
 
 const preferReduceMessage = "Pass the accumulator type to `reduce` as a type parameter — `arr.reduce<T>(cb, init)` — instead of asserting on the initial value."
@@ -84,33 +84,33 @@ const preferReduceMessage = "Pass the accumulator type to `reduce` as a type par
 // intentionally fail closed so the rule does not blow up on generic
 // helpers whose receiver type leaks downward.
 func preferReduceIsArrayOrTuple(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 !preferReduceIsArrayOrTuple(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 !preferReduceIsArrayOrTuple(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(preferReduceTypeParameter{})
+  Register(preferReduceTypeParameter{})
 }

package/linthost/rules_ts_prefer_regexp_exec.go

@@ -19,53 +19,53 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	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 preferRegexpExec struct{}
 
 func (preferRegexpExec) Name() string { return "typescript/prefer-regexp-exec" }
 func (preferRegexpExec) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (preferRegexpExec) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (preferRegexpExec) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	receiver, method, ok := promisePropertyAccessParts(call.Expression)
-	if !ok || method != "match" {
-		return
-	}
-	if receiver == nil {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := stripParens(call.Arguments.Nodes[0])
-	if arg == nil || arg.Kind != shimast.KindRegularExpressionLiteral {
-		return
-	}
-	// Skip when the regex literal carries the `g` flag — `String#match`
-	// returns every match in that mode, which `RegExp#exec` cannot
-	// replicate in a single call.
-	if preferRegexpExecHasGlobalFlag(ctx.File, arg) {
-		return
-	}
-	if !preferRegexpExecIsString(ctx.Checker.GetTypeAtLocation(receiver)) {
-		return
-	}
-	ctx.Report(node, preferRegexpExecMessage)
+  if ctx.Checker == nil {
+    return
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if !ok || method != "match" {
+    return
+  }
+  if receiver == nil {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindRegularExpressionLiteral {
+    return
+  }
+  // Skip when the regex literal carries the `g` flag — `String#match`
+  // returns every match in that mode, which `RegExp#exec` cannot
+  // replicate in a single call.
+  if preferRegexpExecHasGlobalFlag(ctx.File, arg) {
+    return
+  }
+  if !preferRegexpExecIsString(ctx.Checker.GetTypeAtLocation(receiver)) {
+    return
+  }
+  ctx.Report(node, preferRegexpExecMessage)
 }
 
 const preferRegexpExecMessage = "Prefer `RegExp#exec(str)` over `String#match(re)` when the regex has no `g` flag — `exec` returns the same first-match shape and avoids the `g`-flag fallthrough that silently changes the return type of `match`."
@@ -76,16 +76,16 @@ const preferRegexpExecMessage = "Prefer `RegExp#exec(str)` over `String#match(re
 // already validated the token, so a textual scan of the trailing
 // suffix is sufficient.
 func preferRegexpExecHasGlobalFlag(file *shimast.SourceFile, node *shimast.Node) bool {
-	raw := nodeText(file, node)
-	if len(raw) < 2 || raw[0] != '/' {
-		return false
-	}
-	closing := strings.LastIndexByte(raw, '/')
-	if closing <= 0 {
-		return false
-	}
-	flags := raw[closing+1:]
-	return strings.Contains(flags, "g")
+  raw := nodeText(file, node)
+  if len(raw) < 2 || raw[0] != '/' {
+    return false
+  }
+  closing := strings.LastIndexByte(raw, '/')
+  if closing <= 0 {
+    return false
+  }
+  flags := raw[closing+1:]
+  return strings.Contains(flags, "g")
 }
 
 // preferRegexpExecIsString reports whether t is provably string-like.
@@ -93,30 +93,30 @@ func preferRegexpExecHasGlobalFlag(file *shimast.SourceFile, node *shimast.Node)
 // `never` are rejected so generic helpers don't fire. Union and
 // intersection types must have every constituent string-like.
 func preferRegexpExecIsString(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
-		return false
-	}
-	if flags&shimchecker.TypeFlagsStringLike != 0 {
-		return true
-	}
-	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			if !preferRegexpExecIsString(part) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return false
+  }
+  if flags&shimchecker.TypeFlagsStringLike != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if !preferRegexpExecIsString(part) {
+        return false
+      }
+    }
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(preferRegexpExec{})
+  Register(preferRegexpExec{})
 }

package/linthost/rules_ts_prefer_return_this_type.go

@@ -26,68 +26,68 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type preferReturnThisType struct{}
 
 func (preferReturnThisType) Name() string { return "typescript/prefer-return-this-type" }
 func (preferReturnThisType) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (preferReturnThisType) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindMethodDeclaration}
+  return []shimast.Kind{shimast.KindMethodDeclaration}
 }
 func (preferReturnThisType) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	decl := node.AsMethodDeclaration()
-	if decl == nil || decl.Body == nil {
-		return
-	}
-	// Skip async / generator methods — their return shape is wrapped
-	// (`Promise<...>` / `Generator<...>`) and not directly `this`.
-	if hasAsyncModifier(node) {
-		return
-	}
-	if decl.AsteriskToken != nil {
-		return
-	}
-	// Skip static methods — the upstream rule targets instance-method
-	// chains where the receiver type is the subclass; static dispatch
-	// uses the class itself and `this` rewriting changes nothing.
-	if hasModifier(node, shimast.KindStaticKeyword) {
-		return
-	}
-	// The method must have an explicit return-type annotation that is
-	// NOT already `this`. The rewrite-target is the existing annotation;
-	// without one, adding `this` would force a new annotation that the
-	// upstream rule does not propose.
-	if decl.Type == nil {
-		return
-	}
-	if decl.Type.Kind == shimast.KindThisType {
-		return
-	}
-	// The enclosing class must exist — the rule applies to instance
-	// methods of class declarations / expressions only.
-	parent := node.Parent
-	if parent == nil {
-		return
-	}
-	if parent.Kind != shimast.KindClassDeclaration &&
-		parent.Kind != shimast.KindClassExpression {
-		return
-	}
-	// Walk the method body. Every value-returning `return` must
-	// return exactly `this`; we also require at least one return
-	// statement so we don't fire on methods that fall off the end.
-	hasValueReturn, allAreThis := preferReturnThisTypeAnalyzeBody(decl.Body)
-	if !hasValueReturn || !allAreThis {
-		return
-	}
-	ctx.Report(decl.Type, preferReturnThisTypeMessage)
+  if ctx.Checker == nil {
+    return
+  }
+  decl := node.AsMethodDeclaration()
+  if decl == nil || decl.Body == nil {
+    return
+  }
+  // Skip async / generator methods — their return shape is wrapped
+  // (`Promise<...>` / `Generator<...>`) and not directly `this`.
+  if hasAsyncModifier(node) {
+    return
+  }
+  if decl.AsteriskToken != nil {
+    return
+  }
+  // Skip static methods — the upstream rule targets instance-method
+  // chains where the receiver type is the subclass; static dispatch
+  // uses the class itself and `this` rewriting changes nothing.
+  if hasModifier(node, shimast.KindStaticKeyword) {
+    return
+  }
+  // The method must have an explicit return-type annotation that is
+  // NOT already `this`. The rewrite-target is the existing annotation;
+  // without one, adding `this` would force a new annotation that the
+  // upstream rule does not propose.
+  if decl.Type == nil {
+    return
+  }
+  if decl.Type.Kind == shimast.KindThisType {
+    return
+  }
+  // The enclosing class must exist — the rule applies to instance
+  // methods of class declarations / expressions only.
+  parent := node.Parent
+  if parent == nil {
+    return
+  }
+  if parent.Kind != shimast.KindClassDeclaration &&
+    parent.Kind != shimast.KindClassExpression {
+    return
+  }
+  // Walk the method body. Every value-returning `return` must
+  // return exactly `this`; we also require at least one return
+  // statement so we don't fire on methods that fall off the end.
+  hasValueReturn, allAreThis := preferReturnThisTypeAnalyzeBody(decl.Body)
+  if !hasValueReturn || !allAreThis {
+    return
+  }
+  ctx.Report(decl.Type, preferReturnThisTypeMessage)
 }
 
 const preferReturnThisTypeMessage = "Method always returns `this` — declare the return type as `this` so subclass call sites keep the narrower receiver type."
@@ -102,34 +102,34 @@ const preferReturnThisTypeMessage = "Method always returns `this` — declare th
 // cannot rewrite to `this` regardless. The conservative interpretation
 // matches the upstream rule's behavior.
 func preferReturnThisTypeAnalyzeBody(body *shimast.Node) (hasValueReturn, allAreThis bool) {
-	allAreThis = true
-	var walk func(*shimast.Node)
-	walk = func(n *shimast.Node) {
-		if n == nil {
-			return
-		}
-		if n != body && isFunctionLikeKind(n) {
-			return
-		}
-		if n.Kind == shimast.KindReturnStatement {
-			ret := n.AsReturnStatement()
-			if ret != nil && ret.Expression != nil {
-				hasValueReturn = true
-				inner := stripParens(ret.Expression)
-				if inner == nil || inner.Kind != shimast.KindThisKeyword {
-					allAreThis = false
-				}
-			}
-		}
-		n.ForEachChild(func(child *shimast.Node) bool {
-			walk(child)
-			return false
-		})
-	}
-	walk(body)
-	return hasValueReturn, allAreThis
+  allAreThis = true
+  var walk func(*shimast.Node)
+  walk = func(n *shimast.Node) {
+    if n == nil {
+      return
+    }
+    if n != body && isFunctionLikeKind(n) {
+      return
+    }
+    if n.Kind == shimast.KindReturnStatement {
+      ret := n.AsReturnStatement()
+      if ret != nil && ret.Expression != nil {
+        hasValueReturn = true
+        inner := stripParens(ret.Expression)
+        if inner == nil || inner.Kind != shimast.KindThisKeyword {
+          allAreThis = false
+        }
+      }
+    }
+    n.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(body)
+  return hasValueReturn, allAreThis
 }
 
 func init() {
-	Register(preferReturnThisType{})
+  Register(preferReturnThisType{})
 }