@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_ts_no_unsafe_argument.go

@@ -14,69 +14,69 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noUnsafeArgument struct{}
 
 func (noUnsafeArgument) Name() string { return "typescript/no-unsafe-argument" }
 func (noUnsafeArgument) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnsafeArgument) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindCallExpression,
-		shimast.KindNewExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindCallExpression,
+    shimast.KindNewExpression,
+  }
 }
 func (noUnsafeArgument) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	var callee *shimast.Node
-	var args []*shimast.Node
-	switch node.Kind {
-	case shimast.KindCallExpression:
-		if call := node.AsCallExpression(); call != nil {
-			callee = call.Expression
-			if call.Arguments != nil {
-				args = call.Arguments.Nodes
-			}
-		}
-	case shimast.KindNewExpression:
-		if ne := node.AsNewExpression(); ne != nil {
-			callee = ne.Expression
-			if ne.Arguments != nil {
-				args = ne.Arguments.Nodes
-			}
-		}
-	}
-	if callee == nil || len(args) == 0 {
-		return
-	}
-	calleeType := ctx.Checker.GetTypeAtLocation(callee)
-	if calleeType == nil || typeIsUnsafeAny(calleeType) {
-		// Callee itself is `any` — no-unsafe-call handles that.
-		return
-	}
-	for _, arg := range args {
-		if arg == nil {
-			continue
-		}
-		stripped := stripParens(arg)
-		if stripped == nil {
-			continue
-		}
-		argType := ctx.Checker.GetTypeAtLocation(stripped)
-		if !typeIsUnsafeAny(argType) {
-			continue
-		}
-		ctx.Report(arg, noUnsafeArgumentMessage)
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  var callee *shimast.Node
+  var args []*shimast.Node
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    if call := node.AsCallExpression(); call != nil {
+      callee = call.Expression
+      if call.Arguments != nil {
+        args = call.Arguments.Nodes
+      }
+    }
+  case shimast.KindNewExpression:
+    if ne := node.AsNewExpression(); ne != nil {
+      callee = ne.Expression
+      if ne.Arguments != nil {
+        args = ne.Arguments.Nodes
+      }
+    }
+  }
+  if callee == nil || len(args) == 0 {
+    return
+  }
+  calleeType := ctx.Checker.GetTypeAtLocation(callee)
+  if calleeType == nil || typeIsUnsafeAny(calleeType) {
+    // Callee itself is `any` — no-unsafe-call handles that.
+    return
+  }
+  for _, arg := range args {
+    if arg == nil {
+      continue
+    }
+    stripped := stripParens(arg)
+    if stripped == nil {
+      continue
+    }
+    argType := ctx.Checker.GetTypeAtLocation(stripped)
+    if !typeIsUnsafeAny(argType) {
+      continue
+    }
+    ctx.Report(arg, noUnsafeArgumentMessage)
+  }
 }
 
 const noUnsafeArgumentMessage = "Unsafe passing of a value typed as `any` into a typed parameter. Narrow the value before forwarding it."
 
 func init() {
-	Register(noUnsafeArgument{})
+  Register(noUnsafeArgument{})
 }

package/linthost/rules_ts_no_unsafe_assignment.go

@@ -24,79 +24,79 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noUnsafeAssignment struct{}
 
 func (noUnsafeAssignment) Name() string { return "typescript/no-unsafe-assignment" }
 func (noUnsafeAssignment) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnsafeAssignment) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindVariableDeclaration,
-		shimast.KindBinaryExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindVariableDeclaration,
+    shimast.KindBinaryExpression,
+  }
 }
 func (noUnsafeAssignment) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindVariableDeclaration:
-		decl := node.AsVariableDeclaration()
-		if decl == nil || decl.Initializer == nil {
-			return
-		}
-		// Only flag when the target has an explicit type annotation —
-		// `const x = anyValue;` widens `x` to `any` too, which is the
-		// `no-explicit-any` family's concern, not this rule's.
-		if decl.Type == nil {
-			return
-		}
-		rhs := stripParens(decl.Initializer)
-		if rhs == nil {
-			return
-		}
-		rhsType := ctx.Checker.GetTypeAtLocation(rhs)
-		if !typeIsUnsafeAny(rhsType) {
-			return
-		}
-		lhsType := ctx.Checker.GetTypeFromTypeNode(decl.Type)
-		if typeIsUnsafeAny(lhsType) {
-			return
-		}
-		ctx.Report(node, noUnsafeAssignmentMessage)
-	case shimast.KindBinaryExpression:
-		bin := node.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil {
-			return
-		}
-		if bin.OperatorToken.Kind != shimast.KindEqualsToken {
-			return
-		}
-		if bin.Left == nil || bin.Right == nil {
-			return
-		}
-		rhs := stripParens(bin.Right)
-		if rhs == nil {
-			return
-		}
-		rhsType := ctx.Checker.GetTypeAtLocation(rhs)
-		if !typeIsUnsafeAny(rhsType) {
-			return
-		}
-		lhsType := ctx.Checker.GetTypeAtLocation(bin.Left)
-		if typeIsUnsafeAny(lhsType) {
-			return
-		}
-		ctx.Report(node, noUnsafeAssignmentMessage)
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindVariableDeclaration:
+    decl := node.AsVariableDeclaration()
+    if decl == nil || decl.Initializer == nil {
+      return
+    }
+    // Only flag when the target has an explicit type annotation —
+    // `const x = anyValue;` widens `x` to `any` too, which is the
+    // `no-explicit-any` family's concern, not this rule's.
+    if decl.Type == nil {
+      return
+    }
+    rhs := stripParens(decl.Initializer)
+    if rhs == nil {
+      return
+    }
+    rhsType := ctx.Checker.GetTypeAtLocation(rhs)
+    if !typeIsUnsafeAny(rhsType) {
+      return
+    }
+    lhsType := ctx.Checker.GetTypeFromTypeNode(decl.Type)
+    if typeIsUnsafeAny(lhsType) {
+      return
+    }
+    ctx.Report(node, noUnsafeAssignmentMessage)
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return
+    }
+    if bin.OperatorToken.Kind != shimast.KindEqualsToken {
+      return
+    }
+    if bin.Left == nil || bin.Right == nil {
+      return
+    }
+    rhs := stripParens(bin.Right)
+    if rhs == nil {
+      return
+    }
+    rhsType := ctx.Checker.GetTypeAtLocation(rhs)
+    if !typeIsUnsafeAny(rhsType) {
+      return
+    }
+    lhsType := ctx.Checker.GetTypeAtLocation(bin.Left)
+    if typeIsUnsafeAny(lhsType) {
+      return
+    }
+    ctx.Report(node, noUnsafeAssignmentMessage)
+  }
 }
 
 const noUnsafeAssignmentMessage = "Unsafe assignment of a value typed as `any` to a typed target. Narrow the value before storing it."
 
 func init() {
-	Register(noUnsafeAssignment{})
+  Register(noUnsafeAssignment{})
 }

package/linthost/rules_ts_no_unsafe_call.go

@@ -6,7 +6,7 @@
 // https://typescript-eslint.io/rules/no-unsafe-call/
 //
 // Type-aware. The rule visits the three syntactic invocation shapes —
-// `f(...)`, `new F(...)`, and the tagged-template form `f` + ``"x"`` —
+// `f(...)`, `new F(...)`, and the tagged-template form `f` + “"x"“ —
 // and reports when the callee resolves to a type whose flags include
 // `TypeFlagsAny`. `unknown` is intentionally not flagged: it requires a
 // narrowing assertion before the call, which is the explicit ergonomics
@@ -16,50 +16,50 @@
 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 noUnsafeCall struct{}
 
 func (noUnsafeCall) Name() string { return "typescript/no-unsafe-call" }
 func (noUnsafeCall) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnsafeCall) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindCallExpression,
-		shimast.KindNewExpression,
-		shimast.KindTaggedTemplateExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindCallExpression,
+    shimast.KindNewExpression,
+    shimast.KindTaggedTemplateExpression,
+  }
 }
 func (noUnsafeCall) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	var callee *shimast.Node
-	switch node.Kind {
-	case shimast.KindCallExpression:
-		if call := node.AsCallExpression(); call != nil {
-			callee = call.Expression
-		}
-	case shimast.KindNewExpression:
-		if ne := node.AsNewExpression(); ne != nil {
-			callee = ne.Expression
-		}
-	case shimast.KindTaggedTemplateExpression:
-		if tag := node.AsTaggedTemplateExpression(); tag != nil {
-			callee = tag.Tag
-		}
-	}
-	if callee == nil {
-		return
-	}
-	t := ctx.Checker.GetTypeAtLocation(callee)
-	if !typeIsUnsafeAny(t) {
-		return
-	}
-	ctx.Report(callee, noUnsafeCallMessage)
+  if ctx.Checker == nil {
+    return
+  }
+  var callee *shimast.Node
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    if call := node.AsCallExpression(); call != nil {
+      callee = call.Expression
+    }
+  case shimast.KindNewExpression:
+    if ne := node.AsNewExpression(); ne != nil {
+      callee = ne.Expression
+    }
+  case shimast.KindTaggedTemplateExpression:
+    if tag := node.AsTaggedTemplateExpression(); tag != nil {
+      callee = tag.Tag
+    }
+  }
+  if callee == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(callee)
+  if !typeIsUnsafeAny(t) {
+    return
+  }
+  ctx.Report(callee, noUnsafeCallMessage)
 }
 
 const noUnsafeCallMessage = "Unsafe call of a value typed as `any`. Narrow the callee to a concrete signature before invoking it."
@@ -71,12 +71,12 @@ const noUnsafeCallMessage = "Unsafe call of a value typed as `any`. Narrow the c
 // nil so an absent type silently bypasses the rule rather than firing
 // on every unanalysable expression.
 func typeIsUnsafeAny(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	return t.Flags()&shimchecker.TypeFlagsAny != 0
+  if t == nil {
+    return false
+  }
+  return t.Flags()&shimchecker.TypeFlagsAny != 0
 }
 
 func init() {
-	Register(noUnsafeCall{})
+  Register(noUnsafeCall{})
 }