@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_ts_no_unsafe_enum_comparison.go

@@ -24,43 +24,43 @@
 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 noUnsafeEnumComparison struct{}
 
 func (noUnsafeEnumComparison) Name() string { return "typescript/no-unsafe-enum-comparison" }
 func (noUnsafeEnumComparison) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnsafeEnumComparison) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (noUnsafeEnumComparison) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	bin := node.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
-		return
-	}
-	switch bin.OperatorToken.Kind {
-	case shimast.KindEqualsEqualsToken,
-		shimast.KindEqualsEqualsEqualsToken,
-		shimast.KindExclamationEqualsToken,
-		shimast.KindExclamationEqualsEqualsToken:
-	default:
-		return
-	}
-	left := ctx.Checker.GetTypeAtLocation(bin.Left)
-	right := ctx.Checker.GetTypeAtLocation(bin.Right)
-	if left == nil || right == nil {
-		return
-	}
-	if noUnsafeEnumComparisonMismatch(left, right) || noUnsafeEnumComparisonMismatch(right, left) {
-		ctx.Report(node, "Unsafe comparison between an enum-typed value and a plain primitive of the same widened type. Compare against one of the enum's own members so a typo surfaces at compile time.")
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsToken,
+    shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken:
+  default:
+    return
+  }
+  left := ctx.Checker.GetTypeAtLocation(bin.Left)
+  right := ctx.Checker.GetTypeAtLocation(bin.Right)
+  if left == nil || right == nil {
+    return
+  }
+  if noUnsafeEnumComparisonMismatch(left, right) || noUnsafeEnumComparisonMismatch(right, left) {
+    ctx.Report(node, "Unsafe comparison between an enum-typed value and a plain primitive of the same widened type. Compare against one of the enum's own members so a typo surfaces at compile time.")
+  }
 }
 
 // noUnsafeEnumComparisonMismatch reports whether `enumSide` carries an
@@ -69,29 +69,29 @@ func (noUnsafeEnumComparison) Check(ctx *Context, node *shimast.Node) {
 // still counts as the enum side, and the comparison `color === "red"`
 // is still unsafe even when `color` carries an extra nullish branch.
 func noUnsafeEnumComparisonMismatch(enumSide, otherSide *shimchecker.Type) bool {
-	if !noUnsafeEnumComparisonHasEnum(enumSide) {
-		return false
-	}
-	// `any` / `unknown` / `never` on the other side silently propagate
-	// from generic helpers — flagging them would explode false positives
-	// the same way `restrict-template-expressions` mitigates with its
-	// `allowAny` default.
-	if noUnsafeEnumComparisonIsLoose(otherSide) {
-		return false
-	}
-	// If the other side is provably the same enum (or one of its
-	// members), the comparison is the safe shape the rule recommends.
-	if noUnsafeEnumComparisonSharesEnum(enumSide, otherSide) {
-		return false
-	}
-	// The mismatch only fires when the non-enum side is the widened
-	// primitive that the enum widens to. A `Color === Status.Active`
-	// comparison (two unrelated enums of the same widened number) also
-	// trips this branch via the other call ordering.
-	if !noUnsafeEnumComparisonIsBareLiteralLike(otherSide) && !noUnsafeEnumComparisonHasEnum(otherSide) {
-		return false
-	}
-	return true
+  if !noUnsafeEnumComparisonHasEnum(enumSide) {
+    return false
+  }
+  // `any` / `unknown` / `never` on the other side silently propagate
+  // from generic helpers — flagging them would explode false positives
+  // the same way `restrict-template-expressions` mitigates with its
+  // `allowAny` default.
+  if noUnsafeEnumComparisonIsLoose(otherSide) {
+    return false
+  }
+  // If the other side is provably the same enum (or one of its
+  // members), the comparison is the safe shape the rule recommends.
+  if noUnsafeEnumComparisonSharesEnum(enumSide, otherSide) {
+    return false
+  }
+  // The mismatch only fires when the non-enum side is the widened
+  // primitive that the enum widens to. A `Color === Status.Active`
+  // comparison (two unrelated enums of the same widened number) also
+  // trips this branch via the other call ordering.
+  if !noUnsafeEnumComparisonIsBareLiteralLike(otherSide) && !noUnsafeEnumComparisonHasEnum(otherSide) {
+    return false
+  }
+  return true
 }
 
 // noUnsafeEnumComparisonHasEnum reports whether t (or any constituent of
@@ -99,21 +99,21 @@ func noUnsafeEnumComparisonMismatch(enumSide, otherSide *shimchecker.Type) bool
 // the enum union type produced by `enum E { ... }` and the canonical
 // `TypeFlagsEnumLiteral`-tagged literal types for each member.
 func noUnsafeEnumComparisonHasEnum(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&shimchecker.TypeFlagsEnumLike != 0 {
-		return true
-	}
-	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
-		for _, part := range t.Types() {
-			if noUnsafeEnumComparisonHasEnum(part) {
-				return true
-			}
-		}
-	}
-	return false
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsEnumLike != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    for _, part := range t.Types() {
+      if noUnsafeEnumComparisonHasEnum(part) {
+        return true
+      }
+    }
+  }
+  return false
 }
 
 // noUnsafeEnumComparisonIsLoose reports whether t propagates from a
@@ -121,10 +121,10 @@ func noUnsafeEnumComparisonHasEnum(t *shimchecker.Type) bool {
 // `never`. The upstream rule keeps these silent so type-erasure paths
 // (`JSON.parse`, untyped APIs) don't light up everywhere.
 func noUnsafeEnumComparisonIsLoose(t *shimchecker.Type) bool {
-	if t == nil {
-		return true
-	}
-	return t.Flags()&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0
+  if t == nil {
+    return true
+  }
+  return t.Flags()&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0
 }
 
 // noUnsafeEnumComparisonSharesEnum reports whether both sides refer to
@@ -134,12 +134,12 @@ func noUnsafeEnumComparisonIsLoose(t *shimchecker.Type) bool {
 // — comparing those addresses tells us whether `Color.Red` and
 // `Color.Blue` come from the same enum.
 func noUnsafeEnumComparisonSharesEnum(a, b *shimchecker.Type) bool {
-	aDecl := noUnsafeEnumComparisonEnumDeclaration(a)
-	bDecl := noUnsafeEnumComparisonEnumDeclaration(b)
-	if aDecl == nil || bDecl == nil {
-		return false
-	}
-	return aDecl == bDecl
+  aDecl := noUnsafeEnumComparisonEnumDeclaration(a)
+  bDecl := noUnsafeEnumComparisonEnumDeclaration(b)
+  if aDecl == nil || bDecl == nil {
+    return false
+  }
+  return aDecl == bDecl
 }
 
 // noUnsafeEnumComparisonEnumDeclaration returns the EnumDeclaration
@@ -148,48 +148,48 @@ func noUnsafeEnumComparisonSharesEnum(a, b *shimchecker.Type) bool {
 // enum-literal member carry the enum's symbol via Type.Symbol; the
 // symbol's parent declaration is the EnumDeclaration we identify by.
 func noUnsafeEnumComparisonEnumDeclaration(t *shimchecker.Type) *shimast.Node {
-	if t == nil {
-		return nil
-	}
-	flags := t.Flags()
-	if flags&shimchecker.TypeFlagsEnumLike != 0 {
-		sym := t.Symbol()
-		if sym == nil {
-			return nil
-		}
-		for _, decl := range sym.Declarations {
-			if decl == nil {
-				continue
-			}
-			if decl.Kind == shimast.KindEnumDeclaration {
-				return decl
-			}
-			// Enum member literal types carry the member symbol; walk
-			// one level up to land on the surrounding EnumDeclaration.
-			if decl.Parent != nil && decl.Parent.Kind == shimast.KindEnumDeclaration {
-				return decl.Parent
-			}
-		}
-		return nil
-	}
-	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
-		var seen *shimast.Node
-		for _, part := range t.Types() {
-			decl := noUnsafeEnumComparisonEnumDeclaration(part)
-			if decl == nil {
-				continue
-			}
-			if seen == nil {
-				seen = decl
-				continue
-			}
-			if seen != decl {
-				return nil
-			}
-		}
-		return seen
-	}
-	return nil
+  if t == nil {
+    return nil
+  }
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsEnumLike != 0 {
+    sym := t.Symbol()
+    if sym == nil {
+      return nil
+    }
+    for _, decl := range sym.Declarations {
+      if decl == nil {
+        continue
+      }
+      if decl.Kind == shimast.KindEnumDeclaration {
+        return decl
+      }
+      // Enum member literal types carry the member symbol; walk
+      // one level up to land on the surrounding EnumDeclaration.
+      if decl.Parent != nil && decl.Parent.Kind == shimast.KindEnumDeclaration {
+        return decl.Parent
+      }
+    }
+    return nil
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    var seen *shimast.Node
+    for _, part := range t.Types() {
+      decl := noUnsafeEnumComparisonEnumDeclaration(part)
+      if decl == nil {
+        continue
+      }
+      if seen == nil {
+        seen = decl
+        continue
+      }
+      if seen != decl {
+        return nil
+      }
+    }
+    return seen
+  }
+  return nil
 }
 
 // noUnsafeEnumComparisonIsBareLiteralLike reports whether t is a plain
@@ -199,37 +199,37 @@ func noUnsafeEnumComparisonEnumDeclaration(t *shimchecker.Type) *shimast.Node {
 // share an enum's primitive widening — `color === null` is a real
 // nullability check, not a same-primitive mistake.
 func noUnsafeEnumComparisonIsBareLiteralLike(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&shimchecker.TypeFlagsEnumLike != 0 {
-		return false
-	}
-	const primitiveMask = shimchecker.TypeFlagsStringLike |
-		shimchecker.TypeFlagsNumberLike |
-		shimchecker.TypeFlagsBigIntLike
-	if flags&primitiveMask != 0 {
-		return true
-	}
-	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
-		anyMatch := false
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			if noUnsafeEnumComparisonHasEnum(part) {
-				return false
-			}
-			if noUnsafeEnumComparisonIsBareLiteralLike(part) {
-				anyMatch = true
-			}
-		}
-		return anyMatch
-	}
-	return false
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsEnumLike != 0 {
+    return false
+  }
+  const primitiveMask = shimchecker.TypeFlagsStringLike |
+    shimchecker.TypeFlagsNumberLike |
+    shimchecker.TypeFlagsBigIntLike
+  if flags&primitiveMask != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    anyMatch := false
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if noUnsafeEnumComparisonHasEnum(part) {
+        return false
+      }
+      if noUnsafeEnumComparisonIsBareLiteralLike(part) {
+        anyMatch = true
+      }
+    }
+    return anyMatch
+  }
+  return false
 }
 
 func init() {
-	Register(noUnsafeEnumComparison{})
+  Register(noUnsafeEnumComparison{})
 }

package/linthost/rules_ts_no_unsafe_member_access.go

@@ -13,46 +13,46 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noUnsafeMemberAccess struct{}
 
 func (noUnsafeMemberAccess) Name() string { return "typescript/no-unsafe-member-access" }
 func (noUnsafeMemberAccess) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnsafeMemberAccess) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindPropertyAccessExpression,
-		shimast.KindElementAccessExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindPropertyAccessExpression,
+    shimast.KindElementAccessExpression,
+  }
 }
 func (noUnsafeMemberAccess) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	var receiver *shimast.Node
-	switch node.Kind {
-	case shimast.KindPropertyAccessExpression:
-		if access := node.AsPropertyAccessExpression(); access != nil {
-			receiver = access.Expression
-		}
-	case shimast.KindElementAccessExpression:
-		if access := node.AsElementAccessExpression(); access != nil {
-			receiver = access.Expression
-		}
-	}
-	if receiver == nil {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(receiver)
-	if !typeIsUnsafeAny(t) {
-		return
-	}
-	ctx.Report(node, "Unsafe member access on a value typed as `any`. Narrow the receiver to a concrete type before reading a property.")
+  if ctx.Checker == nil {
+    return
+  }
+  var receiver *shimast.Node
+  switch node.Kind {
+  case shimast.KindPropertyAccessExpression:
+    if access := node.AsPropertyAccessExpression(); access != nil {
+      receiver = access.Expression
+    }
+  case shimast.KindElementAccessExpression:
+    if access := node.AsElementAccessExpression(); access != nil {
+      receiver = access.Expression
+    }
+  }
+  if receiver == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(receiver)
+  if !typeIsUnsafeAny(t) {
+    return
+  }
+  ctx.Report(node, "Unsafe member access on a value typed as `any`. Narrow the receiver to a concrete type before reading a property.")
 }
 
 func init() {
-	Register(noUnsafeMemberAccess{})
+  Register(noUnsafeMemberAccess{})
 }

package/linthost/rules_ts_no_unsafe_return.go

@@ -22,50 +22,50 @@
 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 noUnsafeReturn struct{}
 
 func (noUnsafeReturn) Name() string { return "typescript/no-unsafe-return" }
 func (noUnsafeReturn) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnsafeReturn) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindReturnStatement}
+  return []shimast.Kind{shimast.KindReturnStatement}
 }
 func (noUnsafeReturn) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	ret := node.AsReturnStatement()
-	if ret == nil || ret.Expression == nil {
-		return
-	}
-	fn := noUnsafeReturnEnclosingFunction(node)
-	if fn == nil {
-		return
-	}
-	sig := ctx.Checker.GetSignatureFromDeclaration(fn)
-	if sig == nil {
-		return
-	}
-	declared := ctx.Checker.GetReturnTypeOfSignature(sig)
-	if declared == nil {
-		return
-	}
-	if !noUnsafeReturnIsConcrete(declared) {
-		return
-	}
-	exprType := ctx.Checker.GetTypeAtLocation(ret.Expression)
-	if exprType == nil {
-		return
-	}
-	if !noUnsafeReturnIsAny(exprType) {
-		return
-	}
-	ctx.Report(ret.Expression, "Unsafe return of `any` value from function with a concrete declared return type. The `any` leaks past the type boundary and disables downstream type checks.")
+  if ctx.Checker == nil {
+    return
+  }
+  ret := node.AsReturnStatement()
+  if ret == nil || ret.Expression == nil {
+    return
+  }
+  fn := noUnsafeReturnEnclosingFunction(node)
+  if fn == nil {
+    return
+  }
+  sig := ctx.Checker.GetSignatureFromDeclaration(fn)
+  if sig == nil {
+    return
+  }
+  declared := ctx.Checker.GetReturnTypeOfSignature(sig)
+  if declared == nil {
+    return
+  }
+  if !noUnsafeReturnIsConcrete(declared) {
+    return
+  }
+  exprType := ctx.Checker.GetTypeAtLocation(ret.Expression)
+  if exprType == nil {
+    return
+  }
+  if !noUnsafeReturnIsAny(exprType) {
+    return
+  }
+  ctx.Report(ret.Expression, "Unsafe return of `any` value from function with a concrete declared return type. The `any` leaks past the type boundary and disables downstream type checks.")
 }
 
 // noUnsafeReturnEnclosingFunction walks up the parent chain to the
@@ -74,12 +74,12 @@ func (noUnsafeReturn) Check(ctx *Context, node *shimast.Node) {
 // first function-like ancestor — mirroring the `consistent-return`
 // scope rule already established in this package.
 func noUnsafeReturnEnclosingFunction(node *shimast.Node) *shimast.Node {
-	for cur := node.Parent; cur != nil; cur = cur.Parent {
-		if isFunctionLikeKind(cur) {
-			return cur
-		}
-	}
-	return nil
+  for cur := node.Parent; cur != nil; cur = cur.Parent {
+    if isFunctionLikeKind(cur) {
+      return cur
+    }
+  }
+  return nil
 }
 
 // noUnsafeReturnIsConcrete reports whether the declared return type is
@@ -89,25 +89,25 @@ func noUnsafeReturnEnclosingFunction(node *shimast.Node) *shimast.Node {
 // `unknown` and side-effect functions that return `void` do not light
 // up everywhere. Unions are concrete only when every constituent is.
 func noUnsafeReturnIsConcrete(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsVoid) != 0 {
-		return false
-	}
-	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			if !noUnsafeReturnIsConcrete(part) {
-				return false
-			}
-		}
-		return true
-	}
-	return true
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsVoid) != 0 {
+    return false
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if !noUnsafeReturnIsConcrete(part) {
+        return false
+      }
+    }
+    return true
+  }
+  return true
 }
 
 // noUnsafeReturnIsAny reports whether t is the raw `any` type. The
@@ -115,12 +115,12 @@ func noUnsafeReturnIsConcrete(t *shimchecker.Type) bool {
 // returned as `unknown` cannot be used without further narrowing, so
 // they don't leak silently — and only flags the lossy `any` case.
 func noUnsafeReturnIsAny(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	return t.Flags()&shimchecker.TypeFlagsAny != 0
+  if t == nil {
+    return false
+  }
+  return t.Flags()&shimchecker.TypeFlagsAny != 0
 }
 
 func init() {
-	Register(noUnsafeReturn{})
+  Register(noUnsafeReturn{})
 }