@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_ts_related_getter_setter_pairs.go

@@ -24,72 +24,72 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type relatedGetterSetterPairs struct{}
 
 func (relatedGetterSetterPairs) Name() string {
-	return "typescript/related-getter-setter-pairs"
+  return "typescript/related-getter-setter-pairs"
 }
 func (relatedGetterSetterPairs) NeedsTypeChecker() bool { return true }
 func (relatedGetterSetterPairs) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindGetAccessor}
+  return []shimast.Kind{shimast.KindGetAccessor}
 }
 func (relatedGetterSetterPairs) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	parent := node.Parent
-	if parent == nil ||
-		(parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
-		return
-	}
-	getReturnType := node.Type()
-	if getReturnType == nil {
-		// No annotated return type — nothing to compare against.
-		return
-	}
-	name := classMemberName(node)
-	if name == "" {
-		return
-	}
-	setter := findClassSetterFor(parent, name)
-	if setter == nil {
-		return
-	}
-	setParamType := setterParameterType(setter)
-	if setParamType == nil {
-		return
-	}
-	getType := ctx.Checker.GetTypeFromTypeNode(getReturnType)
-	setType := ctx.Checker.GetTypeFromTypeNode(setParamType)
-	if getType == nil || setType == nil {
-		return
-	}
-	// Bidirectional assignability stands in for type identity — the
-	// same shape `no-unnecessary-type-assertion` uses. The accessor
-	// pair is safe only when reading and writing describe the same
-	// set of values.
-	if ctx.Checker.IsTypeAssignableTo(getType, setType) &&
-		ctx.Checker.IsTypeAssignableTo(setType, getType) {
-		return
-	}
-	ctx.Report(node, "Getter return type does not match the corresponding setter parameter type on `"+name+"`.")
+  if ctx.Checker == nil {
+    return
+  }
+  parent := node.Parent
+  if parent == nil ||
+    (parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
+    return
+  }
+  getReturnType := node.Type()
+  if getReturnType == nil {
+    // No annotated return type — nothing to compare against.
+    return
+  }
+  name := classMemberName(node)
+  if name == "" {
+    return
+  }
+  setter := findClassSetterFor(parent, name)
+  if setter == nil {
+    return
+  }
+  setParamType := setterParameterType(setter)
+  if setParamType == nil {
+    return
+  }
+  getType := ctx.Checker.GetTypeFromTypeNode(getReturnType)
+  setType := ctx.Checker.GetTypeFromTypeNode(setParamType)
+  if getType == nil || setType == nil {
+    return
+  }
+  // Bidirectional assignability stands in for type identity — the
+  // same shape `no-unnecessary-type-assertion` uses. The accessor
+  // pair is safe only when reading and writing describe the same
+  // set of values.
+  if ctx.Checker.IsTypeAssignableTo(getType, setType) &&
+    ctx.Checker.IsTypeAssignableTo(setType, getType) {
+    return
+  }
+  ctx.Report(node, "Getter return type does not match the corresponding setter parameter type on `"+name+"`.")
 }
 
 // findClassSetterFor returns the `set` accessor declared on `class`
 // whose name matches `name`, or nil when no such setter exists.
 func findClassSetterFor(class *shimast.Node, name string) *shimast.Node {
-	for _, member := range classMembers(class) {
-		if member == nil || member.Kind != shimast.KindSetAccessor {
-			continue
-		}
-		if classMemberName(member) == name {
-			return member
-		}
-	}
-	return nil
+  for _, member := range classMembers(class) {
+    if member == nil || member.Kind != shimast.KindSetAccessor {
+      continue
+    }
+    if classMemberName(member) == name {
+      return member
+    }
+  }
+  return nil
 }
 
 // setterParameterType returns the type-annotation node of a `set`
@@ -97,17 +97,17 @@ func findClassSetterFor(class *shimast.Node, name string) *shimast.Node {
 // parameter that carries no annotation, returns nil — the rule cannot
 // compare against an inferred type.
 func setterParameterType(setter *shimast.Node) *shimast.Node {
-	params := setter.Parameters()
-	if len(params) == 0 {
-		return nil
-	}
-	decl := params[0].AsParameterDeclaration()
-	if decl == nil {
-		return nil
-	}
-	return decl.Type
+  params := setter.Parameters()
+  if len(params) == 0 {
+    return nil
+  }
+  decl := params[0].AsParameterDeclaration()
+  if decl == nil {
+    return nil
+  }
+  return decl.Type
 }
 
 func init() {
-	Register(relatedGetterSetterPairs{})
+  Register(relatedGetterSetterPairs{})
 }

package/linthost/rules_ts_require_array_sort_compare.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"
 )
 
 // requireArraySortCompare reports `<arr>.sort()` and `<arr>.toSorted()`
@@ -19,42 +19,42 @@ import (
 type requireArraySortCompare struct{}
 
 func (requireArraySortCompare) Name() string {
-	return "typescript/require-array-sort-compare"
+  return "typescript/require-array-sort-compare"
 }
 func (requireArraySortCompare) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (requireArraySortCompare) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (requireArraySortCompare) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	// Only fire when the callee is a property access ending in `.sort`
-	// or `.toSorted` and the call passes zero arguments.
-	receiver, method, ok := promisePropertyAccessParts(call.Expression)
-	if !ok || (method != "sort" && method != "toSorted") {
-		return
-	}
-	if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
-		return
-	}
-	if receiver == nil {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(receiver)
-	if t == nil {
-		return
-	}
-	if !requireArraySortCompareIsArrayLike(ctx.Checker, t) {
-		return
-	}
-	ctx.Report(node, "Require an explicit compareFunction for `."+method+"()` — without one, elements are coerced to strings before being ordered.")
+  if ctx.Checker == nil {
+    return
+  }
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  // Only fire when the callee is a property access ending in `.sort`
+  // or `.toSorted` and the call passes zero arguments.
+  receiver, method, ok := promisePropertyAccessParts(call.Expression)
+  if !ok || (method != "sort" && method != "toSorted") {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    return
+  }
+  if receiver == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(receiver)
+  if t == nil {
+    return
+  }
+  if !requireArraySortCompareIsArrayLike(ctx.Checker, t) {
+    return
+  }
+  ctx.Report(node, "Require an explicit compareFunction for `."+method+"()` — without one, elements are coerced to strings before being ordered.")
 }
 
 // requireArraySortCompareIsArrayLike reports whether t is provably an
@@ -64,33 +64,33 @@ func (requireArraySortCompare) Check(ctx *Context, node *shimast.Node) {
 // are intentionally NOT treated as array-like — they propagate from
 // generic helpers and would explode the false-positive volume.
 func requireArraySortCompareIsArrayLike(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 !requireArraySortCompareIsArrayLike(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 !requireArraySortCompareIsArrayLike(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(requireArraySortCompare{})
+  Register(requireArraySortCompare{})
 }

package/linthost/rules_ts_restrict_plus_operands.go

@@ -9,8 +9,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"
 )
 
 // restrictPlusOperands fires on `<lhs> + <rhs>` when the operands are
@@ -24,42 +24,42 @@ type restrictPlusOperands struct{}
 
 func (restrictPlusOperands) Name() string { return "typescript/restrict-plus-operands" }
 func (restrictPlusOperands) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (restrictPlusOperands) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (restrictPlusOperands) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if expr.OperatorToken.Kind != shimast.KindPlusToken {
-		return
-	}
-	if expr.Left == nil || expr.Right == nil {
-		return
-	}
-	left := ctx.Checker.GetTypeAtLocation(expr.Left)
-	right := ctx.Checker.GetTypeAtLocation(expr.Right)
-	if left == nil || right == nil {
-		return
-	}
-	leftKind := restrictPlusOperandsKind(left)
-	rightKind := restrictPlusOperandsKind(right)
-	// Skip when either side is unconstrained (any / unknown / never /
-	// generic) — the rule would otherwise fire on every generic helper
-	// that accepts `T extends number | string`.
-	if leftKind == restrictPlusOperandsAny || rightKind == restrictPlusOperandsAny {
-		return
-	}
-	if leftKind == rightKind && leftKind != restrictPlusOperandsOther {
-		return
-	}
-	ctx.Report(node, "Operands of `+` must both be `number`, both `string`, or both `bigint`. Mixed or non-primitive operands are silently coerced by the runtime and almost always a bug.")
+  if ctx.Checker == nil {
+    return
+  }
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindPlusToken {
+    return
+  }
+  if expr.Left == nil || expr.Right == nil {
+    return
+  }
+  left := ctx.Checker.GetTypeAtLocation(expr.Left)
+  right := ctx.Checker.GetTypeAtLocation(expr.Right)
+  if left == nil || right == nil {
+    return
+  }
+  leftKind := restrictPlusOperandsKind(left)
+  rightKind := restrictPlusOperandsKind(right)
+  // Skip when either side is unconstrained (any / unknown / never /
+  // generic) — the rule would otherwise fire on every generic helper
+  // that accepts `T extends number | string`.
+  if leftKind == restrictPlusOperandsAny || rightKind == restrictPlusOperandsAny {
+    return
+  }
+  if leftKind == rightKind && leftKind != restrictPlusOperandsOther {
+    return
+  }
+  ctx.Report(node, "Operands of `+` must both be `number`, both `string`, or both `bigint`. Mixed or non-primitive operands are silently coerced by the runtime and almost always a bug.")
 }
 
 // restrictPlusOperandsKind classifies t as one of the four buckets the
@@ -70,58 +70,58 @@ func (restrictPlusOperands) Check(ctx *Context, node *shimast.Node) {
 type restrictPlusOperandsBucket int
 
 const (
-	restrictPlusOperandsOther restrictPlusOperandsBucket = iota
-	restrictPlusOperandsAny
-	restrictPlusOperandsNumber
-	restrictPlusOperandsString
-	restrictPlusOperandsBigInt
+  restrictPlusOperandsOther restrictPlusOperandsBucket = iota
+  restrictPlusOperandsAny
+  restrictPlusOperandsNumber
+  restrictPlusOperandsString
+  restrictPlusOperandsBigInt
 )
 
 func restrictPlusOperandsKind(t *shimchecker.Type) restrictPlusOperandsBucket {
-	if t == nil {
-		return restrictPlusOperandsOther
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
-		return restrictPlusOperandsAny
-	}
-	if flags&shimchecker.TypeFlagsStringLike != 0 {
-		return restrictPlusOperandsString
-	}
-	if flags&shimchecker.TypeFlagsNumberLike != 0 {
-		return restrictPlusOperandsNumber
-	}
-	if flags&shimchecker.TypeFlagsBigIntLike != 0 {
-		return restrictPlusOperandsBigInt
-	}
-	if flags&shimchecker.TypeFlagsUnion != 0 {
-		var seen restrictPlusOperandsBucket
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			kind := restrictPlusOperandsKind(part)
-			if kind == restrictPlusOperandsAny {
-				return restrictPlusOperandsAny
-			}
-			if kind == restrictPlusOperandsOther {
-				return restrictPlusOperandsOther
-			}
-			if seen == 0 {
-				seen = kind
-				continue
-			}
-			if seen != kind {
-				return restrictPlusOperandsOther
-			}
-		}
-		if seen != 0 {
-			return seen
-		}
-	}
-	return restrictPlusOperandsOther
+  if t == nil {
+    return restrictPlusOperandsOther
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return restrictPlusOperandsAny
+  }
+  if flags&shimchecker.TypeFlagsStringLike != 0 {
+    return restrictPlusOperandsString
+  }
+  if flags&shimchecker.TypeFlagsNumberLike != 0 {
+    return restrictPlusOperandsNumber
+  }
+  if flags&shimchecker.TypeFlagsBigIntLike != 0 {
+    return restrictPlusOperandsBigInt
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    var seen restrictPlusOperandsBucket
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      kind := restrictPlusOperandsKind(part)
+      if kind == restrictPlusOperandsAny {
+        return restrictPlusOperandsAny
+      }
+      if kind == restrictPlusOperandsOther {
+        return restrictPlusOperandsOther
+      }
+      if seen == 0 {
+        seen = kind
+        continue
+      }
+      if seen != kind {
+        return restrictPlusOperandsOther
+      }
+    }
+    if seen != 0 {
+      return seen
+    }
+  }
+  return restrictPlusOperandsOther
 }
 
 func init() {
-	Register(restrictPlusOperands{})
+  Register(restrictPlusOperands{})
 }

package/linthost/rules_ts_restrict_template_expressions.go

@@ -10,8 +10,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"
 )
 
 // restrictTemplateExpressions reports each `${expr}` span inside a
@@ -27,36 +27,36 @@ import (
 type restrictTemplateExpressions struct{}
 
 func (restrictTemplateExpressions) Name() string {
-	return "typescript/restrict-template-expressions"
+  return "typescript/restrict-template-expressions"
 }
 func (restrictTemplateExpressions) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (restrictTemplateExpressions) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindTemplateExpression}
+  return []shimast.Kind{shimast.KindTemplateExpression}
 }
 func (restrictTemplateExpressions) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	expr := node.AsTemplateExpression()
-	if expr == nil || expr.TemplateSpans == nil {
-		return
-	}
-	for _, spanNode := range expr.TemplateSpans.Nodes {
-		span := spanNode.AsTemplateSpan()
-		if span == nil || span.Expression == nil {
-			continue
-		}
-		t := ctx.Checker.GetTypeAtLocation(span.Expression)
-		if t == nil {
-			continue
-		}
-		if restrictTemplateExpressionsIsStringy(ctx.Checker, t) {
-			continue
-		}
-		ctx.Report(span.Expression, "Template interpolations must be string-like (`string`, `number`, `bigint`, or `boolean`) — convert the value explicitly to avoid coercing to `\"[object Object]\"`, `\"null\"`, or `\"undefined\"`.")
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  expr := node.AsTemplateExpression()
+  if expr == nil || expr.TemplateSpans == nil {
+    return
+  }
+  for _, spanNode := range expr.TemplateSpans.Nodes {
+    span := spanNode.AsTemplateSpan()
+    if span == nil || span.Expression == nil {
+      continue
+    }
+    t := ctx.Checker.GetTypeAtLocation(span.Expression)
+    if t == nil {
+      continue
+    }
+    if restrictTemplateExpressionsIsStringy(ctx.Checker, t) {
+      continue
+    }
+    ctx.Report(span.Expression, "Template interpolations must be string-like (`string`, `number`, `bigint`, or `boolean`) — convert the value explicitly to avoid coercing to `\"[object Object]\"`, `\"null\"`, or `\"undefined\"`.")
+  }
 }
 
 // restrictTemplateExpressionsIsStringy reports whether t is safe to
@@ -65,31 +65,31 @@ func (restrictTemplateExpressions) Check(ctx *Context, node *shimast.Node) {
 // `any` / `unknown` / `never` pass through (return true) so generic
 // helpers propagate without lighting up the rule everywhere.
 func restrictTemplateExpressionsIsStringy(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 true
-	}
-	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			if !restrictTemplateExpressionsIsStringy(checker, part) {
-				return false
-			}
-		}
-		return true
-	}
-	const stringyMask = shimchecker.TypeFlagsStringLike |
-		shimchecker.TypeFlagsNumberLike |
-		shimchecker.TypeFlagsBigIntLike |
-		shimchecker.TypeFlagsBooleanLike
-	return flags&stringyMask != 0
+  if checker == nil || t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if !restrictTemplateExpressionsIsStringy(checker, part) {
+        return false
+      }
+    }
+    return true
+  }
+  const stringyMask = shimchecker.TypeFlagsStringLike |
+    shimchecker.TypeFlagsNumberLike |
+    shimchecker.TypeFlagsBigIntLike |
+    shimchecker.TypeFlagsBooleanLike
+  return flags&stringyMask != 0
 }
 
 func init() {
-	Register(restrictTemplateExpressions{})
+  Register(restrictTemplateExpressions{})
 }