@ttsc/lint 0.12.4 → 0.13.1

package/linthost/print_nodes_object.go

@@ -2,6 +2,7 @@ package linthost
 
 import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // printObjectLiteral renders an ObjectLiteralExpression with width-aware
@@ -22,30 +23,74 @@ import (
 // The flat form uses a single space inside the braces, matching
 // Prettier's `bracketSpacing: true` default. Empty object literals
 // collapse to `{}` with no inner space, matching every formatter.
-func printObjectLiteral(ctx *PrintContext, node *shimast.Node) Doc {
+//
+// The second return value is the `covered` flag: see PrintNode. It is
+// the AND of every property's coverage — one multi-line verbatim
+// member taints the whole literal.
+func printObjectLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if node == nil {
-    return Doc{}
+    return Doc{}, true
   }
   obj := node.AsObjectLiteralExpression()
   if obj == nil || obj.Properties == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   items := make([]Doc, 0, len(obj.Properties.Nodes))
+  covered := true
   for _, prop := range obj.Properties.Nodes {
     if prop == nil {
       // A nil child entry would render as an empty Doc and surface
       // as `a, , b` in the output. Bail to verbatim so the source
       // bytes round-trip unchanged.
-      return verbatim(ctx, node)
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
     }
-    doc, _ := PrintNode(ctx, prop)
+    doc, childCovered := PrintNode(ctx, prop)
+    covered = covered && childCovered
     items = append(items, doc)
   }
+  // objectWrap:"preserve" — keep a non-empty object expanded when the
+  // source wrote a newline after `{`. An empty literal has no first
+  // property to anchor the check and never preserves.
+  forceBreak := false
+  if len(obj.Properties.Nodes) > 0 {
+    forceBreak = objectHasNewlineAfterBrace(ctx.Source, node, obj.Properties.Nodes[0])
+  }
+  // AddComma honors `format.trailingComma`: object literals accept
+  // trailing commas in ES5 so both "all" and "es5" keep them; only
+  // "none" suppresses. Pairs with the call/array branches so the printer
+  // never disagrees with the trailing-comma rule on the same setting.
   return printList(ctx, listShape{
-    OpenTok:  "{",
-    CloseTok: "}",
-    Items:    items,
-    Space:    true,
-    AddComma: true,
-  })
+    OpenTok:    "{",
+    CloseTok:   "}",
+    Items:      items,
+    Space:      true,
+    AddComma:   ctx.allowsEs5TrailingComma(),
+    ForceBreak: forceBreak,
+  }), covered
+}
+
+// objectHasNewlineAfterBrace reports whether the source places a
+// newline between the object literal's `{` and its first property.
+//
+// Prettier's objectWrap:"preserve" default keeps such an object
+// expanded even when it would fit flat, treating the author's line
+// break as intentional structure. format/print-width mirrors that:
+// without it a deliberately multi-line object that happens to fit
+// would be silently collapsed onto one line, which Prettier never
+// does.
+func objectHasNewlineAfterBrace(src string, node *shimast.Node, firstProp *shimast.Node) bool {
+  if node == nil || firstProp == nil {
+    return false
+  }
+  brace := shimscanner.SkipTrivia(src, node.Pos())
+  propStart := shimscanner.SkipTrivia(src, firstProp.Pos())
+  if brace < 0 || propStart <= brace || propStart > len(src) {
+    return false
+  }
+  for i := brace; i < propStart; i++ {
+    if src[i] == '\n' {
+      return true
+    }
+  }
+  return false
 }

package/linthost/rules_escape.go

@@ -52,12 +52,12 @@ func (noUselessEscape) Check(ctx *Context, node *shimast.Node) {
   // single-char escape whitelist matches ESLint per-context.
   switch node.Kind {
   case shimast.KindStringLiteral:
-    reportStringEscapes(ctx, raw, pos, stringValidEscapes)
+    reportStringEscapes(ctx, raw, pos, stringValidEscapes, false)
   case shimast.KindNoSubstitutionTemplateLiteral,
     shimast.KindTemplateHead,
     shimast.KindTemplateMiddle,
     shimast.KindTemplateTail:
-    reportStringEscapes(ctx, raw, pos, templateValidEscapes)
+    reportStringEscapes(ctx, raw, pos, templateValidEscapes, true)
   case shimast.KindRegularExpressionLiteral:
     reportRegexEscapes(ctx, raw, pos)
   }
@@ -79,7 +79,16 @@ const regexValidEscapes = "^$\\.*+?()[]{}|/-\n\r"
 // translate to absolute file positions. The function issues an autofix
 // (delete the backslash) for ASCII escapes; multi-byte sequences are
 // reported without a fix to avoid corrupting UTF-8.
-func reportStringEscapes(ctx *Context, raw string, base int, whitelist string) {
+//
+// `isTemplate` is true for `NoSubstitutionTemplateLiteral` and
+// `TemplateHead`/`Middle`/`Tail` payloads. Inside a template, `\${` escapes
+// the interpolation opener: stripping the backslash from `\${expr}` would
+// either turn the literal text into an interpolation (corrupting the
+// program) or — when the surrounding template already contains a real
+// `${expr}` — produce TS syntax that no longer parses. The explicit guard
+// here pins that exception so future tightening of `templateValidEscapes`
+// cannot regress the corruption.
+func reportStringEscapes(ctx *Context, raw string, base int, whitelist string, isTemplate bool) {
   if len(raw) < 2 {
     return
   }
@@ -101,6 +110,14 @@ func reportStringEscapes(ctx *Context, raw string, base int, whitelist string) {
       return
     }
     next := raw[i+1]
+    // Template-literal exception: `\${` escapes the interpolation
+    // opener. Without the backslash the next two bytes would either
+    // start an interpolation or trigger a parse error, so the escape is
+    // load-bearing even though `\$` looks redundant in isolation.
+    if isTemplate && next == '$' && i+2 < len(raw) && raw[i+2] == '{' {
+      i++ // consume the `$` so the `{` is not re-examined as a fresh char.
+      continue
+    }
     if isUselessStringEscape(next, whitelist) {
       // Only emit a fix when both surrounding bytes are plain ASCII so
       // deleting one byte cannot corrupt a multi-byte sequence.

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,24 @@ 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.

package/linthost/rules_gap.go

@@ -8,7 +8,10 @@
 // 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
@@ -372,14 +375,63 @@ 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