@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_ts_prefer_optional_chain.go

@@ -13,46 +13,46 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type preferOptionalChain struct{}
 
 func (preferOptionalChain) Name() string { return "typescript/prefer-optional-chain" }
 func (preferOptionalChain) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (preferOptionalChain) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if expr.OperatorToken.Kind != shimast.KindAmpersandAmpersandToken {
-		return
-	}
-	// Skip when the binary expression is itself the left side of an
-	// outer `&&` — the outer node will be visited and report the full
-	// chain. Reporting at every inner conjunct would flood `a && a.b
-	// && a.b.c` with two diagnostics on the same chain.
-	if parent := node.Parent; parent != nil && parent.Kind == shimast.KindBinaryExpression {
-		pe := parent.AsBinaryExpression()
-		if pe != nil && pe.OperatorToken != nil &&
-			pe.OperatorToken.Kind == shimast.KindAmpersandAmpersandToken &&
-			pe.Left == node {
-			return
-		}
-	}
-	guardText, ok := preferOptionalChainGuardText(ctx, expr.Left)
-	if !ok {
-		return
-	}
-	right := stripParens(expr.Right)
-	if !preferOptionalChainRightMatches(ctx, right, guardText) {
-		return
-	}
-	ctx.Report(node, "Prefer an optional chain (`a?.b`) over `a && a.b` — shorter and short-circuits to `undefined` instead of the leftmost falsy value.")
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindAmpersandAmpersandToken {
+    return
+  }
+  // Skip when the binary expression is itself the left side of an
+  // outer `&&` — the outer node will be visited and report the full
+  // chain. Reporting at every inner conjunct would flood `a && a.b
+  // && a.b.c` with two diagnostics on the same chain.
+  if parent := node.Parent; parent != nil && parent.Kind == shimast.KindBinaryExpression {
+    pe := parent.AsBinaryExpression()
+    if pe != nil && pe.OperatorToken != nil &&
+      pe.OperatorToken.Kind == shimast.KindAmpersandAmpersandToken &&
+      pe.Left == node {
+      return
+    }
+  }
+  guardText, ok := preferOptionalChainGuardText(ctx, expr.Left)
+  if !ok {
+    return
+  }
+  right := stripParens(expr.Right)
+  if !preferOptionalChainRightMatches(ctx, right, guardText) {
+    return
+  }
+  ctx.Report(node, "Prefer an optional chain (`a?.b`) over `a && a.b` — shorter and short-circuits to `undefined` instead of the leftmost falsy value.")
 }
 
 // preferOptionalChainRightmostConjunct returns the rightmost operand
@@ -60,17 +60,17 @@ func (preferOptionalChain) Check(ctx *Context, node *shimast.Node) {
 // rightmost conjunct of the left is `a.b`, which is the immediate
 // guard the outer `&&` was extending.
 func preferOptionalChainRightmostConjunct(node *shimast.Node) *shimast.Node {
-	node = stripParens(node)
-	for node != nil && node.Kind == shimast.KindBinaryExpression {
-		inner := node.AsBinaryExpression()
-		if inner == nil || inner.OperatorToken == nil ||
-			inner.OperatorToken.Kind != shimast.KindAmpersandAmpersandToken ||
-			inner.Right == nil {
-			return node
-		}
-		node = stripParens(inner.Right)
-	}
-	return node
+  node = stripParens(node)
+  for node != nil && node.Kind == shimast.KindBinaryExpression {
+    inner := node.AsBinaryExpression()
+    if inner == nil || inner.OperatorToken == nil ||
+      inner.OperatorToken.Kind != shimast.KindAmpersandAmpersandToken ||
+      inner.Right == nil {
+      return node
+    }
+    node = stripParens(inner.Right)
+  }
+  return node
 }
 
 // preferOptionalChainGuardText returns the textual identity of the
@@ -80,84 +80,84 @@ func preferOptionalChainRightmostConjunct(node *shimast.Node) *shimast.Node {
 // comparison form, the returned text is the non-null side, which is
 // what the right-hand access must start with.
 func preferOptionalChainGuardText(ctx *Context, left *shimast.Node) (string, bool) {
-	left = stripParens(left)
-	if left == nil {
-		return "", false
-	}
-	switch left.Kind {
-	case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
-		text := nodeText(ctx.File, left)
-		return text, text != ""
-	case shimast.KindBinaryExpression:
-		inner := left.AsBinaryExpression()
-		if inner == nil || inner.OperatorToken == nil {
-			return "", false
-		}
-		// Chain extension: `(x && a.b) && a.b.c` — peel down to the
-		// rightmost conjunct (`a.b`) and use it as the guard against
-		// the outer right side.
-		if inner.OperatorToken.Kind == shimast.KindAmpersandAmpersandToken {
-			conjunct := preferOptionalChainRightmostConjunct(left)
-			if conjunct == nil {
-				return "", false
-			}
-			switch conjunct.Kind {
-			case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
-				text := nodeText(ctx.File, conjunct)
-				return text, text != ""
-			}
-			return "", false
-		}
-		if inner.OperatorToken.Kind != shimast.KindExclamationEqualsToken &&
-			inner.OperatorToken.Kind != shimast.KindExclamationEqualsEqualsToken {
-			return "", false
-		}
-		lhs := stripParens(inner.Left)
-		rhs := stripParens(inner.Right)
-		if subject, ok := preferOptionalChainNullishCompareSubject(ctx, lhs, rhs); ok {
-			return subject, true
-		}
-		if subject, ok := preferOptionalChainNullishCompareSubject(ctx, rhs, lhs); ok {
-			return subject, true
-		}
-	}
-	return "", false
+  left = stripParens(left)
+  if left == nil {
+    return "", false
+  }
+  switch left.Kind {
+  case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
+    text := nodeText(ctx.File, left)
+    return text, text != ""
+  case shimast.KindBinaryExpression:
+    inner := left.AsBinaryExpression()
+    if inner == nil || inner.OperatorToken == nil {
+      return "", false
+    }
+    // Chain extension: `(x && a.b) && a.b.c` — peel down to the
+    // rightmost conjunct (`a.b`) and use it as the guard against
+    // the outer right side.
+    if inner.OperatorToken.Kind == shimast.KindAmpersandAmpersandToken {
+      conjunct := preferOptionalChainRightmostConjunct(left)
+      if conjunct == nil {
+        return "", false
+      }
+      switch conjunct.Kind {
+      case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
+        text := nodeText(ctx.File, conjunct)
+        return text, text != ""
+      }
+      return "", false
+    }
+    if inner.OperatorToken.Kind != shimast.KindExclamationEqualsToken &&
+      inner.OperatorToken.Kind != shimast.KindExclamationEqualsEqualsToken {
+      return "", false
+    }
+    lhs := stripParens(inner.Left)
+    rhs := stripParens(inner.Right)
+    if subject, ok := preferOptionalChainNullishCompareSubject(ctx, lhs, rhs); ok {
+      return subject, true
+    }
+    if subject, ok := preferOptionalChainNullishCompareSubject(ctx, rhs, lhs); ok {
+      return subject, true
+    }
+  }
+  return "", false
 }
 
 // preferOptionalChainNullishCompareSubject returns the textual identity
 // of `subject` when `nullish` is `null` or `undefined` and `subject` is
 // an identifier or property access. Returns the empty text otherwise.
 func preferOptionalChainNullishCompareSubject(
-	ctx *Context,
-	subject, nullish *shimast.Node,
+  ctx *Context,
+  subject, nullish *shimast.Node,
 ) (string, bool) {
-	if subject == nil || nullish == nil {
-		return "", false
-	}
-	if !preferOptionalChainIsNullOrUndefined(nullish) {
-		return "", false
-	}
-	switch subject.Kind {
-	case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
-		text := nodeText(ctx.File, subject)
-		return text, text != ""
-	}
-	return "", false
+  if subject == nil || nullish == nil {
+    return "", false
+  }
+  if !preferOptionalChainIsNullOrUndefined(nullish) {
+    return "", false
+  }
+  switch subject.Kind {
+  case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
+    text := nodeText(ctx.File, subject)
+    return text, text != ""
+  }
+  return "", false
 }
 
 // preferOptionalChainIsNullOrUndefined reports whether node is the
 // `null` keyword or the `undefined` identifier.
 func preferOptionalChainIsNullOrUndefined(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	if node.Kind == shimast.KindNullKeyword {
-		return true
-	}
-	if node.Kind == shimast.KindIdentifier {
-		return identifierText(node) == "undefined"
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindNullKeyword {
+    return true
+  }
+  if node.Kind == shimast.KindIdentifier {
+    return identifierText(node) == "undefined"
+  }
+  return false
 }
 
 // preferOptionalChainRightMatches reports whether `right` is a
@@ -166,63 +166,63 @@ func preferOptionalChainIsNullOrUndefined(node *shimast.Node) bool {
 // rejected — the `?.` rewrite would not preserve side-effect ordering
 // when the arguments themselves can have side effects.
 func preferOptionalChainRightMatches(
-	ctx *Context,
-	right *shimast.Node,
-	guardText string,
+  ctx *Context,
+  right *shimast.Node,
+  guardText string,
 ) bool {
-	if right == nil || guardText == "" {
-		return false
-	}
-	switch right.Kind {
-	case shimast.KindPropertyAccessExpression:
-		access := right.AsPropertyAccessExpression()
-		if access == nil || access.Expression == nil {
-			return false
-		}
-		return preferOptionalChainHasPrefix(ctx, right, guardText)
-	case shimast.KindCallExpression:
-		call := right.AsCallExpression()
-		if call == nil || call.Expression == nil {
-			return false
-		}
-		// Skip calls with arguments — their evaluation cannot be
-		// observed identically through `?.()`.
-		if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
-			return false
-		}
-		// The callee receiver must itself be a property access; a
-		// bare identifier call (`a()`) has no chain to fold.
-		callee := stripParens(call.Expression)
-		if callee == nil || callee.Kind != shimast.KindPropertyAccessExpression {
-			return false
-		}
-		return preferOptionalChainHasPrefix(ctx, right, guardText)
-	}
-	return false
+  if right == nil || guardText == "" {
+    return false
+  }
+  switch right.Kind {
+  case shimast.KindPropertyAccessExpression:
+    access := right.AsPropertyAccessExpression()
+    if access == nil || access.Expression == nil {
+      return false
+    }
+    return preferOptionalChainHasPrefix(ctx, right, guardText)
+  case shimast.KindCallExpression:
+    call := right.AsCallExpression()
+    if call == nil || call.Expression == nil {
+      return false
+    }
+    // Skip calls with arguments — their evaluation cannot be
+    // observed identically through `?.()`.
+    if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+      return false
+    }
+    // The callee receiver must itself be a property access; a
+    // bare identifier call (`a()`) has no chain to fold.
+    callee := stripParens(call.Expression)
+    if callee == nil || callee.Kind != shimast.KindPropertyAccessExpression {
+      return false
+    }
+    return preferOptionalChainHasPrefix(ctx, right, guardText)
+  }
+  return false
 }
 
 // preferOptionalChainHasPrefix returns whether the textual form of
 // `node` begins with `guard` followed by a `.` or `[` — the only
 // continuations that mean "a property of the guarded value".
 func preferOptionalChainHasPrefix(
-	ctx *Context,
-	node *shimast.Node,
-	guard string,
+  ctx *Context,
+  node *shimast.Node,
+  guard string,
 ) bool {
-	text := nodeText(ctx.File, node)
-	if !strings.HasPrefix(text, guard) {
-		return false
-	}
-	if len(text) == len(guard) {
-		return false
-	}
-	switch text[len(guard)] {
-	case '.', '[', '(':
-		return true
-	}
-	return false
+  text := nodeText(ctx.File, node)
+  if !strings.HasPrefix(text, guard) {
+    return false
+  }
+  if len(text) == len(guard) {
+    return false
+  }
+  switch text[len(guard)] {
+  case '.', '[', '(':
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(preferOptionalChain{})
+  Register(preferOptionalChain{})
 }

package/linthost/rules_ts_prefer_promise_reject_errors.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"
 )
 
 // preferPromiseRejectErrors reports `Promise.reject(arg)`, `p.reject(arg)`
@@ -27,39 +27,39 @@ import (
 type preferPromiseRejectErrors struct{}
 
 func (preferPromiseRejectErrors) Name() string {
-	return "typescript/prefer-promise-reject-errors"
+  return "typescript/prefer-promise-reject-errors"
 }
 func (preferPromiseRejectErrors) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (preferPromiseRejectErrors) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (preferPromiseRejectErrors) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	if !preferPromiseRejectErrorsIsRejectCall(ctx, call, node) {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
-		return
-	}
-	arg := stripParens(call.Arguments.Nodes[0])
-	if arg == nil {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(arg)
-	if t == nil {
-		return
-	}
-	if preferPromiseRejectErrorsIsNonError(ctx.Checker, t) {
-		ctx.Report(node, "Reject promises with an Error object instead of a non-Error value.")
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if !preferPromiseRejectErrorsIsRejectCall(ctx, call, node) {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(arg)
+  if t == nil {
+    return
+  }
+  if preferPromiseRejectErrorsIsNonError(ctx.Checker, t) {
+    ctx.Report(node, "Reject promises with an Error object instead of a non-Error value.")
+  }
 }
 
 // preferPromiseRejectErrorsIsRejectCall returns true when `call` is one of
@@ -70,25 +70,25 @@ func (preferPromiseRejectErrors) Check(ctx *Context, node *shimast.Node) {
 //
 // `node` is the AST node form of `call`, used for the parent walk.
 func preferPromiseRejectErrorsIsRejectCall(ctx *Context, call *shimast.CallExpression, node *shimast.Node) bool {
-	receiver, method, ok := promisePropertyAccessParts(call.Expression)
-	if ok && method == "reject" {
-		if identifierText(receiver) == "Promise" {
-			return true
-		}
-		if ctx.Checker != nil && receiver != nil {
-			if t := ctx.Checker.GetTypeAtLocation(receiver); t != nil &&
-				isPromiseTypedExpression(ctx.Checker, t) {
-				return true
-			}
-		}
-		return false
-	}
-	// Bare identifier call — check Promise executor binding.
-	name := callCalleeName(call)
-	if name == "" {
-		return false
-	}
-	return preferPromiseRejectErrorsIsExecutorReject(node, name)
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if ok && method == "reject" {
+    if identifierText(receiver) == "Promise" {
+      return true
+    }
+    if ctx.Checker != nil && receiver != nil {
+      if t := ctx.Checker.GetTypeAtLocation(receiver); t != nil &&
+        isPromiseTypedExpression(ctx.Checker, t) {
+        return true
+      }
+    }
+    return false
+  }
+  // Bare identifier call — check Promise executor binding.
+  name := callCalleeName(call)
+  if name == "" {
+    return false
+  }
+  return preferPromiseRejectErrorsIsExecutorReject(node, name)
 }
 
 // preferPromiseRejectErrorsIsExecutorReject walks parent function-like
@@ -97,19 +97,19 @@ func preferPromiseRejectErrorsIsRejectCall(ctx *Context, call *shimast.CallExpre
 // parameter is named `name`. Mirrors the param walking used by
 // `promiseNoMultipleResolved`.
 func preferPromiseRejectErrorsIsExecutorReject(node *shimast.Node, name string) bool {
-	for fn := nearestFunctionLike(node); fn != nil; fn = nearestFunctionLike(fn) {
-		if !preferPromiseRejectErrorsIsPromiseExecutorFn(fn) {
-			continue
-		}
-		params := fn.Parameters()
-		if len(params) < 2 {
-			continue
-		}
-		if parameterIdentifierName(params[1]) == name {
-			return true
-		}
-	}
-	return false
+  for fn := nearestFunctionLike(node); fn != nil; fn = nearestFunctionLike(fn) {
+    if !preferPromiseRejectErrorsIsPromiseExecutorFn(fn) {
+      continue
+    }
+    params := fn.Parameters()
+    if len(params) < 2 {
+      continue
+    }
+    if parameterIdentifierName(params[1]) == name {
+      return true
+    }
+  }
+  return false
 }
 
 // preferPromiseRejectErrorsIsPromiseExecutorFn reports whether `fn` is
@@ -118,22 +118,22 @@ func preferPromiseRejectErrorsIsExecutorReject(node *shimast.Node, name string)
 // does in rules_promise.go so `new Promise(((_, reject) => …))` still
 // matches.
 func preferPromiseRejectErrorsIsPromiseExecutorFn(fn *shimast.Node) bool {
-	if fn == nil || !isFunctionLikeKind(fn) {
-		return false
-	}
-	cur := fn
-	for parent := cur.Parent; parent != nil && parent.Kind == shimast.KindParenthesizedExpression; parent = parent.Parent {
-		cur = parent
-	}
-	newExpr := cur.Parent
-	if newExpr == nil || newExpr.Kind != shimast.KindNewExpression {
-		return false
-	}
-	ne := newExpr.AsNewExpression()
-	if ne == nil || identifierText(ne.Expression) != "Promise" || ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
-		return false
-	}
-	return stripParens(ne.Arguments.Nodes[0]) == fn
+  if fn == nil || !isFunctionLikeKind(fn) {
+    return false
+  }
+  cur := fn
+  for parent := cur.Parent; parent != nil && parent.Kind == shimast.KindParenthesizedExpression; parent = parent.Parent {
+    cur = parent
+  }
+  newExpr := cur.Parent
+  if newExpr == nil || newExpr.Kind != shimast.KindNewExpression {
+    return false
+  }
+  ne := newExpr.AsNewExpression()
+  if ne == nil || identifierText(ne.Expression) != "Promise" || ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
+    return false
+  }
+  return stripParens(ne.Arguments.Nodes[0]) == fn
 }
 
 // preferPromiseRejectErrorsIsNonError mirrors `onlyThrowErrorIsPrimitive`
@@ -143,34 +143,34 @@ func preferPromiseRejectErrorsIsPromiseExecutorFn(fn *shimast.Node) bool {
 // Union and intersection types recurse: a constituent that is primitive
 // is enough to fire, matching the throw-side baseline.
 func preferPromiseRejectErrorsIsNonError(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 preferPromiseRejectErrorsIsNonError(checker, part) {
-				return true
-			}
-		}
-		return false
-	}
-	const primitiveMask = shimchecker.TypeFlagsStringLike |
-		shimchecker.TypeFlagsNumberLike |
-		shimchecker.TypeFlagsBigIntLike |
-		shimchecker.TypeFlagsBooleanLike |
-		shimchecker.TypeFlagsVoid |
-		shimchecker.TypeFlagsUndefined |
-		shimchecker.TypeFlagsNull
-	return flags&primitiveMask != 0
+  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 preferPromiseRejectErrorsIsNonError(checker, part) {
+        return true
+      }
+    }
+    return false
+  }
+  const primitiveMask = shimchecker.TypeFlagsStringLike |
+    shimchecker.TypeFlagsNumberLike |
+    shimchecker.TypeFlagsBigIntLike |
+    shimchecker.TypeFlagsBooleanLike |
+    shimchecker.TypeFlagsVoid |
+    shimchecker.TypeFlagsUndefined |
+    shimchecker.TypeFlagsNull
+  return flags&primitiveMask != 0
 }
 
 func init() {
-	Register(preferPromiseRejectErrors{})
+  Register(preferPromiseRejectErrors{})
 }