@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_ts_no_misused_spread.go

@@ -19,65 +19,65 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noMisusedSpread struct{}
 
 func (noMisusedSpread) Name() string { return "typescript/no-misused-spread" }
 func (noMisusedSpread) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindArrayLiteralExpression,
-		shimast.KindObjectLiteralExpression,
-		shimast.KindCallExpression,
-		shimast.KindNewExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindArrayLiteralExpression,
+    shimast.KindObjectLiteralExpression,
+    shimast.KindCallExpression,
+    shimast.KindNewExpression,
+  }
 }
 func (noMisusedSpread) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindArrayLiteralExpression:
-		arr := node.AsArrayLiteralExpression()
-		if arr == nil || arr.Elements == nil {
-			return
-		}
-		for _, elem := range arr.Elements.Nodes {
-			reportObjectSpreadInIterable(ctx, elem)
-		}
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil || call.Arguments == nil {
-			return
-		}
-		for _, arg := range call.Arguments.Nodes {
-			reportObjectSpreadInIterable(ctx, arg)
-		}
-	case shimast.KindNewExpression:
-		ne := node.AsNewExpression()
-		if ne == nil || ne.Arguments == nil {
-			return
-		}
-		for _, arg := range ne.Arguments.Nodes {
-			reportObjectSpreadInIterable(ctx, arg)
-		}
-	case shimast.KindObjectLiteralExpression:
-		obj := node.AsObjectLiteralExpression()
-		if obj == nil || obj.Properties == nil {
-			return
-		}
-		for _, prop := range obj.Properties.Nodes {
-			if prop == nil || prop.Kind != shimast.KindSpreadAssignment {
-				continue
-			}
-			spread := prop.AsSpreadAssignment()
-			if spread == nil {
-				continue
-			}
-			inner := stripParens(spread.Expression)
-			if inner != nil && inner.Kind == shimast.KindArrayLiteralExpression {
-				ctx.Report(prop, "Spreading an array literal into an object literal coerces numeric indices to string keys — likely a mistake.")
-			}
-		}
-	}
+  switch node.Kind {
+  case shimast.KindArrayLiteralExpression:
+    arr := node.AsArrayLiteralExpression()
+    if arr == nil || arr.Elements == nil {
+      return
+    }
+    for _, elem := range arr.Elements.Nodes {
+      reportObjectSpreadInIterable(ctx, elem)
+    }
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil || call.Arguments == nil {
+      return
+    }
+    for _, arg := range call.Arguments.Nodes {
+      reportObjectSpreadInIterable(ctx, arg)
+    }
+  case shimast.KindNewExpression:
+    ne := node.AsNewExpression()
+    if ne == nil || ne.Arguments == nil {
+      return
+    }
+    for _, arg := range ne.Arguments.Nodes {
+      reportObjectSpreadInIterable(ctx, arg)
+    }
+  case shimast.KindObjectLiteralExpression:
+    obj := node.AsObjectLiteralExpression()
+    if obj == nil || obj.Properties == nil {
+      return
+    }
+    for _, prop := range obj.Properties.Nodes {
+      if prop == nil || prop.Kind != shimast.KindSpreadAssignment {
+        continue
+      }
+      spread := prop.AsSpreadAssignment()
+      if spread == nil {
+        continue
+      }
+      inner := stripParens(spread.Expression)
+      if inner != nil && inner.Kind == shimast.KindArrayLiteralExpression {
+        ctx.Report(prop, "Spreading an array literal into an object literal coerces numeric indices to string keys — likely a mistake.")
+      }
+    }
+  }
 }
 
 // reportObjectSpreadInIterable reports the spread element when its
@@ -85,20 +85,20 @@ func (noMisusedSpread) Check(ctx *Context, node *shimast.Node) {
 // via iteration (array literal element or function/constructor
 // argument).
 func reportObjectSpreadInIterable(ctx *Context, elem *shimast.Node) {
-	if elem == nil || elem.Kind != shimast.KindSpreadElement {
-		return
-	}
-	spread := elem.AsSpreadElement()
-	if spread == nil {
-		return
-	}
-	inner := stripParens(spread.Expression)
-	if inner == nil || inner.Kind != shimast.KindObjectLiteralExpression {
-		return
-	}
-	ctx.Report(elem, "Spread of an object literal into an iterable context is meaningless — object literals are not iterable.")
+  if elem == nil || elem.Kind != shimast.KindSpreadElement {
+    return
+  }
+  spread := elem.AsSpreadElement()
+  if spread == nil {
+    return
+  }
+  inner := stripParens(spread.Expression)
+  if inner == nil || inner.Kind != shimast.KindObjectLiteralExpression {
+    return
+  }
+  ctx.Report(elem, "Spread of an object literal into an iterable context is meaningless — object literals are not iterable.")
 }
 
 func init() {
-	Register(noMisusedSpread{})
+  Register(noMisusedSpread{})
 }

package/linthost/rules_ts_no_redundant_type_constituents.go

@@ -14,100 +14,100 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noRedundantTypeConstituents struct{}
 
 func (noRedundantTypeConstituents) Name() string {
-	return "typescript/no-redundant-type-constituents"
+  return "typescript/no-redundant-type-constituents"
 }
 func (noRedundantTypeConstituents) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindUnionType, shimast.KindIntersectionType}
+  return []shimast.Kind{shimast.KindUnionType, shimast.KindIntersectionType}
 }
 func (noRedundantTypeConstituents) Check(ctx *Context, node *shimast.Node) {
-	types := unionOrIntersectionTypes(node)
-	if len(types) < 2 {
-		return
-	}
-	isUnion := node.Kind == shimast.KindUnionType
-	hasAny := containsKeywordType(types, shimast.KindAnyKeyword)
-	hasUnknown := containsKeywordType(types, shimast.KindUnknownKeyword)
-	hasNever := containsKeywordType(types, shimast.KindNeverKeyword)
-	label := "intersection"
-	if isUnion {
-		label = "union"
-	}
-	seen := map[string]bool{}
-	for _, t := range types {
-		if t == nil {
-			continue
-		}
-		switch {
-		case isUnion && (hasAny || hasUnknown) && t.Kind != shimast.KindAnyKeyword && t.Kind != shimast.KindUnknownKeyword:
-			// `T | any` / `T | unknown` — every non-top constituent is
-			// absorbed. `any` takes precedence in the message because
-			// `any` also subsumes `unknown`.
-			absorbing := "unknown"
-			if hasAny {
-				absorbing = "any"
-			}
-			ctx.Report(t, "Constituent is overridden by `"+absorbing+"` in the surrounding union.")
-		case isUnion && hasNever && t.Kind == shimast.KindNeverKeyword:
-			ctx.Report(t, "`never` is absorbed by the surrounding union.")
-		case !isUnion && hasNever:
-			// `T & never` collapses to `never` for every constituent.
-			ctx.Report(t, "Intersection with `never` collapses to `never`.")
-		case !isUnion && hasUnknown && t.Kind == shimast.KindUnknownKeyword:
-			ctx.Report(t, "`unknown` is absorbed by the surrounding intersection.")
-		}
-		// Duplicate by textual identity — fire on the second occurrence
-		// so the first declaration stays unblamed.
-		key := strings.TrimSpace(nodeText(ctx.File, t))
-		if key == "" {
-			continue
-		}
-		if seen[key] {
-			ctx.Report(t, "Duplicate constituent in "+label+".")
-			continue
-		}
-		seen[key] = true
-	}
+  types := unionOrIntersectionTypes(node)
+  if len(types) < 2 {
+    return
+  }
+  isUnion := node.Kind == shimast.KindUnionType
+  hasAny := containsKeywordType(types, shimast.KindAnyKeyword)
+  hasUnknown := containsKeywordType(types, shimast.KindUnknownKeyword)
+  hasNever := containsKeywordType(types, shimast.KindNeverKeyword)
+  label := "intersection"
+  if isUnion {
+    label = "union"
+  }
+  seen := map[string]bool{}
+  for _, t := range types {
+    if t == nil {
+      continue
+    }
+    switch {
+    case isUnion && (hasAny || hasUnknown) && t.Kind != shimast.KindAnyKeyword && t.Kind != shimast.KindUnknownKeyword:
+      // `T | any` / `T | unknown` — every non-top constituent is
+      // absorbed. `any` takes precedence in the message because
+      // `any` also subsumes `unknown`.
+      absorbing := "unknown"
+      if hasAny {
+        absorbing = "any"
+      }
+      ctx.Report(t, "Constituent is overridden by `"+absorbing+"` in the surrounding union.")
+    case isUnion && hasNever && t.Kind == shimast.KindNeverKeyword:
+      ctx.Report(t, "`never` is absorbed by the surrounding union.")
+    case !isUnion && hasNever:
+      // `T & never` collapses to `never` for every constituent.
+      ctx.Report(t, "Intersection with `never` collapses to `never`.")
+    case !isUnion && hasUnknown && t.Kind == shimast.KindUnknownKeyword:
+      ctx.Report(t, "`unknown` is absorbed by the surrounding intersection.")
+    }
+    // Duplicate by textual identity — fire on the second occurrence
+    // so the first declaration stays unblamed.
+    key := strings.TrimSpace(nodeText(ctx.File, t))
+    if key == "" {
+      continue
+    }
+    if seen[key] {
+      ctx.Report(t, "Duplicate constituent in "+label+".")
+      continue
+    }
+    seen[key] = true
+  }
 }
 
 // unionOrIntersectionTypes returns the constituent type nodes of a union
 // or intersection type node, or nil for other shapes.
 func unionOrIntersectionTypes(node *shimast.Node) []*shimast.Node {
-	if node == nil {
-		return nil
-	}
-	switch node.Kind {
-	case shimast.KindUnionType:
-		if u := node.AsUnionTypeNode(); u != nil && u.Types != nil {
-			return u.Types.Nodes
-		}
-	case shimast.KindIntersectionType:
-		if i := node.AsIntersectionTypeNode(); i != nil && i.Types != nil {
-			return i.Types.Nodes
-		}
-	}
-	return nil
+  if node == nil {
+    return nil
+  }
+  switch node.Kind {
+  case shimast.KindUnionType:
+    if u := node.AsUnionTypeNode(); u != nil && u.Types != nil {
+      return u.Types.Nodes
+    }
+  case shimast.KindIntersectionType:
+    if i := node.AsIntersectionTypeNode(); i != nil && i.Types != nil {
+      return i.Types.Nodes
+    }
+  }
+  return nil
 }
 
 // containsKeywordType reports whether `types` contains a direct keyword
 // type node of `kind` — `any`, `unknown`, or `never` in type position
 // parse as bare keyword nodes rather than identifiers.
 func containsKeywordType(types []*shimast.Node, kind shimast.Kind) bool {
-	for _, t := range types {
-		if t != nil && t.Kind == kind {
-			return true
-		}
-	}
-	return false
+  for _, t := range types {
+    if t != nil && t.Kind == kind {
+      return true
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(noRedundantTypeConstituents{})
+  Register(noRedundantTypeConstituents{})
 }

package/linthost/rules_ts_no_restricted_types.go

@@ -14,7 +14,7 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noRestrictedTypes struct{}
@@ -23,40 +23,40 @@ type noRestrictedTypes struct{}
 // when no config is supplied. Each entry pairs the banned identifier
 // with a short, actionable replacement hint.
 var noRestrictedTypesDefault = map[string]string{
-	"Object":   "Use `object` (any non-primitive) or a specific shape like `Record<string, unknown>` instead of `Object`.",
-	"Function": "Declare the specific call signature instead of the unsafe `Function` type.",
-	"Number":   "Use the lowercase primitive `number` instead of the wrapper type `Number`.",
-	"String":   "Use the lowercase primitive `string` instead of the wrapper type `String`.",
-	"Boolean":  "Use the lowercase primitive `boolean` instead of the wrapper type `Boolean`.",
+  "Object":   "Use `object` (any non-primitive) or a specific shape like `Record<string, unknown>` instead of `Object`.",
+  "Function": "Declare the specific call signature instead of the unsafe `Function` type.",
+  "Number":   "Use the lowercase primitive `number` instead of the wrapper type `Number`.",
+  "String":   "Use the lowercase primitive `string` instead of the wrapper type `String`.",
+  "Boolean":  "Use the lowercase primitive `boolean` instead of the wrapper type `Boolean`.",
 }
 
 func (noRestrictedTypes) Name() string { return "typescript/no-restricted-types" }
 func (noRestrictedTypes) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindTypeReference}
+  return []shimast.Kind{shimast.KindTypeReference}
 }
 func (noRestrictedTypes) Check(ctx *Context, node *shimast.Node) {
-	ref := node.AsTypeReferenceNode()
-	if ref == nil || ref.TypeName == nil {
-		return
-	}
-	name := identifierText(ref.TypeName)
-	if name == "" {
-		return
-	}
-	message, banned := noRestrictedTypesDefault[name]
-	if !banned {
-		return
-	}
-	// Shadow guard: if the user has declared a same-named `type` /
-	// `interface` / `class` at file scope, their identifier is NOT the
-	// global wrapper. Re-use the wrapper-types helper so the two rules
-	// stay consistent about what counts as a shadow.
-	if fileShadowsWrapperName(ctx.File, name) {
-		return
-	}
-	ctx.Report(node, message)
+  ref := node.AsTypeReferenceNode()
+  if ref == nil || ref.TypeName == nil {
+    return
+  }
+  name := identifierText(ref.TypeName)
+  if name == "" {
+    return
+  }
+  message, banned := noRestrictedTypesDefault[name]
+  if !banned {
+    return
+  }
+  // Shadow guard: if the user has declared a same-named `type` /
+  // `interface` / `class` at file scope, their identifier is NOT the
+  // global wrapper. Re-use the wrapper-types helper so the two rules
+  // stay consistent about what counts as a shadow.
+  if fileShadowsWrapperName(ctx.File, name) {
+    return
+  }
+  ctx.Report(node, message)
 }
 
 func init() {
-	Register(noRestrictedTypes{})
+  Register(noRestrictedTypes{})
 }

package/linthost/rules_ts_no_unnecessary_boolean_literal_compare.go

@@ -12,81 +12,81 @@
 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 noUnnecessaryBooleanLiteralCompare struct{}
 
 func (noUnnecessaryBooleanLiteralCompare) Name() string {
-	return "typescript/no-unnecessary-boolean-literal-compare"
+  return "typescript/no-unnecessary-boolean-literal-compare"
 }
 func (noUnnecessaryBooleanLiteralCompare) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnnecessaryBooleanLiteralCompare) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (noUnnecessaryBooleanLiteralCompare) 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
-	}
-	// Only equality / inequality operators are subject to the rewrite —
-	// `<`, `>`, `&&`, etc. against `true` / `false` are not the same shape.
-	switch bin.OperatorToken.Kind {
-	case shimast.KindEqualsEqualsToken,
-		shimast.KindEqualsEqualsEqualsToken,
-		shimast.KindExclamationEqualsToken,
-		shimast.KindExclamationEqualsEqualsToken:
-	default:
-		return
-	}
-	left := stripParens(bin.Left)
-	right := stripParens(bin.Right)
-	if left == nil || right == nil {
-		return
-	}
-	// Identify which side is the literal and which side is the value.
-	// `true === x` and `x === true` are both reported.
-	var value *shimast.Node
-	switch {
-	case noUnnecessaryBooleanLiteralCompareIsBoolLiteral(left):
-		value = right
-	case noUnnecessaryBooleanLiteralCompareIsBoolLiteral(right):
-		value = left
-	default:
-		return
-	}
-	// Skip when both sides are literals — that's a different code smell
-	// (e.g. `true === false`) that other rules cover.
-	if noUnnecessaryBooleanLiteralCompareIsBoolLiteral(value) {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(value)
-	if t == nil {
-		return
-	}
-	// Only fire when the value side is pure boolean. A `boolean | null`
-	// operand uses the literal compare to strip nullability — leaving
-	// that intact is the explicit carve-out the rule documentation calls
-	// out, so we refuse to flag it.
-	if !noUnnecessaryBooleanLiteralCompareIsPureBoolean(t) {
-		return
-	}
-	ctx.Report(node, "This comparison against a boolean literal is unnecessary; use the value (or its negation) directly.")
+  if ctx.Checker == nil {
+    return
+  }
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+    return
+  }
+  // Only equality / inequality operators are subject to the rewrite —
+  // `<`, `>`, `&&`, etc. against `true` / `false` are not the same shape.
+  switch bin.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsToken,
+    shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken:
+  default:
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  if left == nil || right == nil {
+    return
+  }
+  // Identify which side is the literal and which side is the value.
+  // `true === x` and `x === true` are both reported.
+  var value *shimast.Node
+  switch {
+  case noUnnecessaryBooleanLiteralCompareIsBoolLiteral(left):
+    value = right
+  case noUnnecessaryBooleanLiteralCompareIsBoolLiteral(right):
+    value = left
+  default:
+    return
+  }
+  // Skip when both sides are literals — that's a different code smell
+  // (e.g. `true === false`) that other rules cover.
+  if noUnnecessaryBooleanLiteralCompareIsBoolLiteral(value) {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(value)
+  if t == nil {
+    return
+  }
+  // Only fire when the value side is pure boolean. A `boolean | null`
+  // operand uses the literal compare to strip nullability — leaving
+  // that intact is the explicit carve-out the rule documentation calls
+  // out, so we refuse to flag it.
+  if !noUnnecessaryBooleanLiteralCompareIsPureBoolean(t) {
+    return
+  }
+  ctx.Report(node, "This comparison against a boolean literal is unnecessary; use the value (or its negation) directly.")
 }
 
 // noUnnecessaryBooleanLiteralCompareIsBoolLiteral reports whether node is
 // the literal `true` or `false` keyword.
 func noUnnecessaryBooleanLiteralCompareIsBoolLiteral(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	return node.Kind == shimast.KindTrueKeyword || node.Kind == shimast.KindFalseKeyword
+  if node == nil {
+    return false
+  }
+  return node.Kind == shimast.KindTrueKeyword || node.Kind == shimast.KindFalseKeyword
 }
 
 // noUnnecessaryBooleanLiteralCompareIsPureBoolean reports whether t is a
@@ -95,35 +95,35 @@ func noUnnecessaryBooleanLiteralCompareIsBoolLiteral(node *shimast.Node) bool {
 // are explicitly excluded so the literal compare stays in place when it
 // is also stripping nullability or escaping an opaque value.
 func noUnnecessaryBooleanLiteralCompareIsPureBoolean(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.TypeFlagsUnion != 0 {
-		parts := t.Types()
-		if len(parts) == 0 {
-			return false
-		}
-		for _, part := range parts {
-			if part == nil {
-				return false
-			}
-			pf := part.Flags()
-			if pf&(shimchecker.TypeFlagsNull|shimchecker.TypeFlagsUndefined) != 0 {
-				return false
-			}
-			if pf&shimchecker.TypeFlagsBooleanLike == 0 {
-				return false
-			}
-		}
-		return true
-	}
-	return flags&shimchecker.TypeFlagsBooleanLike != 0
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return false
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    parts := t.Types()
+    if len(parts) == 0 {
+      return false
+    }
+    for _, part := range parts {
+      if part == nil {
+        return false
+      }
+      pf := part.Flags()
+      if pf&(shimchecker.TypeFlagsNull|shimchecker.TypeFlagsUndefined) != 0 {
+        return false
+      }
+      if pf&shimchecker.TypeFlagsBooleanLike == 0 {
+        return false
+      }
+    }
+    return true
+  }
+  return flags&shimchecker.TypeFlagsBooleanLike != 0
 }
 
 func init() {
-	Register(noUnnecessaryBooleanLiteralCompare{})
+  Register(noUnnecessaryBooleanLiteralCompare{})
 }