@ttsc/lint 0.12.3 → 0.13.0

package/linthost/rules_format_print_width.go

@@ -1,6 +1,8 @@
 package linthost
 
 import (
+  "strings"
+
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
@@ -25,16 +27,22 @@ import (
 //     printer's StartingIndent so continuation lines align under the
 //     opening token and fit measurement charges the prefix against
 //     the budget.
-//  3. Build the node's Doc via PrintNode.
-//  4. Render with the configured printWidth / tabWidth / useTabs /
+//  3. Build the node's Doc via PrintNode, which also reports a
+//     `covered` flag.
+//  4. Abstain when `covered` is false: the subtree holds a multi-line
+//     verbatim node whose frozen columns would not survive a reflow.
+//  5. Render with the configured printWidth / tabWidth / useTabs /
 //     endOfLine.
-//  5. Slice the original source bytes for the node's range.
-//  6. If the rendered output differs, emit one TextEdit replacing
+//  6. Slice the original source bytes for the node's range.
+//  7. If the rendered output differs, emit one TextEdit replacing
 //     [start, end) with the new bytes.
 //
 // The "no diff → no edit" invariant is what keeps `ttsc format`
 // idempotent: a second pass renders identical bytes, the comparison
-// short-circuits, and the cascade converges.
+// short-circuits, and the cascade converges. The `covered` abstain in
+// step 4 is the safety floor: `ttsc format` either reflows correctly or
+// leaves the node byte-identical — it never emits a half-reflowed,
+// inconsistently indented shape.
 //
 // The rule is a format-class rule (IsFormat == true) so `ttsc format`
 // applies its edits while `ttsc check` only emits diagnostics for
@@ -44,11 +52,19 @@ import (
 type formatPrintWidth struct{}
 
 // formatPrintWidthOptions mirrors `TtscLintRuleOptions.PrintWidth`.
+//
+// TrailingComma reaches this rule because the printer's reflow decides
+// whether to emit a trailing comma on every multi-line list — and that
+// decision must match the user's `format.trailingComma` setting or the
+// reflow oscillates against `format/trailing-comma` on every cascade
+// pass. The config layer mirrors `format.trailingComma` into both
+// rules' option blobs (see `expandFormatBlock` in config_format.go).
 type formatPrintWidthOptions struct {
-  PrintWidth *int    `json:"printWidth"`
-  TabWidth   *int    `json:"tabWidth"`
-  UseTabs    *bool   `json:"useTabs"`
-  EndOfLine  *string `json:"endOfLine"`
+  PrintWidth    *int    `json:"printWidth"`
+  TabWidth      *int    `json:"tabWidth"`
+  UseTabs       *bool   `json:"useTabs"`
+  EndOfLine     *string `json:"endOfLine"`
+  TrailingComma *string `json:"trailingComma"`
 }
 
 func (formatPrintWidth) Name() string   { return "format/print-width" }
@@ -66,6 +82,29 @@ func (formatPrintWidth) Visits() []shimast.Kind {
   }
 }
 
+// Known residual divergence from Prettier 3 (investigated against the
+// nestjs / typeorm / vscode benchmark fixtures, not closed in this
+// pass):
+//
+//   - Multi-line `reduce(...)` (or other single-arg method) calls where
+//     Prettier 3 keeps the inline form because it fits print-width
+//     minus the trailing-suffix budget. The current shrunk-budget
+//     re-render still over-breaks some of these; the next slice should
+//     measure fitsFirstLine against `pw - col - trailingNonComment`
+//     before committing to the broken layout.
+//   - Single-line `export type { X } from "long-path"` reexports.
+//     Prettier 3 keeps them flat even when the whole declaration
+//     overflows; ttsc-lint visits `KindNamedExports` in isolation and
+//     breaks the brace clause. A real fix requires teaching the rule
+//     about the surrounding ExportDeclaration so the brace clause is
+//     measured against the full declaration line, or visiting
+//     ExportDeclaration directly so the `from "..."` tail joins the
+//     reflow surface.
+//
+// Both cases are tracked benchmark cases that forced
+// `format/print-width: 'off'` on the ttsc-lint branch. They are listed
+// here so a future slice can pick them up without rediscovering the
+// divergence.
 func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   if ctx == nil || ctx.File == nil || node == nil {
     return
@@ -85,6 +124,9 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   if opts.EndOfLine != nil {
     printOpts.EndOfLine = *opts.EndOfLine
   }
+  if opts.TrailingComma != nil {
+    printOpts.TrailingComma = *opts.TrailingComma
+  }
 
   src := ctx.File.Text()
   start := shimscanner.SkipTrivia(src, node.Pos())
@@ -101,6 +143,16 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
     return
   }
 
+  // Abstain on any node nested inside a template-literal substitution.
+  // Prettier renders `${…}` expressions at printWidth:Infinity — it
+  // never breaks an interpolation the source wrote on one line — so
+  // reflowing a call or literal inside `${…}` would split the template
+  // across lines and diverge from Prettier. See the printWidth:Infinity
+  // branch in Prettier's printTemplateExpression.
+  if hasTemplateSubstitutionAncestor(node) {
+    return
+  }
+
   // Safety: abstain when the node carries comments outside its
   // children. The per-node printers join child docs with a fresh
   // `, ` separator and have no path for trivia between siblings, so
@@ -113,29 +165,85 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   }
 
   printOpts.StartingColumn = leadingColumn(src, start, printOpts.TabWidth)
-  printOpts.BaseIndent = lineLeadingIndent(src, start, printOpts.TabWidth)
+  // A node reflowed on a ternary-arm continuation line (`? expr` or
+  // `: expr`) hangs its broken continuation under the arm's expression,
+  // two columns past the `?`/`:` marker — not under the marker itself.
+  printOpts.BaseIndent = lineLeadingIndent(src, start, printOpts.TabWidth) +
+    ternaryArmIndentBonus(src, start)
+
+  // trailingWidth is the column span of the tokens that stay on the
+  // node's last line after `end` — a `;`, a `);`, a `) {`. The reflow
+  // replaces only [start, end) and cannot move them, so both the fast
+  // path and the layout budget must reserve those columns; otherwise
+  // the rule emits a line that overflows by exactly the suffix.
+  trailingWidth := trailingLineWidth(src, end, printOpts.TabWidth)
 
   // Fast path: if the node's existing single-line bytes already fit
-  // the printWidth budget, the reflowed output cannot differ from
-  // the source (the printer would render the same flat shape). Skip
-  // the Doc build + render entirely. This is the common case on
+  // the printWidth budget — prefix column, node width and trailing
+  // suffix all charged — the reflowed output cannot differ from the
+  // source (the printer would render the same flat shape). Skip the
+  // Doc build + render entirely. This is the common case on
   // well-formatted code — every short call, every short literal —
   // and saves the allocations from PrintNode + Print.
   if !sliceContainsNewline(src, start, end) &&
-    printOpts.StartingColumn+(end-start) <= printOpts.PrintWidth {
+    printOpts.StartingColumn+(end-start)+trailingWidth <= printOpts.PrintWidth {
     return
   }
 
   printCtx := NewPrintContext(ctx.File, printOpts)
-  doc, _ := PrintNode(printCtx, node)
+  doc, covered := PrintNode(printCtx, node)
   if doc.IsNil() {
     return
   }
+  // Safety abstain: the printed subtree contains a multi-line verbatim
+  // node — one the dispatcher has no printer for. Such a node keeps the
+  // source columns its lines were written at, while the reflow
+  // re-indents everything around it. Emitting the edit would produce
+  // inconsistently indented, corrupt output (a callback header at one
+  // indent, its body frozen at another). Abstaining leaves the bytes
+  // byte-identical, which is always safe. See the coverage-signal note
+  // in print_dispatch.go.
+  if !covered {
+    return
+  }
+  // Render at the full printWidth budget. A reflow that breaks across
+  // lines then makes every layout decision — which call argument hugs,
+  // where a list explodes — against the true column budget. The
+  // un-movable trailing suffix (`;`, `) {`, ` satisfies T`) lands on a
+  // short last line; charging it against the whole budget would
+  // wrongly penalize the interior lines and over-break the node.
   rendered := Print(doc, printOpts)
+  // The one case the suffix genuinely shares the node's line is a
+  // reflow that collapses to a single line. When the flat form plus
+  // the suffix would overflow, re-render under a budget shrunk by the
+  // suffix so the node breaks instead of spilling the suffix past
+  // printWidth — the regression that keeps a call flat at exactly
+  // printWidth while the trailing `;` runs over.
+  if trailingWidth > 0 &&
+    !strings.Contains(rendered, "\n") &&
+    maxLineWidth(rendered, printOpts.StartingColumn, trailingWidth, printOpts.TabWidth) > printOpts.PrintWidth &&
+    printOpts.PrintWidth-trailingWidth >= 1 {
+    shrunk := printOpts
+    shrunk.PrintWidth -= trailingWidth
+    rendered = Print(doc, shrunk)
+  }
   original := src[start:end]
   if rendered == original {
     return
   }
+  // Safety floor: never emit an edit that makes the widest line wider
+  // than it already was. The reflow may be unable to break an
+  // un-breakable token run — a long string literal, a verbatim object
+  // member — but it must never *worsen* the worst line. That is exactly
+  // the regression this guards: `ttsc format` collapsing an
+  // already-broken, fitting call into one over-wide line. A reflow that
+  // only fixes indentation and leaves a pre-existing over-wide line
+  // untouched is still emitted.
+  renderedMax := maxLineWidth(rendered, printOpts.StartingColumn, trailingWidth, printOpts.TabWidth)
+  originalMax := maxLineWidth(original, printOpts.StartingColumn, trailingWidth, printOpts.TabWidth)
+  if renderedMax > printOpts.PrintWidth && renderedMax > originalMax {
+    return
+  }
   ctx.ReportRangeFix(
     start,
     end,
@@ -144,6 +252,113 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
+// trailingLineWidth returns the visual column width of src[end:] up to
+// the next newline, with trailing whitespace trimmed. The format/print-
+// width reflow replaces only the node's own byte range, so whatever
+// shares the node's last source line — a statement `;`, a `) {` header
+// tail, a `, nextArg)` continuation — stays put. Charging that width
+// against the budget keeps the rule from emitting a line that overflows
+// by exactly the suffix it could never move.
+//
+// Trailing `//` line comments are excluded from the budget. A line
+// comment runs to the end of the source line by definition, so breaking
+// the reflowed node to make the comment fit cannot help — Prettier 3
+// keeps the node inline and lets the comment trail (see typeorm's
+// `comment.replaceAll(...) // Null bytes' shape that pushed
+// `format/print-width: 'off'` onto the ttsc-lint benchmark branch).
+// Excluding the comment from `trailingLineWidth` matches that
+// behavior: the fast path sees just the un-movable punctuation suffix,
+// and the shrunk-budget re-render does not over-shrink and over-break.
+func trailingLineWidth(src string, end int, tabWidth int) int {
+  if end < 0 || end > len(src) {
+    return 0
+  }
+  if tabWidth <= 0 {
+    tabWidth = 2
+  }
+  lineEnd := trailingSuffixEnd(src, end)
+  col := 0
+  for i := end; i < lineEnd; i++ {
+    if src[i] == '\t' {
+      col += tabWidth - (col % tabWidth)
+    } else {
+      col++
+    }
+  }
+  return col
+}
+
+// trailingSuffixEnd returns the byte offset where the node's un-movable
+// trailing suffix ends on the line that begins at `end`. The walk stops
+// at the first `//` line comment (Prettier-style "free" trailing
+// attachment, see trailingLineWidth) or at the newline, then trims
+// trailing whitespace so a `;<spaces><newline>` tail measures the
+// `;` only. Trailing block comments inside the un-movable suffix span
+// (`} /* note */`) keep their bytes counted; that path is rare and
+// already exercised through the existing block-comment fixture.
+func trailingSuffixEnd(src string, end int) int {
+  lineEnd := end
+  for lineEnd < len(src) && src[lineEnd] != '\n' {
+    if src[lineEnd] == '/' && lineEnd+1 < len(src) {
+      next := src[lineEnd+1]
+      if next == '/' {
+        // `//` line comment — Prettier treats the whole tail as a
+        // trailing comment that runs to EOL. Drop it from the suffix
+        // budget so the rule does not break the node to chase a
+        // comment that cannot be moved or wrapped.
+        break
+      }
+    }
+    lineEnd++
+  }
+  for lineEnd > end {
+    c := src[lineEnd-1]
+    if c != ' ' && c != '\t' && c != '\r' {
+      break
+    }
+    lineEnd--
+  }
+  return lineEnd
+}
+
+// maxLineWidth returns the widest effective column span among the lines
+// of `text`. The first line is charged `startingColumn` — the prefix
+// already on that source line that the reflow does not re-emit — and
+// the last line is charged `trailingWidth` for the un-movable suffix
+// that follows the node. Tabs count as `tabWidth` columns.
+//
+// The rule compares the rendered output's widest line against the
+// source node's: a reflow that cannot fit an un-breakable token is
+// still allowed through as long as it does not make the worst line any
+// wider than it already was.
+func maxLineWidth(text string, startingColumn, trailingWidth, tabWidth int) int {
+  if tabWidth <= 0 {
+    tabWidth = 2
+  }
+  lines := strings.Split(text, "\n")
+  widest := 0
+  for i, line := range lines {
+    width := 0
+    for _, r := range line {
+      if r == '\t' {
+        width += tabWidth - (width % tabWidth)
+      } else if r != '\r' {
+        width++
+      }
+    }
+    if i == 0 {
+      width += startingColumn
+    }
+    if i == len(lines)-1 {
+      width += trailingWidth
+    }
+    if width > widest {
+      widest = width
+    }
+  }
+  return widest
+}
+
 // leadingColumn returns the visual column the byte at `pos` occupies on
 // its line. Tabs expand to `tabWidth` columns; other bytes count as 1.
 // The rule uses this to seed the printer's StartingColumn so fit
@@ -240,6 +455,25 @@ func lineStartOffset(src string, pos int) int {
   return pos
 }
 
+// ternaryArmIndentBonus returns 2 when the line containing `pos` begins,
+// after its leading whitespace, with a `? ` or `: ` ternary-arm marker,
+// and 0 otherwise. format/print-width adds it to BaseIndent so a node
+// reflowed inside a ternary arm indents its broken continuation under
+// the arm's expression rather than under the `?`/`:` token. In practice
+// only a ternary arm opens a reflow target's line with `? ` / `: `; the
+// two-byte prefix is a heuristic, and a rare false positive only shifts
+// a broken continuation by two columns — it never corrupts bytes.
+func ternaryArmIndentBonus(src string, pos int) int {
+  i := lineStartOffset(src, pos)
+  for i < len(src) && (src[i] == ' ' || src[i] == '\t') {
+    i++
+  }
+  if i+1 < len(src) && (src[i] == '?' || src[i] == ':') && src[i+1] == ' ' {
+    return 2
+  }
+  return 0
+}
+
 // hasReflowAncestor reports whether any ancestor of `node` would also
 // match the format/print-width visitor. The rule uses this to suppress
 // nested fires when an enclosing reflow target already covers the
@@ -256,6 +490,27 @@ func hasReflowAncestor(node *shimast.Node) bool {
   return false
 }
 
+// hasTemplateSubstitutionAncestor reports whether `node` sits inside a
+// template-literal substitution (`${…}`). format/print-width abstains
+// on such nodes: Prettier prints template interpolations at infinite
+// printWidth and only keeps a break the source already had, so a reflow
+// of a nested call or literal would split a one-line `${…}` and never
+// match Prettier's output.
+func hasTemplateSubstitutionAncestor(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  for parent := node.Parent; parent != nil; parent = parent.Parent {
+    if parent.Kind == shimast.KindTemplateExpression {
+      return true
+    }
+  }
+  return false
+}
+
+// isReflowKind reports whether `k` is one of the node kinds the
+// format/print-width rule visits. Kept in sync with Visits() so
+// hasReflowAncestor does not need to call Visits() at runtime.
 func isReflowKind(k shimast.Kind) bool {
   switch k {
   case shimast.KindObjectLiteralExpression,

package/linthost/rules_format_quotes.go

@@ -25,6 +25,9 @@ import (
 // also intentionally out of scope.
 type formatQuotes struct{}
 
+// formatQuotesOptions mirrors `TtscLintRuleOptions.Quotes`. Prefer accepts
+// `"double"` (the default, enforces double quotes) or `"single"` (enforces
+// single quotes). Any other value is treated as the default.
 type formatQuotesOptions struct {
   Prefer string `json:"prefer"`
 }

package/linthost/rules_format_sort_imports.go

@@ -173,6 +173,8 @@ func loadSortImportsOptions(ctx *Context) resolvedSortImportsOptions {
   }
 }
 
+// hasThirdPartyGroup reports whether at least one group in the list is the
+// third-party catchall. Used to decide whether a sentinel needs to be appended.
 func hasThirdPartyGroup(groups []sortImportsGroup) bool {
   for _, g := range groups {
     if g.thirdParty {
@@ -449,6 +451,8 @@ func reportNamedSpecifierSort(ctx *Context, decl *shimast.Node, caseInsensitive
   )
 }
 
+// joinSortedSpecifiers returns the specifier texts joined with ", " in their
+// already-sorted order. The caller owns the sort; this is a formatting step only.
 func joinSortedSpecifiers(entries []specifierEntry) string {
   texts := make([]string, len(entries))
   for i, e := range entries {

package/linthost/rules_gap.go

@@ -1,6 +1,17 @@
+// Miscellaneous AST-only rules that cover the gap between the core ESLint
+// "Possible Problems" list and the @typescript-eslint strict/stylistic
+// presets: empty static blocks, setter returns, unused labels, dynamic
+// delete, nullish-coalescing with non-null assertions, unnecessary type
+// constraints, unsafe built-in types, wrapper object types, useless
+// constructors, non-literal enum members, type-assertion style, type
+// definition style, dot notation, and unsafe declaration merging.
+// Each rule is registered in init() at the bottom of the file.
 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-empty-static-block: `class C { static {} }` has no effect.
 // ESLint recommended: https://eslint.org/docs/latest/rules/no-empty-static-block
@@ -35,6 +46,9 @@ func (noSetterReturn) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Setter should not return a value.")
 }
 
+// isInsideDirectSetter reports whether node is lexically nested inside a
+// SetAccessor without an intervening function boundary. "Direct" means the
+// return value would actually be a setter return, not a nested callback's.
 func isInsideDirectSetter(node *shimast.Node) bool {
   for p := node.Parent; p != nil; p = p.Parent {
     if p.Kind == shimast.KindSetAccessor {
@@ -99,6 +113,9 @@ func (noDynamicDelete) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Do not delete dynamically computed property keys.")
 }
 
+// isStaticPropertyKey reports whether node is a literal key that can
+// appear in a delete expression without triggering no-dynamic-delete:
+// string literals, no-substitution template literals, and numeric literals.
 func isStaticPropertyKey(node *shimast.Node) bool {
   node = stripParens(node)
   if node == nil {
@@ -263,6 +280,9 @@ func fileShadowsWrapperName(file *shimast.SourceFile, name string) bool {
   return false
 }
 
+// wrapperPrimitive maps a boxed object type name (e.g. "String") to its
+// primitive keyword equivalent (e.g. "string"). Returns ("", false) for
+// names that are not recognized wrapper types.
 func wrapperPrimitive(name string) (string, bool) {
   switch name {
   case "String":
@@ -355,16 +375,68 @@ func (dotNotation) Visits() []shimast.Kind {
 }
 func (dotNotation) Check(ctx *Context, node *shimast.Node) {
   access := node.AsElementAccessExpression()
-  if access == nil {
+  if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
     return
   }
   key := stringLiteralText(access.ArgumentExpression)
   if key == "" || !isSimpleIdentifierName(key) {
     return
   }
-  ctx.Report(node, "Use dot notation instead of a string literal property access.")
+  message := "Use dot notation instead of a string literal property access."
+  // Conservative: keep reserved words as bracket access. Modern JS accepts
+  // `obj.class`/`obj.if`/etc. syntactically but mixing them with member
+  // expression syntax is jarring and can confuse minifiers and older runtimes.
+  if isReservedWord(key) {
+    ctx.Report(node, message)
+    return
+  }
+  src := ctx.File.Text()
+  // Determine where the bracket access begins. With an optional chain
+  // (`obj?.["foo"]`) the `?.` token already separates object from access, so
+  // we replace the `["foo"]` tail with `foo`. Otherwise we replace the
+  // `["foo"]` tail with `.foo`.
+  var replaceFrom int
+  var replacement string
+  if access.QuestionDotToken != nil {
+    replaceFrom = shimscanner.SkipTrivia(src, access.QuestionDotToken.End())
+    replacement = key
+  } else {
+    replaceFrom = access.Expression.End()
+    replacement = "." + key
+  }
+  if replaceFrom < 0 || replaceFrom >= node.End() {
+    ctx.Report(node, message)
+    return
+  }
+  ctx.ReportFix(
+    node,
+    message,
+    TextEdit{Pos: replaceFrom, End: node.End(), Text: replacement},
+  )
+}
+
+// isReservedWord reports whether `value` is an ECMAScript reserved word. The
+// `dot-notation` autofix uses this to skip the rewrite even though modern
+// parsers accept reserved-word member names: leaving bracket access matches
+// the conservative branch ESLint takes when `allowKeywords: false`.
+func isReservedWord(value string) bool {
+  switch value {
+  case "break", "case", "catch", "class", "const", "continue",
+    "debugger", "default", "delete", "do", "else", "enum",
+    "export", "extends", "false", "finally", "for", "function",
+    "if", "implements", "import", "in", "instanceof", "interface",
+    "let", "new", "null", "package", "private", "protected",
+    "public", "return", "static", "super", "switch", "this",
+    "throw", "true", "try", "typeof", "var", "void",
+    "while", "with", "yield", "await":
+    return true
+  }
+  return false
 }
 
+// isSimpleIdentifierName reports whether value is a valid bare identifier
+// (ASCII letters, digits, underscore, dollar sign; digits not first). Used
+// by dot-notation to decide whether bracket access can become dot access.
 func isSimpleIdentifierName(value string) bool {
   if value == "" {
     return false

package/linthost/rules_imports.go

@@ -67,13 +67,11 @@ func (noImportTypeSideEffects) Check(ctx *Context, node *shimast.Node) {
   }
   src := ctx.File.Text()
   for _, spec := range named.Elements.Nodes {
-    // Locate the `type` keyword token at the head of the specifier by
-    // first skipping leading trivia (whitespace + comments). A naive
-    // `findKeyword` would search the byte range linearly and could
-    // match `type` *inside* a leading block comment such as
-    // `/* type alias */`, deleting the comment text and corrupting
-    // the source. SkipTrivia honors the lexer's notion of trivia, so
-    // the post-skip position is the actual first token byte.
+    // Locate the `type` keyword token at the head of each specifier by
+    // skipping leading trivia (whitespace + comments). A naive
+    // findKeyword scan would risk matching `type` inside a block comment
+    // such as `/* type alias */`, corrupting the source. SkipTrivia
+    // anchors the scan at the actual first token byte.
     typePos := shimscanner.SkipTrivia(src, spec.Pos())
     if typePos < 0 || typePos+len("type") > len(src) {
       continue

package/linthost/rules_logic.go

@@ -1,6 +1,14 @@
+// Correctness and equality rules — a focused set from ESLint's "Possible
+// Problems" and "Suggestions" categories that catch logic errors rather than
+// style issues: redundant boolean casts, unsafe negations, loose equality,
+// NaN comparisons, constant conditions, and assignment-in-condition.
+// 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.
@@ -21,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 {
@@ -37,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]},
+    )
   }
 }
 
@@ -71,6 +135,12 @@ func isInBooleanContext(node *shimast.Node) bool {
   return false
 }
 
+// skipParents walks up through any wrapping ParenthesizedExpression nodes and
+// returns the outermost parenthesized wrapper. This is the inverse of
+// stripParens: where stripParens descends into the canonical inner expression,
+// skipParents climbs up to the outermost paren so that structural parent
+// comparisons (e.g. "is this expression the test of an if?") resolve against
+// the node the parser actually attached as a child, not the inner form.
 func skipParents(node *shimast.Node) *shimast.Node {
   for node != nil && node.Parent != nil && node.Parent.Kind == shimast.KindParenthesizedExpression {
     node = node.Parent

package/linthost/rules_loops.go

@@ -57,6 +57,10 @@ func (forDirection) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
+// updateDirection returns the direction (+1 for incrementing, -1 for
+// decrementing, 0 for unknown) that the incrementor expression moves the
+// named counter variable. Only simple patterns are recognised: i++, i--,
+// ++i, --i, i += N, and i -= N. Compound or computed expressions return 0.
 func updateDirection(node *shimast.Node, counter string) int {
   if node == nil || counter == "" {
     return 0