@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_ts_explicit_function_return_type.go

@@ -17,51 +17,51 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type explicitFunctionReturnType struct{}
 
 func (explicitFunctionReturnType) Name() string {
-	return "typescript/explicit-function-return-type"
+  return "typescript/explicit-function-return-type"
 }
 func (explicitFunctionReturnType) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindMethodDeclaration,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindMethodDeclaration,
+  }
 }
 func (explicitFunctionReturnType) Check(ctx *Context, node *shimast.Node) {
-	var typeNode *shimast.Node
-	switch node.Kind {
-	case shimast.KindFunctionDeclaration:
-		decl := node.AsFunctionDeclaration()
-		if decl == nil {
-			return
-		}
-		// Overload signatures (no body) already separate the return type
-		// onto each declaration; skip the implementation signature when
-		// it has no body either.
-		if decl.Body == nil {
-			return
-		}
-		typeNode = decl.Type
-	case shimast.KindMethodDeclaration:
-		decl := node.AsMethodDeclaration()
-		if decl == nil {
-			return
-		}
-		if decl.Body == nil {
-			return
-		}
-		typeNode = decl.Type
-	}
-	if typeNode != nil {
-		return
-	}
-	ctx.Report(node, "Missing return type on function — add an explicit return-type annotation.")
+  var typeNode *shimast.Node
+  switch node.Kind {
+  case shimast.KindFunctionDeclaration:
+    decl := node.AsFunctionDeclaration()
+    if decl == nil {
+      return
+    }
+    // Overload signatures (no body) already separate the return type
+    // onto each declaration; skip the implementation signature when
+    // it has no body either.
+    if decl.Body == nil {
+      return
+    }
+    typeNode = decl.Type
+  case shimast.KindMethodDeclaration:
+    decl := node.AsMethodDeclaration()
+    if decl == nil {
+      return
+    }
+    if decl.Body == nil {
+      return
+    }
+    typeNode = decl.Type
+  }
+  if typeNode != nil {
+    return
+  }
+  ctx.Report(node, "Missing return type on function — add an explicit return-type annotation.")
 }
 
 func init() {
-	Register(explicitFunctionReturnType{})
+  Register(explicitFunctionReturnType{})
 }

package/linthost/rules_ts_extra.go

@@ -173,7 +173,9 @@ func (noExtraNonNullAssertion) Check(ctx *Context, node *shimast.Node) {
 // undefined; asserting non-null on the whole chain defeats the chain.
 type noNonNullAssertedOptionalChain struct{}
 
-func (noNonNullAssertedOptionalChain) Name() string { return "typescript/no-non-null-asserted-optional-chain" }
+func (noNonNullAssertedOptionalChain) Name() string {
+  return "typescript/no-non-null-asserted-optional-chain"
+}
 func (noNonNullAssertedOptionalChain) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindNonNullExpression}
 }
@@ -711,7 +713,9 @@ func (arrayType) Check(ctx *Context, node *shimast.Node) {
 // `Record<string, T>`. ESLint default prefers `Record`.
 type consistentIndexedObjectStyle struct{}
 
-func (consistentIndexedObjectStyle) Name() string { return "typescript/consistent-indexed-object-style" }
+func (consistentIndexedObjectStyle) Name() string {
+  return "typescript/consistent-indexed-object-style"
+}
 func (consistentIndexedObjectStyle) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindTypeLiteral}
 }

package/linthost/rules_ts_no_base_to_string.go

@@ -22,87 +22,87 @@
 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 noBaseToString struct{}
 
 func (noBaseToString) Name() string { return "typescript/no-base-to-string" }
 func (noBaseToString) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noBaseToString) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindTemplateExpression,
-		shimast.KindBinaryExpression,
-		shimast.KindCallExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindTemplateExpression,
+    shimast.KindBinaryExpression,
+    shimast.KindCallExpression,
+  }
 }
 func (noBaseToString) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindTemplateExpression:
-		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
-			}
-			reportIfBaseToString(ctx, span.Expression)
-		}
-	case shimast.KindBinaryExpression:
-		bin := node.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil || bin.OperatorToken.Kind != shimast.KindPlusToken {
-			return
-		}
-		left := stripParens(bin.Left)
-		right := stripParens(bin.Right)
-		if left == nil || right == nil {
-			return
-		}
-		leftType := ctx.Checker.GetTypeAtLocation(left)
-		rightType := ctx.Checker.GetTypeAtLocation(right)
-		if isStringLikeType(leftType) {
-			if !isSafeToStringType(ctx.Checker, rightType) {
-				ctx.Report(right, baseToStringMessage)
-			}
-		} else if isStringLikeType(rightType) {
-			if !isSafeToStringType(ctx.Checker, leftType) {
-				ctx.Report(left, baseToStringMessage)
-			}
-		}
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil || call.Expression == nil || call.Arguments == nil {
-			return
-		}
-		if call.Expression.Kind != shimast.KindIdentifier || identifierText(call.Expression) != "String" {
-			return
-		}
-		if len(call.Arguments.Nodes) != 1 {
-			return
-		}
-		reportIfBaseToString(ctx, call.Arguments.Nodes[0])
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindTemplateExpression:
+    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
+      }
+      reportIfBaseToString(ctx, span.Expression)
+    }
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil || bin.OperatorToken.Kind != shimast.KindPlusToken {
+      return
+    }
+    left := stripParens(bin.Left)
+    right := stripParens(bin.Right)
+    if left == nil || right == nil {
+      return
+    }
+    leftType := ctx.Checker.GetTypeAtLocation(left)
+    rightType := ctx.Checker.GetTypeAtLocation(right)
+    if isStringLikeType(leftType) {
+      if !isSafeToStringType(ctx.Checker, rightType) {
+        ctx.Report(right, baseToStringMessage)
+      }
+    } else if isStringLikeType(rightType) {
+      if !isSafeToStringType(ctx.Checker, leftType) {
+        ctx.Report(left, baseToStringMessage)
+      }
+    }
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil || call.Expression == nil || call.Arguments == nil {
+      return
+    }
+    if call.Expression.Kind != shimast.KindIdentifier || identifierText(call.Expression) != "String" {
+      return
+    }
+    if len(call.Arguments.Nodes) != 1 {
+      return
+    }
+    reportIfBaseToString(ctx, call.Arguments.Nodes[0])
+  }
 }
 
 const baseToStringMessage = "Value implicitly coerces to '[object Object]'. Override `toString` or pass an explicit string representation."
 
 func reportIfBaseToString(ctx *Context, expr *shimast.Node) {
-	if expr == nil {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(expr)
-	if isSafeToStringType(ctx.Checker, t) {
-		return
-	}
-	ctx.Report(expr, baseToStringMessage)
+  if expr == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(expr)
+  if isSafeToStringType(ctx.Checker, t) {
+    return
+  }
+  ctx.Report(expr, baseToStringMessage)
 }
 
 // isStringLikeType reports whether t is provably string-typed (a
@@ -110,22 +110,22 @@ func reportIfBaseToString(ctx *Context, expr *shimast.Node) {
 // thereof). Used to decide whether the OTHER operand of a `+`
 // expression is being coerced.
 func isStringLikeType(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&shimchecker.TypeFlagsStringLike != 0 {
-		return true
-	}
-	if flags&shimchecker.TypeFlagsUnion != 0 {
-		for _, part := range t.Types() {
-			if !isStringLikeType(part) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsStringLike != 0 {
+    return true
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    for _, part := range t.Types() {
+      if !isStringLikeType(part) {
+        return false
+      }
+    }
+    return true
+  }
+  return false
 }
 
 // isSafeToStringType reports whether `t` can be implicitly coerced to a
@@ -136,38 +136,38 @@ func isStringLikeType(t *shimchecker.Type) bool {
 // because flagging them would explode at generic-helper boundaries —
 // the same conservatism `no-floating-promises` adopts.
 func isSafeToStringType(checker *shimchecker.Checker, t *shimchecker.Type) bool {
-	if checker == nil || t == nil {
-		return true
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
-		return true
-	}
-	if flags&(shimchecker.TypeFlagsStringLike|
-		shimchecker.TypeFlagsNumberLike|
-		shimchecker.TypeFlagsBigIntLike|
-		shimchecker.TypeFlagsBooleanLike|
-		shimchecker.TypeFlagsNull|
-		shimchecker.TypeFlagsUndefined) != 0 {
-		return true
-	}
-	if flags&shimchecker.TypeFlagsUnion != 0 {
-		for _, part := range t.Types() {
-			if !isSafeToStringType(checker, part) {
-				return false
-			}
-		}
-		return true
-	}
-	if flags&shimchecker.TypeFlagsIntersection != 0 {
-		for _, part := range t.Types() {
-			if isSafeToStringType(checker, part) {
-				return true
-			}
-		}
-		return false
-	}
-	return typeOverridesToString(checker, t)
+  if checker == nil || t == nil {
+    return true
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsStringLike|
+    shimchecker.TypeFlagsNumberLike|
+    shimchecker.TypeFlagsBigIntLike|
+    shimchecker.TypeFlagsBooleanLike|
+    shimchecker.TypeFlagsNull|
+    shimchecker.TypeFlagsUndefined) != 0 {
+    return true
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    for _, part := range t.Types() {
+      if !isSafeToStringType(checker, part) {
+        return false
+      }
+    }
+    return true
+  }
+  if flags&shimchecker.TypeFlagsIntersection != 0 {
+    for _, part := range t.Types() {
+      if isSafeToStringType(checker, part) {
+        return true
+      }
+    }
+    return false
+  }
+  return typeOverridesToString(checker, t)
 }
 
 // typeOverridesToString reports whether `t` carries a `toString` method
@@ -177,19 +177,19 @@ func isSafeToStringType(checker *shimchecker.Checker, t *shimchecker.Type) bool
 // `toString` is reachable at all the type is treated as base — the
 // only way to coerce it is the prototype-chain default.
 func typeOverridesToString(checker *shimchecker.Checker, t *shimchecker.Type) bool {
-	prop := checker.GetPropertyOfType(t, "toString")
-	if prop == nil {
-		return false
-	}
-	for _, decl := range prop.Declarations {
-		if decl == nil {
-			continue
-		}
-		if !isObjectToStringDeclaration(decl) {
-			return true
-		}
-	}
-	return false
+  prop := checker.GetPropertyOfType(t, "toString")
+  if prop == nil {
+    return false
+  }
+  for _, decl := range prop.Declarations {
+    if decl == nil {
+      continue
+    }
+    if !isObjectToStringDeclaration(decl) {
+      return true
+    }
+  }
+  return false
 }
 
 // isObjectToStringDeclaration reports whether `decl` is the
@@ -199,20 +199,20 @@ func typeOverridesToString(checker *shimchecker.Checker, t *shimchecker.Type) bo
 // declaration; anything else (Array, Date, Error, user classes, etc.)
 // counts as a real override.
 func isObjectToStringDeclaration(decl *shimast.Node) bool {
-	parent := decl.Parent
-	if parent == nil {
-		return false
-	}
-	if parent.Kind != shimast.KindInterfaceDeclaration {
-		return false
-	}
-	iface := parent.AsInterfaceDeclaration()
-	if iface == nil {
-		return false
-	}
-	return identifierText(iface.Name()) == "Object"
+  parent := decl.Parent
+  if parent == nil {
+    return false
+  }
+  if parent.Kind != shimast.KindInterfaceDeclaration {
+    return false
+  }
+  iface := parent.AsInterfaceDeclaration()
+  if iface == nil {
+    return false
+  }
+  return identifierText(iface.Name()) == "Object"
 }
 
 func init() {
-	Register(noBaseToString{})
+  Register(noBaseToString{})
 }

package/linthost/rules_ts_no_confusing_void.go

@@ -22,22 +22,22 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noConfusingVoidExpression struct{}
 
 func (noConfusingVoidExpression) Name() string {
-	return "typescript/no-confusing-void-expression"
+  return "typescript/no-confusing-void-expression"
 }
 func (noConfusingVoidExpression) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindVoidExpression}
+  return []shimast.Kind{shimast.KindVoidExpression}
 }
 func (noConfusingVoidExpression) Check(ctx *Context, node *shimast.Node) {
-	if isValidVoidExpressionPosition(node) {
-		return
-	}
-	ctx.Report(node, "Placing `void` operator in a value position is confusing — use it only as a statement, an arrow concise body, or inside another `void`.")
+  if isValidVoidExpressionPosition(node) {
+    return
+  }
+  ctx.Report(node, "Placing `void` operator in a value position is confusing — use it only as a statement, an arrow concise body, or inside another `void`.")
 }
 
 // isValidVoidExpressionPosition reports whether the `void X`
@@ -45,28 +45,28 @@ func (noConfusingVoidExpression) Check(ctx *Context, node *shimast.Node) {
 // Parenthesized expressions are transparent — `(void x)` keeps the
 // same effective context as `void x` for the surrounding code.
 func isValidVoidExpressionPosition(node *shimast.Node) bool {
-	parent := node.Parent
-	for parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
-		node = parent
-		parent = parent.Parent
-	}
-	if parent == nil {
-		return false
-	}
-	switch parent.Kind {
-	case shimast.KindExpressionStatement:
-		return true
-	case shimast.KindVoidExpression:
-		// `void void x` — the inner `void` is the operand of another
-		// `void`, which discards the result anyway.
-		return true
-	case shimast.KindArrowFunction:
-		arrow := parent.AsArrowFunction()
-		return arrow != nil && arrow.Body == node
-	}
-	return false
+  parent := node.Parent
+  for parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
+    node = parent
+    parent = parent.Parent
+  }
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindExpressionStatement:
+    return true
+  case shimast.KindVoidExpression:
+    // `void void x` — the inner `void` is the operand of another
+    // `void`, which discards the result anyway.
+    return true
+  case shimast.KindArrowFunction:
+    arrow := parent.AsArrowFunction()
+    return arrow != nil && arrow.Body == node
+  }
+  return false
 }
 
 func init() {
-	Register(noConfusingVoidExpression{})
+  Register(noConfusingVoidExpression{})
 }