@ttsc/lint 0.12.4 → 0.13.0

package/linthost/rules_logic.go

@@ -5,7 +5,10 @@
 // AST-only, no scope analysis.
 package linthost
 
-import shimast "github.com/microsoft/typescript-go/shim/ast"
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
 
 // no-extra-boolean-cast: `if (!!x)`, `if (Boolean(x))`, `Boolean(!!x)` —
 // the conversion is implicit in a boolean context.
@@ -26,9 +29,43 @@ func (noExtraBooleanCast) Check(ctx *Context, node *shimast.Node) {
     if identifierText(call.Expression) != "Boolean" {
       return
     }
-    if isInBooleanContext(node) {
-      ctx.Report(node, "Redundant Boolean call.")
+    if call.QuestionDotToken != nil {
+      return
+    }
+    if !isInBooleanContext(node) {
+      return
+    }
+    message := "Redundant Boolean call."
+    // Only autofix when there is exactly one positional argument: zero
+    // arguments produce `undefined → false`, and multi-arg calls signal the
+    // author may be passing through an unrelated value as the second slot.
+    // Spread arguments hide the runtime shape, so skip those as well.
+    if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+      ctx.Report(node, message)
+      return
+    }
+    arg := call.Arguments.Nodes[0]
+    if arg == nil || arg.Kind == shimast.KindSpreadElement {
+      ctx.Report(node, message)
+      return
+    }
+    src := ctx.File.Text()
+    argStart := shimscanner.SkipTrivia(src, arg.Pos())
+    argEnd := arg.End()
+    if argStart < 0 || argStart >= argEnd || argEnd > len(src) {
+      ctx.Report(node, message)
+      return
+    }
+    editPos := shimscanner.SkipTrivia(src, node.Pos())
+    if editPos < 0 || editPos >= node.End() {
+      ctx.Report(node, message)
+      return
     }
+    ctx.ReportFix(
+      node,
+      message,
+      TextEdit{Pos: editPos, End: node.End(), Text: src[argStart:argEnd]},
+    )
   case shimast.KindPrefixUnaryExpression:
     outer := node.AsPrefixUnaryExpression()
     if outer == nil || outer.Operator != shimast.KindExclamationToken {
@@ -42,9 +79,31 @@ func (noExtraBooleanCast) Check(ctx *Context, node *shimast.Node) {
     if inner == nil || inner.Operator != shimast.KindExclamationToken {
       return
     }
-    if isInBooleanContext(node) {
-      ctx.Report(node, "Redundant double negation.")
+    if !isInBooleanContext(node) {
+      return
+    }
+    message := "Redundant double negation."
+    if inner.Operand == nil {
+      ctx.Report(node, message)
+      return
     }
+    src := ctx.File.Text()
+    inStart := shimscanner.SkipTrivia(src, inner.Operand.Pos())
+    inEnd := inner.Operand.End()
+    if inStart < 0 || inStart >= inEnd || inEnd > len(src) {
+      ctx.Report(node, message)
+      return
+    }
+    editPos := shimscanner.SkipTrivia(src, node.Pos())
+    if editPos < 0 || editPos >= node.End() {
+      ctx.Report(node, message)
+      return
+    }
+    ctx.ReportFix(
+      node,
+      message,
+      TextEdit{Pos: editPos, End: node.End(), Text: src[inStart:inEnd]},
+    )
   }
 }
 

package/linthost/rules_problems.go

@@ -74,7 +74,9 @@ func (noExAssign) Check(ctx *Context, node *shimast.Node) {
 }
 
 // walkAssignments invokes `report` on every `<name> = ...` shape inside
-// `root`. Used by no-ex-assign and friends.
+// `root`. Used by no-ex-assign to scan a single catch block; the
+// file-wide no-func-assign / no-class-assign scans go through
+// reportAssignmentsToDeclarations instead.
 func walkAssignments(root *shimast.Node, name string, report func(*shimast.Node)) {
   if root == nil {
     return
@@ -230,38 +232,80 @@ func numericLiteralLosesPrecision(text string) bool {
 type noClassAssign struct{}
 
 func (noClassAssign) Name() string           { return "no-class-assign" }
-func (noClassAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindClassDeclaration} }
+func (noClassAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (noClassAssign) Check(ctx *Context, node *shimast.Node) {
-  decl := node.AsClassDeclaration()
-  if decl == nil || decl.Name() == nil {
-    return
-  }
-  name := identifierText(decl.Name())
-  if name == "" {
-    return
-  }
-  walkAssignments(ctx.File.AsNode(), name, func(target *shimast.Node) {
-    ctx.Report(target, "'"+name+"' is a class.")
-  })
+  reportAssignmentsToDeclarations(ctx, node, shimast.KindClassDeclaration, "is a class.")
 }
 
 // no-func-assign: same idea, but for function declarations.
 type noFuncAssign struct{}
 
 func (noFuncAssign) Name() string           { return "no-func-assign" }
-func (noFuncAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindFunctionDeclaration} }
+func (noFuncAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (noFuncAssign) Check(ctx *Context, node *shimast.Node) {
-  decl := node.AsFunctionDeclaration()
-  if decl == nil || decl.Name() == nil {
+  reportAssignmentsToDeclarations(ctx, node, shimast.KindFunctionDeclaration, "is a function.")
+}
+
+// reportAssignmentsToDeclarations flags every `<name> = …` assignment whose
+// target identifier names a `declKind` declaration found anywhere in the
+// file. It walks the file exactly once — gathering declared names and
+// assignment targets in the same pass — so the cost is linear in file size.
+//
+// The earlier shape registered for `declKind` directly and, on every
+// declaration, re-scanned the whole file for assignments: O(declarations ×
+// file size), which blows up quadratically on a file with many top-level
+// functions. Visiting `KindSourceFile` once and cross-referencing afterward
+// keeps the same findings without the repeated scans.
+func reportAssignmentsToDeclarations(
+  ctx *Context,
+  file *shimast.Node,
+  declKind shimast.Kind,
+  noun string,
+) {
+  if ctx == nil || file == nil {
     return
   }
-  name := identifierText(decl.Name())
-  if name == "" {
+  declared := map[string]struct{}{}
+  var targets []*shimast.Node
+  walkDescendants(file, func(n *shimast.Node) {
+    switch n.Kind {
+    case declKind:
+      if name := declarationName(n); name != "" {
+        declared[name] = struct{}{}
+      }
+    case shimast.KindBinaryExpression:
+      if expr := n.AsBinaryExpression(); expr != nil &&
+        expr.OperatorToken != nil && isAssignmentOperator(expr.OperatorToken.Kind) &&
+        expr.Left != nil && expr.Left.Kind == shimast.KindIdentifier {
+        targets = append(targets, expr.Left)
+      }
+    }
+  })
+  if len(declared) == 0 || len(targets) == 0 {
     return
   }
-  walkAssignments(ctx.File.AsNode(), name, func(target *shimast.Node) {
-    ctx.Report(target, "'"+name+"' is a function.")
-  })
+  for _, target := range targets {
+    name := identifierText(target)
+    if _, ok := declared[name]; ok {
+      ctx.Report(target, "'"+name+"' "+noun)
+    }
+  }
+}
+
+// declarationName returns the bound name of a class or function declaration
+// node, or "" when the node is neither (or is anonymous).
+func declarationName(n *shimast.Node) string {
+  switch n.Kind {
+  case shimast.KindFunctionDeclaration:
+    if d := n.AsFunctionDeclaration(); d != nil {
+      return identifierText(d.Name())
+    }
+  case shimast.KindClassDeclaration:
+    if d := n.AsClassDeclaration(); d != nil {
+      return identifierText(d.Name())
+    }
+  }
+  return ""
 }
 
 // no-prototype-builtins: `obj.hasOwnProperty(x)` — should be

package/linthost/rules_promise.go

@@ -19,6 +19,9 @@ import (
 type awaitThenable struct{}
 
 func (awaitThenable) Name() string { return "await-thenable" }
+func (awaitThenable) NeedsTypeChecker() bool {
+  return true
+}
 func (awaitThenable) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindAwaitExpression}
 }

package/linthost/rules_suggestions.go

@@ -7,6 +7,7 @@ import (
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // no-alert: `alert()` / `confirm()` / `prompt()`. Rarely the right
@@ -742,16 +743,72 @@ func (noUnneededTernary) Visits() []shimast.Kind {
 }
 func (noUnneededTernary) Check(ctx *Context, node *shimast.Node) {
   cond := node.AsConditionalExpression()
-  if cond == nil {
+  if cond == nil || cond.Condition == nil {
     return
   }
   t := stripParens(cond.WhenTrue)
   f := stripParens(cond.WhenFalse)
   tBool, tOk := isLiteralBoolean(t)
   fBool, fOk := isLiteralBoolean(f)
-  if tOk && fOk && tBool != fBool {
-    ctx.Report(node, "Unnecessary use of conditional expression for boolean.")
+  if !(tOk && fOk && tBool != fBool) {
+    return
+  }
+  message := "Unnecessary use of conditional expression for boolean."
+  src := ctx.File.Text()
+  condStart := shimscanner.SkipTrivia(src, cond.Condition.Pos())
+  if condStart < 0 || condStart >= cond.Condition.End() {
+    ctx.Report(node, message)
+    return
+  }
+  condText := src[condStart:cond.Condition.End()]
+  var replacement string
+  if tBool {
+    // `cond ? true : false` → `Boolean(cond)`
+    replacement = "Boolean(" + condText + ")"
+  } else {
+    // `cond ? false : true` → `!cond`. Wrap the condition in parentheses
+    // when it is not already a primary expression so operator precedence
+    // does not flip the meaning (e.g. `a || b` must become `!(a || b)`).
+    if needsParensForUnaryNegation(cond.Condition) {
+      replacement = "!(" + condText + ")"
+    } else {
+      replacement = "!" + condText
+    }
+  }
+  editPos := shimscanner.SkipTrivia(src, node.Pos())
+  if editPos < 0 || editPos >= node.End() {
+    ctx.Report(node, message)
+    return
+  }
+  ctx.ReportFix(
+    node,
+    message,
+    TextEdit{Pos: editPos, End: node.End(), Text: replacement},
+  )
+}
+
+// needsParensForUnaryNegation reports whether `cond` must be wrapped in
+// parentheses before prefixing with `!`. Anything looser than a unary /
+// member / primary expression flips precedence when negated. Mirrors
+// ESLint's `no-unneeded-ternary` autofix safety check.
+func needsParensForUnaryNegation(node *shimast.Node) bool {
+  inner := stripParens(node)
+  if inner == nil {
+    return false
+  }
+  switch inner.Kind {
+  case shimast.KindBinaryExpression,
+    shimast.KindConditionalExpression,
+    shimast.KindYieldExpression,
+    shimast.KindAwaitExpression,
+    shimast.KindArrowFunction,
+    shimast.KindFunctionExpression,
+    shimast.KindAsExpression,
+    shimast.KindSatisfiesExpression,
+    shimast.KindTypeAssertionExpression:
+    return true
   }
+  return false
 }
 
 // no-unused-expressions: an expression statement whose value isn't used.
@@ -1099,9 +1156,27 @@ func (preferTemplate) Check(ctx *Context, node *shimast.Node) {
     }
   }
   hasString, hasOther := concatChainShape(node)
-  if hasString && hasOther {
-    ctx.Report(node, "Unexpected string concatenation.")
+  if !(hasString && hasOther) {
+    return
+  }
+  message := "Unexpected string concatenation."
+  src := ctx.File.Text()
+  operands := flattenConcatOperands(node)
+  template, ok := renderConcatAsTemplate(src, operands)
+  if !ok {
+    ctx.Report(node, message)
+    return
   }
+  editPos := shimscanner.SkipTrivia(src, node.Pos())
+  if editPos < 0 || editPos >= node.End() {
+    ctx.Report(node, message)
+    return
+  }
+  ctx.ReportFix(
+    node,
+    message,
+    TextEdit{Pos: editPos, End: node.End(), Text: template},
+  )
 }
 
 func concatChainShape(node *shimast.Node) (hasString bool, hasOther bool) {
@@ -1122,6 +1197,86 @@ func concatChainShape(node *shimast.Node) (hasString bool, hasOther bool) {
   return false, true
 }
 
+// flattenConcatOperands walks a `+` chain left-to-right and returns each
+// leaf operand in source order. Parenthesized sub-expressions are kept as
+// a single operand so the rendered template literal does not lose their
+// grouping. Mirrors ESLint's behavior of treating `("a" + b)` as one
+// expression slot when it appears inside a larger chain.
+func flattenConcatOperands(node *shimast.Node) []*shimast.Node {
+  if node == nil {
+    return nil
+  }
+  if node.Kind == shimast.KindBinaryExpression {
+    bin := node.AsBinaryExpression()
+    if bin != nil && bin.OperatorToken != nil && bin.OperatorToken.Kind == shimast.KindPlusToken {
+      out := flattenConcatOperands(bin.Left)
+      out = append(out, flattenConcatOperands(bin.Right)...)
+      return out
+    }
+  }
+  return []*shimast.Node{node}
+}
+
+// renderConcatAsTemplate renders the flattened concat operands as a single
+// backtick template literal. String-like literals contribute their value
+// directly (with template-specific escaping); any other expression becomes
+// a `${…}` placeholder copied verbatim from the source text. Returns ok=false
+// when an operand cannot be rendered (typically because its source range is
+// unavailable), so the caller falls back to detection-only.
+func renderConcatAsTemplate(src string, operands []*shimast.Node) (string, bool) {
+  if len(operands) == 0 {
+    return "", false
+  }
+  var sb strings.Builder
+  sb.WriteByte('`')
+  for _, operand := range operands {
+    if operand == nil {
+      return "", false
+    }
+    inner := stripParens(operand)
+    if isStringLikeLiteral(inner) {
+      sb.WriteString(escapeTemplateLiteralBody(stringLiteralText(inner)))
+      continue
+    }
+    pos := shimscanner.SkipTrivia(src, operand.Pos())
+    end := operand.End()
+    if pos < 0 || pos >= end || end > len(src) {
+      return "", false
+    }
+    sb.WriteString("${")
+    sb.WriteString(src[pos:end])
+    sb.WriteByte('}')
+  }
+  sb.WriteByte('`')
+  return sb.String(), true
+}
+
+// escapeTemplateLiteralBody escapes the characters that would otherwise
+// terminate or interpolate a template literal body: backslash, backtick,
+// and the `${` sequence. Matches the canonical ESLint `prefer-template`
+// fixer escape set.
+func escapeTemplateLiteralBody(text string) string {
+  var sb strings.Builder
+  sb.Grow(len(text))
+  for i := 0; i < len(text); i++ {
+    ch := text[i]
+    switch ch {
+    case '\\', '`':
+      sb.WriteByte('\\')
+      sb.WriteByte(ch)
+    case '$':
+      if i+1 < len(text) && text[i+1] == '{' {
+        sb.WriteString("\\$")
+      } else {
+        sb.WriteByte('$')
+      }
+    default:
+      sb.WriteByte(ch)
+    }
+  }
+  return sb.String()
+}
+
 // require-yield: `function* gen() { return 1; }` — generators that
 // never yield are usually unintended.
 type requireYield struct{}

package/linthost/rules_var.go

@@ -71,7 +71,7 @@ func (preferConst) Check(ctx *Context, node *shimast.Node) {
       if expr == nil || expr.OperatorToken == nil || !isAssignmentOperator(expr.OperatorToken.Kind) {
         return
       }
-      for _, name := range bindingIdentifierNames(expr.Left) {
+      for _, name := range assignmentTargetNames(expr.Left) {
         assigned[name] = true
       }
     case shimast.KindPrefixUnaryExpression:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.12.4",
+  "version": "0.13.0",
   "description": "Reference ttsc plugin: ESLint-style lint rules hosted in the same Program/Checker as the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -33,10 +33,10 @@
     "src"
   ],
   "devDependencies": {
-    "@typescript/native-preview": "7.0.0-dev.20260519.1",
+    "@typescript/native-preview": "7.0.0-dev.20260522.1",
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
-    "ttsc": "0.12.4"
+    "ttsc": "0.13.0"
   },
   "repository": {
     "type": "git",