@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_format_parameter_properties.go

@@ -0,0 +1,175 @@
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// formatParameterProperties breaks a constructor's parameter list onto
+// one-parameter-per-line when it declares parameter properties, matching
+// Prettier 3. Prettier forces the break whenever a constructor has more
+// than one parameter and at least one carries an accessibility or
+// `readonly` modifier (a parameter property), regardless of whether the
+// flat form fits printWidth:
+//
+//   constructor(
+//     private readonly repo: Repository,
+//     private readonly logger: Logger,
+//   ) {}
+//
+// A single parameter property stays inline (`constructor(private x: T)`),
+// and a constructor with no parameter property is left to the ordinary
+// width-driven reflow. The rule rewrites only the `(...)` parameter
+// region and emits no trailing comma, format/trailing-comma adds it on
+// the now-multi-line list, so the two rules stay disjoint. Idempotent:
+// an already-broken list contains a newline and is skipped.
+type formatParameterProperties struct{}
+
+// formatParameterPropertiesOptions carries the indentation settings the
+// rewrite needs. The config layer mirrors format.tabWidth/useTabs in.
+type formatParameterPropertiesOptions struct {
+  TabWidth *int  `json:"tabWidth"`
+  UseTabs  *bool `json:"useTabs"`
+}
+
+func (formatParameterProperties) Name() string   { return "format/parameter-properties" }
+func (formatParameterProperties) IsFormat() bool { return true }
+
+func (formatParameterProperties) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindConstructor}
+}
+
+func (formatParameterProperties) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.File == nil || node == nil {
+    return
+  }
+  ctor := node.AsConstructorDeclaration()
+  if ctor == nil || ctor.Parameters == nil {
+    return
+  }
+  params := ctor.Parameters.Nodes
+  // Prettier only force-breaks when there is more than one parameter; a
+  // lone parameter property stays inline.
+  if len(params) < 2 || !anyParameterProperty(params) {
+    return
+  }
+
+  src := ctx.File.Text()
+  // The constructor must be the first token on its line so its leading
+  // whitespace is a sound base indent; otherwise abstain.
+  ctorStart := shimscanner.SkipTrivia(src, node.Pos())
+  if ctorStart < 0 || ctorStart > len(src) {
+    return
+  }
+  lineStart := lineStartOffset(src, ctorStart)
+  for i := lineStart; i < ctorStart; i++ {
+    if src[i] != ' ' && src[i] != '\t' {
+      return
+    }
+  }
+  indent := src[lineStart:ctorStart]
+
+  // Locate the `(` immediately preceding the first parameter (scanning
+  // back over whitespace only, so a parameter decorator's own `(` is
+  // never mistaken for it) and the matching `)`.
+  firstStart := shimscanner.SkipTrivia(src, params[0].Pos())
+  openPos := -1
+  for i := firstStart - 1; i >= 0; i-- {
+    c := src[i]
+    if c == '(' {
+      openPos = i
+      break
+    }
+    if c != ' ' && c != '\t' && c != '\r' && c != '\n' {
+      return
+    }
+  }
+  if openPos < 0 {
+    return
+  }
+  closePos := findCloseTokenAfter(src, ctor.Parameters.End(), ')')
+  if closePos < 0 {
+    return
+  }
+  region := src[openPos : closePos+1]
+  if strings.ContainsRune(region, '\n') {
+    return // already multi-line
+  }
+  // A comment inside the region cannot survive the param-by-param
+  // reconstruction, so abstain rather than drop it.
+  if strings.Contains(region, "//") || strings.Contains(region, "/*") {
+    return
+  }
+
+  var opts formatParameterPropertiesOptions
+  _ = ctx.DecodeOptions(&opts)
+  oneLevel := "  "
+  if opts.UseTabs != nil && *opts.UseTabs {
+    oneLevel = "\t"
+  } else if opts.TabWidth != nil && *opts.TabWidth > 0 {
+    oneLevel = strings.Repeat(" ", *opts.TabWidth)
+  }
+  inner := indent + oneLevel
+
+  var b strings.Builder
+  b.WriteString("(\n")
+  for i, p := range params {
+    if p == nil {
+      return
+    }
+    ps := shimscanner.SkipTrivia(src, p.Pos())
+    pe := p.End()
+    if ps < 0 || pe < ps || pe > len(src) {
+      return
+    }
+    b.WriteString(inner)
+    b.WriteString(strings.TrimRight(src[ps:pe], " \t"))
+    if i < len(params)-1 {
+      b.WriteByte(',')
+    }
+    b.WriteByte('\n')
+  }
+  b.WriteString(indent)
+  b.WriteByte(')')
+  newText := b.String()
+  if newText == region {
+    return
+  }
+  ctx.ReportRangeFix(
+    openPos,
+    closePos+1,
+    "Constructor with parameter properties should list one parameter per line.",
+    TextEdit{Pos: openPos, End: closePos + 1, Text: newText},
+  )
+}
+
+// anyParameterProperty reports whether any parameter carries an
+// accessibility (`public`/`private`/`protected`) or `readonly` modifier,
+// which makes it a parameter property.
+func anyParameterProperty(params []*shimast.Node) bool {
+  for _, p := range params {
+    if p == nil {
+      continue
+    }
+    mods := p.Modifiers()
+    if mods == nil {
+      continue
+    }
+    for _, m := range mods.Nodes {
+      switch m.Kind {
+      case shimast.KindPublicKeyword,
+        shimast.KindPrivateKeyword,
+        shimast.KindProtectedKeyword,
+        shimast.KindReadonlyKeyword:
+        return true
+      }
+    }
+  }
+  return false
+}
+
+func init() {
+  Register(formatParameterProperties{})
+}

package/linthost/rules_format_print_width.go

@@ -7,7 +7,7 @@ import (
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-// format/print-width reflows expressions and declarations so they fit
+// formatPrintWidth reflows expressions and declarations so they fit
 // within a `printWidth`-column budget, mirroring Prettier's headline
 // formatting feature.
 //
@@ -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,
   }
 }
 
@@ -102,7 +103,7 @@ func (formatPrintWidth) Visits() []shimast.Kind {
 //     reflow surface.
 //
 // Both cases are tracked benchmark cases that forced
-// `format/print-width: 'off'` on the ttsc-lint branch. They are listed
+// `formatPrintWidth: '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) {
@@ -135,6 +136,35 @@ 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.
+  if !sliceContainsNewline(src, start, end) &&
+    printOpts.StartingColumn+(end-start)+trailingWidth <= printOpts.PrintWidth {
+    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 +174,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.
@@ -157,46 +187,26 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   // 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 +217,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 +227,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 +243,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
@@ -253,19 +263,19 @@ 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
+// 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
 // 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
-// `format/print-width: 'off'` onto the ttsc-lint benchmark branch).
+// `formatPrintWidth: '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.
@@ -302,7 +312,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 +332,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.
 //
@@ -389,7 +399,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),
@@ -457,12 +467,12 @@ func lineStartOffset(src string, pos int) int {
 
 // 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
+// and 0 otherwise. formatPrintWidth 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.
+// 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') {
@@ -475,7 +485,7 @@ func ternaryArmIndentBonus(src string, pos int) int {
 }
 
 // hasReflowAncestor reports whether any ancestor of `node` would also
-// match the format/print-width visitor. The rule uses this to suppress
+// match the formatPrintWidth visitor. The rule uses this to suppress
 // nested fires when an enclosing reflow target already covers the
 // child.
 func hasReflowAncestor(node *shimast.Node) bool {
@@ -491,7 +501,7 @@ func hasReflowAncestor(node *shimast.Node) bool {
 }
 
 // hasTemplateSubstitutionAncestor reports whether `node` sits inside a
-// template-literal substitution (`${…}`). format/print-width abstains
+// template-literal substitution (`${…}`). formatPrintWidth 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
@@ -509,7 +519,7 @@ func hasTemplateSubstitutionAncestor(node *shimast.Node) bool {
 }
 
 // isReflowKind reports whether `k` is one of the node kinds the
-// format/print-width rule visits. Kept in sync with Visits() so
+// formatPrintWidth 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 {
@@ -519,7 +529,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 +539,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 +548,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,7 +569,7 @@ 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

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{})
+}