@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_ts_no_unnecessary_condition.go

@@ -14,10 +14,10 @@
 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"
 )
 
 // truthState is the lattice value the rule tracks for each constituent of
@@ -35,73 +35,73 @@ import (
 type truthState int
 
 const (
-	truthStateUnknowable truthState = iota
-	truthStateAlwaysTruthy
-	truthStateAlwaysFalsy
-	truthStateMixed
+  truthStateUnknowable truthState = iota
+  truthStateAlwaysTruthy
+  truthStateAlwaysFalsy
+  truthStateMixed
 )
 
 type noUnnecessaryCondition struct{}
 
 func (noUnnecessaryCondition) Name() string { return "typescript/no-unnecessary-condition" }
 func (noUnnecessaryCondition) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnnecessaryCondition) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindIfStatement,
-		shimast.KindWhileStatement,
-		shimast.KindDoStatement,
-		shimast.KindForStatement,
-		shimast.KindConditionalExpression,
-		shimast.KindBinaryExpression,
-		shimast.KindPrefixUnaryExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindIfStatement,
+    shimast.KindWhileStatement,
+    shimast.KindDoStatement,
+    shimast.KindForStatement,
+    shimast.KindConditionalExpression,
+    shimast.KindBinaryExpression,
+    shimast.KindPrefixUnaryExpression,
+  }
 }
 func (noUnnecessaryCondition) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindIfStatement:
-		if stmt := node.AsIfStatement(); stmt != nil {
-			noUnnecessaryConditionReport(ctx, stmt.Expression)
-		}
-	case shimast.KindWhileStatement:
-		if stmt := node.AsWhileStatement(); stmt != nil {
-			noUnnecessaryConditionReport(ctx, stmt.Expression)
-		}
-	case shimast.KindDoStatement:
-		if stmt := node.AsDoStatement(); stmt != nil {
-			noUnnecessaryConditionReport(ctx, stmt.Expression)
-		}
-	case shimast.KindForStatement:
-		if stmt := node.AsForStatement(); stmt != nil {
-			noUnnecessaryConditionReport(ctx, stmt.Condition)
-		}
-	case shimast.KindConditionalExpression:
-		if expr := node.AsConditionalExpression(); expr != nil {
-			noUnnecessaryConditionReport(ctx, expr.Condition)
-		}
-	case shimast.KindPrefixUnaryExpression:
-		expr := node.AsPrefixUnaryExpression()
-		if expr != nil && expr.Operator == shimast.KindExclamationToken {
-			noUnnecessaryConditionReport(ctx, expr.Operand)
-		}
-	case shimast.KindBinaryExpression:
-		bin := node.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil {
-			return
-		}
-		// Only `&&` / `||` test their left operand for truthiness. `??`
-		// short-circuits on nullish, not on falsy, and is intentionally
-		// out of scope — its dedicated rule
-		// `no-unnecessary-nullish-coalescing` covers that pattern.
-		switch bin.OperatorToken.Kind {
-		case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
-			noUnnecessaryConditionReport(ctx, bin.Left)
-		}
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindIfStatement:
+    if stmt := node.AsIfStatement(); stmt != nil {
+      noUnnecessaryConditionReport(ctx, stmt.Expression)
+    }
+  case shimast.KindWhileStatement:
+    if stmt := node.AsWhileStatement(); stmt != nil {
+      noUnnecessaryConditionReport(ctx, stmt.Expression)
+    }
+  case shimast.KindDoStatement:
+    if stmt := node.AsDoStatement(); stmt != nil {
+      noUnnecessaryConditionReport(ctx, stmt.Expression)
+    }
+  case shimast.KindForStatement:
+    if stmt := node.AsForStatement(); stmt != nil {
+      noUnnecessaryConditionReport(ctx, stmt.Condition)
+    }
+  case shimast.KindConditionalExpression:
+    if expr := node.AsConditionalExpression(); expr != nil {
+      noUnnecessaryConditionReport(ctx, expr.Condition)
+    }
+  case shimast.KindPrefixUnaryExpression:
+    expr := node.AsPrefixUnaryExpression()
+    if expr != nil && expr.Operator == shimast.KindExclamationToken {
+      noUnnecessaryConditionReport(ctx, expr.Operand)
+    }
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return
+    }
+    // Only `&&` / `||` test their left operand for truthiness. `??`
+    // short-circuits on nullish, not on falsy, and is intentionally
+    // out of scope — its dedicated rule
+    // `no-unnecessary-nullish-coalescing` covers that pattern.
+    switch bin.OperatorToken.Kind {
+    case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
+      noUnnecessaryConditionReport(ctx, bin.Left)
+    }
+  }
 }
 
 // noUnnecessaryConditionReport flags `expr` when its static type proves
@@ -110,34 +110,34 @@ func (noUnnecessaryCondition) Check(ctx *Context, node *shimast.Node) {
 // only checks Left, so the recursion here picks up Right too. Wrapping
 // parens are skipped via stripParens.
 func noUnnecessaryConditionReport(ctx *Context, expr *shimast.Node) {
-	if expr == nil {
-		return
-	}
-	expr = stripParens(expr)
-	if expr == nil {
-		return
-	}
-	if expr.Kind == shimast.KindBinaryExpression {
-		bin := expr.AsBinaryExpression()
-		if bin != nil && bin.OperatorToken != nil {
-			switch bin.OperatorToken.Kind {
-			case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
-				noUnnecessaryConditionReport(ctx, bin.Left)
-				noUnnecessaryConditionReport(ctx, bin.Right)
-				return
-			}
-		}
-	}
-	t := ctx.Checker.GetTypeAtLocation(expr)
-	if t == nil {
-		return
-	}
-	switch noUnnecessaryConditionEvaluate(ctx.Checker, t) {
-	case truthStateAlwaysTruthy:
-		ctx.Report(expr, "Unnecessary conditional, value is always truthy.")
-	case truthStateAlwaysFalsy:
-		ctx.Report(expr, "Unnecessary conditional, value is always falsy.")
-	}
+  if expr == nil {
+    return
+  }
+  expr = stripParens(expr)
+  if expr == nil {
+    return
+  }
+  if expr.Kind == shimast.KindBinaryExpression {
+    bin := expr.AsBinaryExpression()
+    if bin != nil && bin.OperatorToken != nil {
+      switch bin.OperatorToken.Kind {
+      case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
+        noUnnecessaryConditionReport(ctx, bin.Left)
+        noUnnecessaryConditionReport(ctx, bin.Right)
+        return
+      }
+    }
+  }
+  t := ctx.Checker.GetTypeAtLocation(expr)
+  if t == nil {
+    return
+  }
+  switch noUnnecessaryConditionEvaluate(ctx.Checker, t) {
+  case truthStateAlwaysTruthy:
+    ctx.Report(expr, "Unnecessary conditional, value is always truthy.")
+  case truthStateAlwaysFalsy:
+    ctx.Report(expr, "Unnecessary conditional, value is always falsy.")
+  }
 }
 
 // noUnnecessaryConditionEvaluate folds a type into a single truthState by
@@ -148,103 +148,103 @@ func noUnnecessaryConditionReport(ctx *Context, expr *shimast.Node) {
 // because the Checker may resolve them into shapes (e.g. branded
 // primitives) the rule cannot reason about safely.
 func noUnnecessaryConditionEvaluate(checker *shimchecker.Checker, t *shimchecker.Type) truthState {
-	if checker == nil || t == nil {
-		return truthStateUnknowable
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
-		return truthStateUnknowable
-	}
-	if flags&shimchecker.TypeFlagsIntersection != 0 {
-		// Intersections such as `Foo & { brand: "x" }` carry semantics the
-		// rule cannot prove without a deeper Checker walk, so we keep the
-		// conservative bail.
-		return truthStateUnknowable
-	}
-	if flags&shimchecker.TypeFlagsUnion != 0 {
-		parts := t.Types()
-		if len(parts) == 0 {
-			return truthStateUnknowable
-		}
-		combined := truthState(-1)
-		for _, part := range parts {
-			if part == nil {
-				return truthStateUnknowable
-			}
-			state := noUnnecessaryConditionEvaluate(checker, part)
-			if state == truthStateUnknowable || state == truthStateMixed {
-				// A union with even one constituent we can't pin breaks the
-				// "always X" guarantee — bail.
-				return state
-			}
-			if combined == truthState(-1) {
-				combined = state
-				continue
-			}
-			if combined != state {
-				// `string | null` has both a falsy ("") and a always-falsy
-				// (null) outcome that disagree across constituents — fall
-				// back to mixed so the rule stays silent.
-				return truthStateMixed
-			}
-		}
-		if combined == truthState(-1) {
-			return truthStateUnknowable
-		}
-		return combined
-	}
-	// Atomic types.
-	if flags&(shimchecker.TypeFlagsNull|shimchecker.TypeFlagsUndefined|shimchecker.TypeFlagsVoid) != 0 {
-		return truthStateAlwaysFalsy
-	}
-	if flags&shimchecker.TypeFlagsBooleanLiteral != 0 {
-		text := checker.TypeToString(t)
-		if strings.TrimSpace(text) == "false" {
-			return truthStateAlwaysFalsy
-		}
-		if strings.TrimSpace(text) == "true" {
-			return truthStateAlwaysTruthy
-		}
-		return truthStateUnknowable
-	}
-	if flags&shimchecker.TypeFlagsStringLiteral != 0 {
-		text := strings.TrimSpace(checker.TypeToString(t))
-		if text == `""` || text == `''` {
-			return truthStateAlwaysFalsy
-		}
-		return truthStateAlwaysTruthy
-	}
-	if flags&shimchecker.TypeFlagsNumberLiteral != 0 {
-		text := strings.TrimSpace(checker.TypeToString(t))
-		// `0`, `0.0`, `-0` all stringify as `0`; everything else is truthy.
-		// `NaN` is not representable as a literal type, so it cannot reach
-		// this branch.
-		if text == "0" {
-			return truthStateAlwaysFalsy
-		}
-		return truthStateAlwaysTruthy
-	}
-	if flags&shimchecker.TypeFlagsBigIntLiteral != 0 {
-		text := strings.TrimSpace(checker.TypeToString(t))
-		if text == "0n" {
-			return truthStateAlwaysFalsy
-		}
-		return truthStateAlwaysTruthy
-	}
-	if flags&shimchecker.TypeFlagsObject != 0 {
-		// A non-nullable object value is always truthy. `{}`, arrays,
-		// class instances, functions, and structural records all share
-		// this contract; only `null` / `undefined` make an object position
-		// falsy and those flags route to the always-falsy branch above.
-		return truthStateAlwaysTruthy
-	}
-	// Plain `string` / `number` / `boolean` / `bigint` / enum / symbol /
-	// type parameter / index / template literal — every one of these can
-	// hold both truthy and falsy values (or escapes static reasoning), so
-	// the rule must stay silent.
-	return truthStateMixed
+  if checker == nil || t == nil {
+    return truthStateUnknowable
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return truthStateUnknowable
+  }
+  if flags&shimchecker.TypeFlagsIntersection != 0 {
+    // Intersections such as `Foo & { brand: "x" }` carry semantics the
+    // rule cannot prove without a deeper Checker walk, so we keep the
+    // conservative bail.
+    return truthStateUnknowable
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    parts := t.Types()
+    if len(parts) == 0 {
+      return truthStateUnknowable
+    }
+    combined := truthState(-1)
+    for _, part := range parts {
+      if part == nil {
+        return truthStateUnknowable
+      }
+      state := noUnnecessaryConditionEvaluate(checker, part)
+      if state == truthStateUnknowable || state == truthStateMixed {
+        // A union with even one constituent we can't pin breaks the
+        // "always X" guarantee — bail.
+        return state
+      }
+      if combined == truthState(-1) {
+        combined = state
+        continue
+      }
+      if combined != state {
+        // `string | null` has both a falsy ("") and a always-falsy
+        // (null) outcome that disagree across constituents — fall
+        // back to mixed so the rule stays silent.
+        return truthStateMixed
+      }
+    }
+    if combined == truthState(-1) {
+      return truthStateUnknowable
+    }
+    return combined
+  }
+  // Atomic types.
+  if flags&(shimchecker.TypeFlagsNull|shimchecker.TypeFlagsUndefined|shimchecker.TypeFlagsVoid) != 0 {
+    return truthStateAlwaysFalsy
+  }
+  if flags&shimchecker.TypeFlagsBooleanLiteral != 0 {
+    text := checker.TypeToString(t)
+    if strings.TrimSpace(text) == "false" {
+      return truthStateAlwaysFalsy
+    }
+    if strings.TrimSpace(text) == "true" {
+      return truthStateAlwaysTruthy
+    }
+    return truthStateUnknowable
+  }
+  if flags&shimchecker.TypeFlagsStringLiteral != 0 {
+    text := strings.TrimSpace(checker.TypeToString(t))
+    if text == `""` || text == `''` {
+      return truthStateAlwaysFalsy
+    }
+    return truthStateAlwaysTruthy
+  }
+  if flags&shimchecker.TypeFlagsNumberLiteral != 0 {
+    text := strings.TrimSpace(checker.TypeToString(t))
+    // `0`, `0.0`, `-0` all stringify as `0`; everything else is truthy.
+    // `NaN` is not representable as a literal type, so it cannot reach
+    // this branch.
+    if text == "0" {
+      return truthStateAlwaysFalsy
+    }
+    return truthStateAlwaysTruthy
+  }
+  if flags&shimchecker.TypeFlagsBigIntLiteral != 0 {
+    text := strings.TrimSpace(checker.TypeToString(t))
+    if text == "0n" {
+      return truthStateAlwaysFalsy
+    }
+    return truthStateAlwaysTruthy
+  }
+  if flags&shimchecker.TypeFlagsObject != 0 {
+    // A non-nullable object value is always truthy. `{}`, arrays,
+    // class instances, functions, and structural records all share
+    // this contract; only `null` / `undefined` make an object position
+    // falsy and those flags route to the always-falsy branch above.
+    return truthStateAlwaysTruthy
+  }
+  // Plain `string` / `number` / `boolean` / `bigint` / enum / symbol /
+  // type parameter / index / template literal — every one of these can
+  // hold both truthy and falsy values (or escapes static reasoning), so
+  // the rule must stay silent.
+  return truthStateMixed
 }
 
 func init() {
-	Register(noUnnecessaryCondition{})
+  Register(noUnnecessaryCondition{})
 }

package/linthost/rules_ts_no_unnecessary_qualifier.go

@@ -7,7 +7,7 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // noUnnecessaryQualifier inspects every two-segment qualified reference
@@ -22,23 +22,23 @@ import (
 type noUnnecessaryQualifier struct{}
 
 func (noUnnecessaryQualifier) Name() string {
-	return "typescript/no-unnecessary-qualifier"
+  return "typescript/no-unnecessary-qualifier"
 }
 func (noUnnecessaryQualifier) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindQualifiedName,
-		shimast.KindPropertyAccessExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindQualifiedName,
+    shimast.KindPropertyAccessExpression,
+  }
 }
 func (noUnnecessaryQualifier) Check(ctx *Context, node *shimast.Node) {
-	head := noUnnecessaryQualifierHead(node)
-	if head == "" {
-		return
-	}
-	if !noUnnecessaryQualifierHasEnclosingScope(node, head) {
-		return
-	}
-	ctx.Report(node, "Qualifier `"+head+"` is the enclosing namespace or enum — drop the qualifier.")
+  head := noUnnecessaryQualifierHead(node)
+  if head == "" {
+    return
+  }
+  if !noUnnecessaryQualifierHasEnclosingScope(node, head) {
+    return
+  }
+  ctx.Report(node, "Qualifier `"+head+"` is the enclosing namespace or enum — drop the qualifier.")
 }
 
 // noUnnecessaryQualifierHead returns the LHS identifier text when the
@@ -47,35 +47,35 @@ func (noUnnecessaryQualifier) Check(ctx *Context, node *shimast.Node) {
 // accesses, or non-identifier heads — those shapes don't match the
 // "qualifier names the enclosing scope" pattern.
 func noUnnecessaryQualifierHead(node *shimast.Node) string {
-	if node == nil {
-		return ""
-	}
-	switch node.Kind {
-	case shimast.KindQualifiedName:
-		qn := node.AsQualifiedName()
-		if qn == nil || qn.Left == nil {
-			return ""
-		}
-		if qn.Left.Kind != shimast.KindIdentifier {
-			return ""
-		}
-		return identifierText(qn.Left)
-	case shimast.KindPropertyAccessExpression:
-		pa := node.AsPropertyAccessExpression()
-		if pa == nil || pa.Expression == nil || pa.Name() == nil {
-			return ""
-		}
-		// Optional chains (`Foo?.Bar`) aren't redundant in the same
-		// sense — the `?.` changes runtime behavior, so leave them be.
-		if pa.QuestionDotToken != nil {
-			return ""
-		}
-		if pa.Expression.Kind != shimast.KindIdentifier {
-			return ""
-		}
-		return identifierText(pa.Expression)
-	}
-	return ""
+  if node == nil {
+    return ""
+  }
+  switch node.Kind {
+  case shimast.KindQualifiedName:
+    qn := node.AsQualifiedName()
+    if qn == nil || qn.Left == nil {
+      return ""
+    }
+    if qn.Left.Kind != shimast.KindIdentifier {
+      return ""
+    }
+    return identifierText(qn.Left)
+  case shimast.KindPropertyAccessExpression:
+    pa := node.AsPropertyAccessExpression()
+    if pa == nil || pa.Expression == nil || pa.Name() == nil {
+      return ""
+    }
+    // Optional chains (`Foo?.Bar`) aren't redundant in the same
+    // sense — the `?.` changes runtime behavior, so leave them be.
+    if pa.QuestionDotToken != nil {
+      return ""
+    }
+    if pa.Expression.Kind != shimast.KindIdentifier {
+      return ""
+    }
+    return identifierText(pa.Expression)
+  }
+  return ""
 }
 
 // noUnnecessaryQualifierHasEnclosingScope reports whether `node`
@@ -83,36 +83,36 @@ func noUnnecessaryQualifierHead(node *shimast.Node) string {
 // declaration body. The walk climbs `Parent` links until it finds a
 // matching block or hits the SourceFile root.
 func noUnnecessaryQualifierHasEnclosingScope(node *shimast.Node, head string) bool {
-	for cur := node.Parent; cur != nil; cur = cur.Parent {
-		switch cur.Kind {
-		case shimast.KindModuleDeclaration:
-			decl := cur.AsModuleDeclaration()
-			if decl == nil || decl.Name() == nil {
-				continue
-			}
-			// `declare module "fs"` carries a string-literal name and
-			// does not bind an identifier in the surrounding scope —
-			// skip those entirely. The rule only fires when the head
-			// matches the enclosing namespace's identifier name.
-			if decl.Name().Kind != shimast.KindIdentifier {
-				continue
-			}
-			if identifierText(decl.Name()) == head {
-				return true
-			}
-		case shimast.KindEnumDeclaration:
-			decl := cur.AsEnumDeclaration()
-			if decl == nil || decl.Name() == nil {
-				continue
-			}
-			if identifierText(decl.Name()) == head {
-				return true
-			}
-		}
-	}
-	return false
+  for cur := node.Parent; cur != nil; cur = cur.Parent {
+    switch cur.Kind {
+    case shimast.KindModuleDeclaration:
+      decl := cur.AsModuleDeclaration()
+      if decl == nil || decl.Name() == nil {
+        continue
+      }
+      // `declare module "fs"` carries a string-literal name and
+      // does not bind an identifier in the surrounding scope —
+      // skip those entirely. The rule only fires when the head
+      // matches the enclosing namespace's identifier name.
+      if decl.Name().Kind != shimast.KindIdentifier {
+        continue
+      }
+      if identifierText(decl.Name()) == head {
+        return true
+      }
+    case shimast.KindEnumDeclaration:
+      decl := cur.AsEnumDeclaration()
+      if decl == nil || decl.Name() == nil {
+        continue
+      }
+      if identifierText(decl.Name()) == head {
+        return true
+      }
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(noUnnecessaryQualifier{})
+  Register(noUnnecessaryQualifier{})
 }