@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_ts_no_deprecated.go

@@ -28,65 +28,65 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noDeprecated struct{}
 
 func (noDeprecated) Name() string { return "typescript/no-deprecated" }
 func (noDeprecated) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noDeprecated) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindIdentifier,
-		shimast.KindPropertyAccessExpression,
-		shimast.KindCallExpression,
-		shimast.KindNewExpression,
-		shimast.KindJsxOpeningElement,
-		shimast.KindJsxSelfClosingElement,
-	}
+  return []shimast.Kind{
+    shimast.KindIdentifier,
+    shimast.KindPropertyAccessExpression,
+    shimast.KindCallExpression,
+    shimast.KindNewExpression,
+    shimast.KindJsxOpeningElement,
+    shimast.KindJsxSelfClosingElement,
+  }
 }
 func (noDeprecated) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	// All non-identifier kinds delegate to the identifier walk for
-	// reporting — they're listed in Visits() to keep the contract
-	// explicit about which structural shapes carry symbol references,
-	// but the actual diagnostic is emitted once per identifier so a
-	// chain like `obj.method()` reports the `method` identifier, not
-	// the surrounding PropertyAccess and CallExpression as well.
-	if node.Kind != shimast.KindIdentifier {
-		return
-	}
-	if noDeprecatedSkipIdentifier(node) {
-		return
-	}
-	symbol := ctx.Checker.GetSymbolAtLocation(node)
-	if symbol == nil {
-		return
-	}
-	tag := findDeprecatedJSDocTag(symbol)
-	if tag == nil {
-		return
-	}
-	// Don't report when this identifier IS the name of one of the
-	// symbol's declarations — that's the deprecation marker itself.
-	if noDeprecatedLocationIsDeclarationName(node, symbol) {
-		return
-	}
-	name := identifierText(node)
-	if name == "" {
-		name = symbol.Name
-	}
-	message := "`" + name + "` is deprecated."
-	if comment := jsdocDeprecatedComment(tag); comment != "" {
-		message = message + " " + comment
-	}
-	ctx.Report(node, message)
+  if ctx.Checker == nil {
+    return
+  }
+  // All non-identifier kinds delegate to the identifier walk for
+  // reporting — they're listed in Visits() to keep the contract
+  // explicit about which structural shapes carry symbol references,
+  // but the actual diagnostic is emitted once per identifier so a
+  // chain like `obj.method()` reports the `method` identifier, not
+  // the surrounding PropertyAccess and CallExpression as well.
+  if node.Kind != shimast.KindIdentifier {
+    return
+  }
+  if noDeprecatedSkipIdentifier(node) {
+    return
+  }
+  symbol := ctx.Checker.GetSymbolAtLocation(node)
+  if symbol == nil {
+    return
+  }
+  tag := findDeprecatedJSDocTag(symbol)
+  if tag == nil {
+    return
+  }
+  // Don't report when this identifier IS the name of one of the
+  // symbol's declarations — that's the deprecation marker itself.
+  if noDeprecatedLocationIsDeclarationName(node, symbol) {
+    return
+  }
+  name := identifierText(node)
+  if name == "" {
+    name = symbol.Name
+  }
+  message := "`" + name + "` is deprecated."
+  if comment := jsdocDeprecatedComment(tag); comment != "" {
+    message = message + " " + comment
+  }
+  ctx.Report(node, message)
 }
 
 // noDeprecatedSkipIdentifier reports whether an identifier visit
@@ -100,35 +100,35 @@ func (noDeprecated) Check(ctx *Context, node *shimast.Node) {
 // `noDeprecatedLocationIsDeclarationName` — which handles every
 // declaration kind without enumerating each one here.
 func noDeprecatedSkipIdentifier(node *shimast.Node) bool {
-	parent := node.Parent
-	if parent == nil {
-		return false
-	}
-	if parent.Kind == shimast.KindQualifiedName {
-		qn := parent.AsQualifiedName()
-		if qn != nil && qn.Left == node {
-			return true
-		}
-	}
-	return false
+  parent := node.Parent
+  if parent == nil {
+    return false
+  }
+  if parent.Kind == shimast.KindQualifiedName {
+    qn := parent.AsQualifiedName()
+    if qn != nil && qn.Left == node {
+      return true
+    }
+  }
+  return false
 }
 
 // noDeprecatedLocationIsDeclarationName reports whether `loc` is the
 // name node of one of `symbol`'s declarations — i.e. the deprecation
 // marker itself rather than a reference site.
 func noDeprecatedLocationIsDeclarationName(loc *shimast.Node, symbol *shimast.Symbol) bool {
-	if loc == nil || symbol == nil {
-		return false
-	}
-	for _, decl := range symbol.Declarations {
-		if decl == nil {
-			continue
-		}
-		if decl.Name() == loc {
-			return true
-		}
-	}
-	return false
+  if loc == nil || symbol == nil {
+    return false
+  }
+  for _, decl := range symbol.Declarations {
+    if decl == nil {
+      continue
+    }
+    if decl.Name() == loc {
+      return true
+    }
+  }
+  return false
 }
 
 // findDeprecatedJSDocTag walks the symbol's declarations for a
@@ -138,58 +138,58 @@ func noDeprecatedLocationIsDeclarationName(loc *shimast.Node, symbol *shimast.Sy
 // VariableStatement, and JSDoc on an ExportSpecifier may be on the
 // outer ExportDeclaration.
 func findDeprecatedJSDocTag(symbol *shimast.Symbol) *shimast.Node {
-	if symbol == nil {
-		return nil
-	}
-	for _, decl := range symbol.Declarations {
-		if tag := deprecatedJSDocTagOnNodeOrAncestors(decl); tag != nil {
-			return tag
-		}
-	}
-	return nil
+  if symbol == nil {
+    return nil
+  }
+  for _, decl := range symbol.Declarations {
+    if tag := deprecatedJSDocTagOnNodeOrAncestors(decl); tag != nil {
+      return tag
+    }
+  }
+  return nil
 }
 
 // deprecatedJSDocTagOnNodeOrAncestors walks up from `node` looking for
 // a `@deprecated` JSDoc tag attached to any ancestor. Returns the
 // first matching tag, or nil.
 func deprecatedJSDocTagOnNodeOrAncestors(node *shimast.Node) *shimast.Node {
-	for n := node; n != nil; n = n.Parent {
-		for _, jsdoc := range n.JSDoc(nil) {
-			data := jsdoc.AsJSDoc()
-			if data == nil || data.Tags == nil {
-				continue
-			}
-			for _, tag := range data.Tags.Nodes {
-				if tag.Kind == shimast.KindJSDocDeprecatedTag {
-					return tag
-				}
-			}
-		}
-		if n.Kind == shimast.KindSourceFile {
-			return nil
-		}
-	}
-	return nil
+  for n := node; n != nil; n = n.Parent {
+    for _, jsdoc := range n.JSDoc(nil) {
+      data := jsdoc.AsJSDoc()
+      if data == nil || data.Tags == nil {
+        continue
+      }
+      for _, tag := range data.Tags.Nodes {
+        if tag.Kind == shimast.KindJSDocDeprecatedTag {
+          return tag
+        }
+      }
+    }
+    if n.Kind == shimast.KindSourceFile {
+      return nil
+    }
+  }
+  return nil
 }
 
 // jsdocDeprecatedComment returns the textual comment that follows the
 // `@deprecated` token in `tag`'s source range, trimmed of surrounding
 // whitespace. Empty when the tag has no comment.
 func jsdocDeprecatedComment(tag *shimast.Node) string {
-	if tag == nil {
-		return ""
-	}
-	src := strings.TrimSpace(shimast.NodeText(tag))
-	if src == "" {
-		return ""
-	}
-	const prefix = "@deprecated"
-	if strings.HasPrefix(src, prefix) {
-		src = src[len(prefix):]
-	}
-	return strings.TrimSpace(src)
+  if tag == nil {
+    return ""
+  }
+  src := strings.TrimSpace(shimast.NodeText(tag))
+  if src == "" {
+    return ""
+  }
+  const prefix = "@deprecated"
+  if strings.HasPrefix(src, prefix) {
+    src = src[len(prefix):]
+  }
+  return strings.TrimSpace(src)
 }
 
 func init() {
-	Register(noDeprecated{})
+  Register(noDeprecated{})
 }

package/linthost/rules_ts_no_for_in_array.go

@@ -7,8 +7,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"
 )
 
 // noForInArray fires on `for (... in <expr>)` when the Checker reports that
@@ -21,27 +21,27 @@ type noForInArray struct{}
 
 func (noForInArray) Name() string { return "typescript/no-for-in-array" }
 func (noForInArray) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noForInArray) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindForInStatement}
+  return []shimast.Kind{shimast.KindForInStatement}
 }
 func (noForInArray) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	stmt := node.AsForInOrOfStatement()
-	if stmt == nil || stmt.Expression == nil {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(stmt.Expression)
-	if t == nil {
-		return
-	}
-	if !noForInArrayIsArrayLike(ctx.Checker, t) {
-		return
-	}
-	ctx.Report(node, "Iterating an array with `for...in` yields enumerable property names (as strings), including inherited members. Use `for...of`, `forEach`, or an indexed `for` loop instead.")
+  if ctx.Checker == nil {
+    return
+  }
+  stmt := node.AsForInOrOfStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(stmt.Expression)
+  if t == nil {
+    return
+  }
+  if !noForInArrayIsArrayLike(ctx.Checker, t) {
+    return
+  }
+  ctx.Report(node, "Iterating an array with `for...in` yields enumerable property names (as strings), including inherited members. Use `for...of`, `forEach`, or an indexed `for` loop instead.")
 }
 
 // noForInArrayIsArrayLike reports whether t is provably an array or tuple.
@@ -52,33 +52,33 @@ func (noForInArray) Check(ctx *Context, node *shimast.Node) {
 // the false-positive volume on otherwise legitimate `for...in` over a
 // genuinely-keyed object.
 func noForInArrayIsArrayLike(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 !noForInArrayIsArrayLike(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 !noForInArrayIsArrayLike(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(noForInArray{})
+  Register(noForInArray{})
 }

package/linthost/rules_ts_no_magic_numbers.go

@@ -22,48 +22,48 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type tsNoMagicNumbers struct{}
 
 func (tsNoMagicNumbers) Name() string { return "typescript/no-magic-numbers" }
 func (tsNoMagicNumbers) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNumericLiteral}
+  return []shimast.Kind{shimast.KindNumericLiteral}
 }
 func (tsNoMagicNumbers) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	// Identify the surface node that represents the numeric value:
-	// either the literal itself or the wrapping `+lit` / `-lit` unary.
-	surface := node
-	if parent := node.Parent; parent != nil && parent.Kind == shimast.KindPrefixUnaryExpression {
-		prefix := parent.AsPrefixUnaryExpression()
-		if prefix != nil && (prefix.Operator == shimast.KindMinusToken || prefix.Operator == shimast.KindPlusToken) && prefix.Operand == node {
-			surface = parent
-		}
-	}
-	// Skip when the literal lives inside a type position. A literal type
-	// (`type N = 5`, `Array<10>`) is not a runtime constant — the
-	// rule's concern is unexplained runtime values.
-	if isInsideTypePosition(surface) {
-		return
-	}
-	// TS extension: enum member initializers are themselves the named
-	// constant the rule is asking for. `enum S { OK = 200 }` lifts the
-	// value into `S.OK`; flagging the `200` would push authors to
-	// double-wrap an already-named constant.
-	if isEnumMemberInitializer(surface) {
-		return
-	}
-	// Whitelisted unit values: -1 / 0 / 1 carry intrinsic meaning (not
-	// found, identity, step) in almost every codebase. Treating them as
-	// magic produces only noise.
-	if isWellKnownUnitNumber(ctx.File, surface) {
-		return
-	}
-	ctx.Report(surface, "No magic number: extract into a named constant or enum member.")
+  if node == nil {
+    return
+  }
+  // Identify the surface node that represents the numeric value:
+  // either the literal itself or the wrapping `+lit` / `-lit` unary.
+  surface := node
+  if parent := node.Parent; parent != nil && parent.Kind == shimast.KindPrefixUnaryExpression {
+    prefix := parent.AsPrefixUnaryExpression()
+    if prefix != nil && (prefix.Operator == shimast.KindMinusToken || prefix.Operator == shimast.KindPlusToken) && prefix.Operand == node {
+      surface = parent
+    }
+  }
+  // Skip when the literal lives inside a type position. A literal type
+  // (`type N = 5`, `Array<10>`) is not a runtime constant — the
+  // rule's concern is unexplained runtime values.
+  if isInsideTypePosition(surface) {
+    return
+  }
+  // TS extension: enum member initializers are themselves the named
+  // constant the rule is asking for. `enum S { OK = 200 }` lifts the
+  // value into `S.OK`; flagging the `200` would push authors to
+  // double-wrap an already-named constant.
+  if isEnumMemberInitializer(surface) {
+    return
+  }
+  // Whitelisted unit values: -1 / 0 / 1 carry intrinsic meaning (not
+  // found, identity, step) in almost every codebase. Treating them as
+  // magic produces only noise.
+  if isWellKnownUnitNumber(ctx.File, surface) {
+    return
+  }
+  ctx.Report(surface, "No magic number: extract into a named constant or enum member.")
 }
 
 // isEnumMemberInitializer reports whether surface is the initializer
@@ -71,12 +71,12 @@ func (tsNoMagicNumbers) Check(ctx *Context, node *shimast.Node) {
 // itself (or its unary wrapper) is the EnumMember.Initializer in that
 // case, which is exactly the position the TS extension whitelists.
 func isEnumMemberInitializer(surface *shimast.Node) bool {
-	parent := surface.Parent
-	if parent == nil || parent.Kind != shimast.KindEnumMember {
-		return false
-	}
-	member := parent.AsEnumMember()
-	return member != nil && member.Initializer == surface
+  parent := surface.Parent
+  if parent == nil || parent.Kind != shimast.KindEnumMember {
+    return false
+  }
+  member := parent.AsEnumMember()
+  return member != nil && member.Initializer == surface
 }
 
 // isInsideTypePosition reports whether `surface` is reached only
@@ -84,26 +84,26 @@ func isEnumMemberInitializer(surface *shimast.Node) bool {
 // Literal types, type arguments, and type aliases are type positions;
 // the rule has nothing to say about literals that never reach runtime.
 func isInsideTypePosition(surface *shimast.Node) bool {
-	for p := surface.Parent; p != nil; p = p.Parent {
-		switch p.Kind {
-		case shimast.KindLiteralType,
-			shimast.KindTypeReference,
-			shimast.KindTypeAliasDeclaration,
-			shimast.KindUnionType,
-			shimast.KindIntersectionType,
-			shimast.KindTypeOperator,
-			shimast.KindIndexedAccessType,
-			shimast.KindMappedType,
-			shimast.KindConditionalType,
-			shimast.KindTypeParameter:
-			return true
-		case shimast.KindPrefixUnaryExpression,
-			shimast.KindParenthesizedExpression:
-			continue
-		}
-		return false
-	}
-	return false
+  for p := surface.Parent; p != nil; p = p.Parent {
+    switch p.Kind {
+    case shimast.KindLiteralType,
+      shimast.KindTypeReference,
+      shimast.KindTypeAliasDeclaration,
+      shimast.KindUnionType,
+      shimast.KindIntersectionType,
+      shimast.KindTypeOperator,
+      shimast.KindIndexedAccessType,
+      shimast.KindMappedType,
+      shimast.KindConditionalType,
+      shimast.KindTypeParameter:
+      return true
+    case shimast.KindPrefixUnaryExpression,
+      shimast.KindParenthesizedExpression:
+      continue
+    }
+    return false
+  }
+  return false
 }
 
 // isWellKnownUnitNumber reports whether `surface` is the literal `0`,
@@ -111,14 +111,14 @@ func isInsideTypePosition(surface *shimast.Node) bool {
 // vs `0` and `1e0` vs `1` consistent with what the author actually
 // wrote — only the bare textual form is whitelisted.
 func isWellKnownUnitNumber(file *shimast.SourceFile, surface *shimast.Node) bool {
-	text := nodeText(file, surface)
-	switch text {
-	case "0", "1", "-1":
-		return true
-	}
-	return false
+  text := nodeText(file, surface)
+  switch text {
+  case "0", "1", "-1":
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(tsNoMagicNumbers{})
+  Register(tsNoMagicNumbers{})
 }

package/linthost/rules_ts_no_meaningless_void_operator.go

@@ -16,39 +16,39 @@
 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 noMeaninglessVoidOperator struct{}
 
 func (noMeaninglessVoidOperator) Name() string {
-	return "typescript/no-meaningless-void-operator"
+  return "typescript/no-meaningless-void-operator"
 }
 func (noMeaninglessVoidOperator) NeedsTypeChecker() bool { return true }
 func (noMeaninglessVoidOperator) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindVoidExpression}
+  return []shimast.Kind{shimast.KindVoidExpression}
 }
 func (noMeaninglessVoidOperator) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	expr := node.AsVoidExpression()
-	if expr == nil || expr.Expression == nil {
-		return
-	}
-	operand := stripParens(expr.Expression)
-	if operand == nil {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(operand)
-	if t == nil {
-		return
-	}
-	if !isVoidOnlyType(t) {
-		return
-	}
-	ctx.Report(node, "The `void` operator on a value already typed `void` adds nothing — drop the operator.")
+  if ctx.Checker == nil {
+    return
+  }
+  expr := node.AsVoidExpression()
+  if expr == nil || expr.Expression == nil {
+    return
+  }
+  operand := stripParens(expr.Expression)
+  if operand == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(operand)
+  if t == nil {
+    return
+  }
+  if !isVoidOnlyType(t) {
+    return
+  }
+  ctx.Report(node, "The `void` operator on a value already typed `void` adds nothing — drop the operator.")
 }
 
 // isVoidOnlyType reports whether t is the bare `void` type or a union
@@ -57,28 +57,28 @@ func (noMeaninglessVoidOperator) Check(ctx *Context, node *shimast.Node) {
 // number` operand still needs the operator to discard the runtime
 // value, so it is left alone.
 func isVoidOnlyType(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&shimchecker.TypeFlagsVoid != 0 {
-		return true
-	}
-	if flags&shimchecker.TypeFlagsUnion != 0 {
-		parts := t.Types()
-		if len(parts) == 0 {
-			return false
-		}
-		for _, part := range parts {
-			if !isVoidOnlyType(part) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsVoid != 0 {
+    return true
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    parts := t.Types()
+    if len(parts) == 0 {
+      return false
+    }
+    for _, part := range parts {
+      if !isVoidOnlyType(part) {
+        return false
+      }
+    }
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(noMeaninglessVoidOperator{})
+  Register(noMeaninglessVoidOperator{})
 }