@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_format_print_width.go

@@ -15,7 +15,7 @@ import (
 // node kinds whose per-node printers are registered with the
 // dispatcher (object/array literals, call/new expressions, named
 // import / export clauses, top-level import declarations). For every
-// other kind, the rule abstains — it never emits an edit that would
+// other kind, the rule abstains, it never emits an edit that would
 // modify bytes the dispatcher does not fully control. Coverage
 // expands by adding kinds to the dispatcher; the rule itself does not
 // need to grow.
@@ -23,7 +23,7 @@ import (
 // Per-node decision flow:
 //
 //  1. Skip leading trivia to find the node's actual first byte.
-//  2. Count the leading column on that line — that becomes the
+//  2. Count the leading column on that line, that becomes the
 //     printer's StartingIndent so continuation lines align under the
 //     opening token and fit measurement charges the prefix against
 //     the budget.
@@ -41,7 +41,7 @@ import (
 // idempotent: a second pass renders identical bytes, the comparison
 // 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,
+// 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`
@@ -54,7 +54,7 @@ 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
+// 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
@@ -79,6 +79,7 @@ func (formatPrintWidth) Visits() []shimast.Kind {
     shimast.KindNamedImports,
     shimast.KindNamedExports,
     shimast.KindImportDeclaration,
+    shimast.KindConditionalExpression,
   }
 }
 
@@ -92,19 +93,16 @@ func (formatPrintWidth) Visits() []shimast.Kind {
 //     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
-// `formatPrintWidth: 'off'` on the ttsc-lint branch. They are listed
-// here so a future slice can pick them up without rediscovering the
-// divergence.
+// (A single-specifier `import/export { X } from "long-path"` that overflows
+// only because of the `from "..."` tail is now kept inline by the
+// isSingleSpecifierNamedClause abstain, matching Prettier, which never
+// breaks a one-name clause. Multi-specifier clauses still break correctly:
+// the trailing-width charge measures the `from "..."` tail against the line
+// budget, so a brace that fits but whose declaration overflows is broken.)
+//
+// These cases are tracked benchmark divergences. 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
@@ -135,6 +133,54 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
     return
   }
 
+  printOpts.StartingColumn = leadingColumn(src, start, printOpts.TabWidth)
+
+  // 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, 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.
+  //
+  // This runs before the abstain guards below on purpose: those guards
+  // only ever return (they never emit an edit), so for a node that
+  // already fits the outcome is identical whichever fires first, and
+  // the fast path is far cheaper than the guards' ancestor walks and
+  // the per-byte comment scan in hasNonChildComments. Charging that
+  // cost only on nodes that actually overflow keeps the hot path on
+  // well-formatted code allocation- and scan-free.
+  // A call/new with two or more callback arguments explodes regardless of width
+  // (Prettier's multiple-callback rule), and an array of same-kind multi-child
+  // arrays/objects explodes under Prettier's shouldBreak heuristic — even when
+  // such a node is nested inside an otherwise-fitting call/new/array. So a flat
+  // one-line node containing either shape still needs a reflow. fastPathForcesBreak
+  // walks the reflow subtree; skip the fast path for it so the printer's
+  // ForceBreak produces the exploded shape. Everything else that fits flat is
+  // byte-identical after reflow, so the fast path stands.
+  if !fastPathForcesBreak(node) &&
+    !sliceContainsNewline(src, start, end) &&
+    printOpts.StartingColumn+displayWidth(src[start:end])+trailingWidth <= printOpts.PrintWidth {
+    return
+  }
+
+  // A named import/export clause with a single specifier is never broken by
+  // Prettier 3: `import { X } from "long"` and `export type { X } from "long"`
+  // stay inline even when the `from "..."` tail pushes the whole declaration
+  // past printWidth (Prettier breaks a brace clause only at two or more
+  // specifiers). The rule visits the brace clause (or the import declaration)
+  // in isolation, so without this it would break a one-name clause and diverge.
+  if isSingleSpecifierNamedClause(node) {
+    return
+  }
+
   // Skip nested-print fires: if the visiting node has an ancestor
   // that also belongs to the rule's set, the outer reflow already
   // includes us. Acting at every level would emit overlapping edits
@@ -144,8 +190,8 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   }
 
   // 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
+  // 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.
@@ -153,50 +199,42 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
     return
   }
 
+  // Abstain on any node nested inside a JSX expression container (`{…}`),
+  // the JSX analogue of the template-substitution guard above. A reflow
+  // node (call / conditional) that sits inside BOTH a JSX attribute
+  // initializer (`x={cond ? a : b}`) and a JSX child
+  // (`{items.map(…)}`) gets broken here, then the next pass measures each
+  // fragment flat, finds it fits, and reverts — `ttsc format` oscillates to
+  // the 10-pass cap and exits 2. `KindJsxExpression` wraps both the
+  // attribute `{…}` and the child `{…}`, so this one guard covers both.
+  if hasJsxExpressionAncestor(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
   // reflowing such a node would silently delete the comment.
-  // Conservative — false positives mean a missed reflow opportunity,
+  // Conservative, false positives mean a missed reflow opportunity,
   // not a regression. Coverage of inline comments inside lists is
   // the next slice of work.
   if hasNonChildComments(node, src, start, end) {
     return
   }
 
-  printOpts.StartingColumn = leadingColumn(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.
+  // 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 — 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)+trailingWidth <= printOpts.PrintWidth {
-    return
-  }
-
   printCtx := NewPrintContext(ctx.File, printOpts)
   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
+  // 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
@@ -207,8 +245,8 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
     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
+  // 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.
@@ -217,7 +255,7 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   // 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, the regression that keeps a call flat at exactly
   // printWidth while the trailing `;` runs over.
   if trailingWidth > 0 &&
     !strings.Contains(rendered, "\n") &&
@@ -233,8 +271,8 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   }
   // 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
+  // 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
@@ -255,14 +293,14 @@ 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 formatPrintWidth
 // 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
+// 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
+// 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
 // `formatPrintWidth: 'off'` onto the ttsc-lint benchmark branch).
@@ -278,11 +316,11 @@ func trailingLineWidth(src string, end int, tabWidth int) int {
   }
   lineEnd := trailingSuffixEnd(src, end)
   col := 0
-  for i := end; i < lineEnd; i++ {
-    if src[i] == '\t' {
+  for _, r := range src[end:lineEnd] {
+    if r == '\t' {
       col += tabWidth - (col % tabWidth)
     } else {
-      col++
+      col += runeWidth(r)
     }
   }
   return col
@@ -302,7 +340,7 @@ func trailingSuffixEnd(src string, end int) int {
     if src[lineEnd] == '/' && lineEnd+1 < len(src) {
       next := src[lineEnd+1]
       if next == '/' {
-        // `//` line comment — Prettier treats the whole tail as a
+        // `//` 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.
@@ -322,8 +360,8 @@ func trailingSuffixEnd(src string, end int) int {
 }
 
 // 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
+// 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.
 //
@@ -343,7 +381,7 @@ func maxLineWidth(text string, startingColumn, trailingWidth, tabWidth int) int
       if r == '\t' {
         width += tabWidth - (width % tabWidth)
       } else if r != '\r' {
-        width++
+        width += runeWidth(r)
       }
     }
     if i == 0 {
@@ -372,11 +410,11 @@ func leadingColumn(src string, pos int, tabWidth int) int {
   }
   lineStart := lineStartOffset(src, pos)
   col := 0
-  for i := lineStart; i < pos; i++ {
-    if src[i] == '\t' {
+  for _, r := range src[lineStart:pos] {
+    if r == '\t' {
       col += tabWidth - (col % tabWidth)
     } else {
-      col++
+      col += runeWidth(r)
     }
   }
   return col
@@ -389,7 +427,7 @@ func leadingColumn(src string, pos int, tabWidth int) int {
 //
 // Continuation lines (Hardline / broken-mode Line) emitted by the
 // reflow doc should align relative to this value, not relative to the
-// node's leading column — see PrintOptions.BaseIndent for the contract.
+// node's leading column, see PrintOptions.BaseIndent for the contract.
 //
 // When the visited node lives on a *continuation line* (e.g. an RHS
 // expression hanging below a binary operator on the previous line),
@@ -462,7 +500,7 @@ func lineStartOffset(src string, pos int) int {
 // 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.
+// 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') {
@@ -508,6 +546,26 @@ func hasTemplateSubstitutionAncestor(node *shimast.Node) bool {
   return false
 }
 
+// hasJsxExpressionAncestor reports whether `node` sits inside a JSX
+// expression container (`{…}`). formatPrintWidth abstains on such nodes for
+// the same reason as hasTemplateSubstitutionAncestor: a reflow node that lives
+// inside both a JSX attribute initializer and a JSX child breaks under
+// print-width and then reverts on the next pass when each fragment measures
+// flat, so `ttsc format` never converges and exits 2. `KindJsxExpression`
+// wraps both the attribute `{…}` and the child `{…}`, so a single ancestor
+// walk covers both placements.
+func hasJsxExpressionAncestor(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  for parent := node.Parent; parent != nil; parent = parent.Parent {
+    if parent.Kind == shimast.KindJsxExpression {
+      return true
+    }
+  }
+  return false
+}
+
 // isReflowKind reports whether `k` is one of the node kinds the
 // formatPrintWidth rule visits. Kept in sync with Visits() so
 // hasReflowAncestor does not need to call Visits() at runtime.
@@ -519,7 +577,8 @@ func isReflowKind(k shimast.Kind) bool {
     shimast.KindNewExpression,
     shimast.KindNamedImports,
     shimast.KindNamedExports,
-    shimast.KindImportDeclaration:
+    shimast.KindImportDeclaration,
+    shimast.KindConditionalExpression:
     return true
   }
   return false
@@ -528,7 +587,7 @@ func isReflowKind(k shimast.Kind) bool {
 // hasNonChildComments scans the byte range [start, end) and returns true
 // if any `//` or `/*` lives outside the union of `node`'s direct child
 // byte ranges. The rule uses this to abstain from reflows that would
-// drop inter-child comments — the v1 list printers join children with
+// drop inter-child comments, the v1 list printers join children with
 // a fresh separator that has no slot for trivia between them.
 //
 // The scan is byte-level for simplicity: a TS scanner would also work
@@ -537,7 +596,7 @@ func isReflowKind(k shimast.Kind) bool {
 // are children, so `"//"` inside them never reaches the comment
 // check). The residual conservative case is comment-shaped bytes
 // inside an inter-child gap that the TS grammar would never tokenize
-// as a comment — effectively nil for valid TypeScript source.
+// as a comment, effectively nil for valid TypeScript source.
 //
 // `format/sort-imports` chose the opposite path on a similar shape:
 // it actively preserves inter-specifier comments by walking the
@@ -558,18 +617,36 @@ func hasNonChildComments(node *shimast.Node, src string, start, end int) bool {
     // child.Pos() points at the start of leading trivia, which
     // can include comments belonging to the sibling boundary.
     // Trim past trivia so the inChild check only covers the
-    // child's actual token bytes — comments between siblings
+    // child's actual token bytes, comments between siblings
     // then surface to the scanner below.
     children = append(children, span{shimscanner.SkipTrivia(src, child.Pos()), child.End()})
     return false
   })
+  // inChild reports whether offset `i` lies inside any child's [pos, end)
+  // token range. The children are appended in source order (ForEachChild
+  // walks the AST in source order) with non-overlapping ranges, so a binary
+  // search for the last child whose `pos <= i` answers the query in O(log n)
+  // instead of the former O(n) per-byte linear scan. The boolean returned is
+  // identical to the linear scan for every offset; this is a pure speedup of
+  // the predicate, it changes no formatting output.
   inChild := func(i int) bool {
-    for _, c := range children {
-      if i >= c.pos && i < c.end {
-        return true
+    lo, hi := 0, len(children)
+    for lo < hi {
+      mid := (lo + hi) / 2
+      if children[mid].pos <= i {
+        lo = mid + 1
+      } else {
+        hi = mid
       }
     }
-    return false
+    // lo is the count of children with pos <= i; the candidate is the one
+    // just before it. A non-overlapping, source-ordered child list means at
+    // most this single candidate can contain `i`.
+    if lo == 0 {
+      return false
+    }
+    c := children[lo-1]
+    return i >= c.pos && i < c.end
   }
   for i := start; i < end-1 && i < len(src)-1; i++ {
     if inChild(i) {
@@ -582,6 +659,40 @@ func hasNonChildComments(node *shimast.Node, src string, start, end int) bool {
   return false
 }
 
+// isSingleSpecifierNamedClause reports whether `node` is a named import/export
+// brace clause (or an import declaration whose binding is one) carrying exactly
+// one specifier. Prettier never breaks such a clause; the print-width rule
+// abstains so a one-name `{ X }` survives a `from "long-path"` overflow inline.
+func isSingleSpecifierNamedClause(node *shimast.Node) bool {
+  switch node.Kind {
+  case shimast.KindNamedImports:
+    ni := node.AsNamedImports()
+    return ni != nil && ni.Elements != nil && len(ni.Elements.Nodes) == 1
+  case shimast.KindNamedExports:
+    ne := node.AsNamedExports()
+    return ne != nil && ne.Elements != nil && len(ne.Elements.Nodes) == 1
+  case shimast.KindImportDeclaration:
+    imp := node.AsImportDeclaration()
+    if imp == nil || imp.ImportClause == nil {
+      return false
+    }
+    clause := imp.ImportClause.AsImportClause()
+    if clause == nil || clause.NamedBindings == nil ||
+      clause.NamedBindings.Kind != shimast.KindNamedImports {
+      return false
+    }
+    // A default binding alongside the named clause (`import D, { X } from …`)
+    // makes Prettier break the brace even for a single specifier, so the
+    // abstain applies only to a bare `import { X } from …`.
+    if clause.Name() != nil {
+      return false
+    }
+    ni := clause.NamedBindings.AsNamedImports()
+    return ni != nil && ni.Elements != nil && len(ni.Elements.Nodes) == 1
+  }
+  return false
+}
+
 func init() {
   Register(formatPrintWidth{})
 }

package/linthost/rules_format_quote_props.go

@@ -0,0 +1,169 @@
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// formatQuoteProps normalizes quoting of object-literal property keys,
+// mirroring Prettier's `quoteProps`:
+//
+//   - "as-needed" (default): drop the quotes from a string key that is a
+//     valid identifier and not a numeric-looking key. `{ "foo": 1 }` becomes
+//     `{ foo: 1 }`; `{ "bar-baz": 1 }` and `{ "123": 1 }` keep their quotes.
+//   - "consistent": if ANY key in the object needs quotes, leave the object
+//     alone; otherwise unquote every removable key.
+//   - "preserve": never change quoting.
+//
+// Only quoted keys the rule can SAFELY unquote are ever touched: a string
+// whose content is a plain ASCII identifier (letters, `_`, `$`, digits after
+// the first) with no escapes. A key with escapes, unicode, a leading digit
+// (numeric-looking), or any non-identifier byte is left quoted in every
+// mode, so the rule can never produce an invalid key. Idempotent.
+type formatQuoteProps struct{}
+
+type formatQuotePropsOptions struct {
+  Mode string `json:"mode"`
+}
+
+func (formatQuoteProps) Name() string   { return "format/quote-props" }
+func (formatQuoteProps) IsFormat() bool { return true }
+
+func (formatQuoteProps) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindObjectLiteralExpression}
+}
+
+func (formatQuoteProps) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.File == nil || node == nil {
+    return
+  }
+  obj := node.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil {
+    return
+  }
+  var opts formatQuotePropsOptions
+  _ = ctx.DecodeOptions(&opts)
+  mode := opts.Mode
+  switch mode {
+  case "consistent", "preserve", "as-needed":
+  default:
+    mode = "as-needed"
+  }
+  if mode == "preserve" {
+    return
+  }
+
+  src := ctx.File.Text()
+
+  // removable collects each quoted key that is safely unquotable, paired
+  // with its bare identifier. anyMustStayQuoted records whether some quoted
+  // key cannot be unquoted (drives "consistent").
+  type removableKey struct {
+    start, end int
+    ident      string
+  }
+  var removable []removableKey
+  anyMustStayQuoted := false
+
+  for _, prop := range obj.Properties.Nodes {
+    if prop == nil {
+      continue
+    }
+    name := propertyKeyName(prop)
+    if name == nil || name.Kind != shimast.KindStringLiteral {
+      continue
+    }
+    ks := shimscanner.SkipTrivia(src, name.Pos())
+    ke := name.End()
+    if ks < 0 || ke <= ks || ke > len(src) {
+      return // give up on the whole object rather than risk a partial edit
+    }
+    ident := unquotableIdentifier(src[ks:ke])
+    if ident == "" {
+      anyMustStayQuoted = true
+      continue
+    }
+    removable = append(removable, removableKey{start: ks, end: ke, ident: ident})
+  }
+
+  if len(removable) == 0 {
+    return
+  }
+  // In "consistent" mode, if any key must stay quoted, the whole object is
+  // kept quoted, so unquote nothing.
+  if mode == "consistent" && anyMustStayQuoted {
+    return
+  }
+
+  var edits []TextEdit
+  for _, k := range removable {
+    edits = append(edits, TextEdit{Pos: k.start, End: k.end, Text: k.ident})
+  }
+  ctx.ReportRangeFix(
+    edits[0].Pos,
+    edits[0].End,
+    "Object property key does not need quotes.",
+    edits...,
+  )
+}
+
+// propertyKeyName returns the static name node of an object-literal property
+// (assignment, method, or accessor), or nil when it has no static name.
+func propertyKeyName(prop *shimast.Node) *shimast.Node {
+  switch prop.Kind {
+  case shimast.KindPropertyAssignment:
+    if p := prop.AsPropertyAssignment(); p != nil {
+      return p.Name()
+    }
+  case shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor:
+    return prop.Name()
+  }
+  return nil
+}
+
+// unquotableIdentifier returns the bare identifier a quoted string key can
+// safely become, or "" when the key must stay quoted. `raw` includes the
+// surrounding quotes. A key is unquotable only when its content is a plain
+// ASCII identifier with no escapes, conservative on purpose: a
+// numeric-looking key (`"123"`), a unicode key, an escaped key, or anything
+// with a non-identifier byte stays quoted, matching Prettier's never
+// unquoting `"123"` and guaranteeing the result is a valid bare key.
+func unquotableIdentifier(raw string) string {
+  if len(raw) < 2 {
+    return ""
+  }
+  q := raw[0]
+  if (q != '"' && q != '\'') || raw[len(raw)-1] != q {
+    return ""
+  }
+  inner := raw[1 : len(raw)-1]
+  if len(inner) == 0 {
+    return ""
+  }
+  if inner == "__proto__" {
+    // A bare `__proto__:` key in an object literal is the spec-special
+    // prototype setter (sets [[Prototype]]), whereas a quoted `"__proto__"`
+    // key is an ordinary own data property. Unquoting would change runtime
+    // semantics, so keep it quoted (Prettier does the same).
+    return ""
+  }
+  for i := 0; i < len(inner); i++ {
+    c := inner[i]
+    isLetter := (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '$'
+    isDigit := c >= '0' && c <= '9'
+    if i == 0 {
+      if !isLetter {
+        return "" // leading digit (numeric-looking) or other byte: keep quoted
+      }
+    } else if !isLetter && !isDigit {
+      return ""
+    }
+  }
+  return inner
+}
+
+func init() {
+  Register(formatQuoteProps{})
+}