@ttsc/lint 0.18.4 → 0.19.0

package/linthost/rules_escape.go

@@ -2,6 +2,7 @@ package linthost
 
 import (
   "strings"
+  "unicode/utf8"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
@@ -37,8 +38,11 @@ func (noUselessEscape) Check(ctx *Context, node *shimast.Node) {
   // Tagged templates expose the raw bytes of the template to the tag
   // function (`String.raw`, `dedent`, `gql`, `css`, …), so a backslash
   // that looks redundant to the JS lexer is meaningful at the tag
-  // boundary. ESLint canonical skips tagged templates entirely.
-  if isInsideTaggedTemplate(node) {
+  // boundary. ESLint canonical skips a tagged template's own quasis, but a
+  // literal merely nested inside a tag's substitution is not itself tagged
+  // and stays checked — so this consults the literal's OWN enclosing
+  // template, not any ancestor tag.
+  if isTaggedTemplateElement(node) {
     return
   }
   // tsgo's `node.Pos()` points at the start of leading trivia; the regex
@@ -82,6 +86,16 @@ const templateValidEscapes = "`'\"\\bfnrtv0xuU$\n\r"
 const regexNonClassValidEscapes = "^$\\.*+?()[]{}|/-\n\r"
 const regexClassValidEscapes = "\\]-^\n\r"
 
+// regexClassSetValidEscapes is the in-class allowlist for a `v`-flag
+// (unicodeSets) regex. There the ClassSetSyntaxCharacters `( ) [ ] { } / | -`
+// stay meaningful inside `[...]`, so a backslash before them is load-bearing:
+// stripping it (e.g. `/[\(]/v` → `/[(]/v`) turns valid source into a
+// `SyntaxError: Invalid character in character class`. Mirrors ESLint's
+// REGEX_CLASSSET_CHARACTER_ESCAPES; its `q` (from `\q{…}`) is handled with the
+// other shorthand letters in `isUselessRegexEscape`. `]` and `-` already sit
+// in the base set above.
+const regexClassSetValidEscapes = regexClassValidEscapes + "()[{}|/"
+
 // reportStringEscapes walks the raw source bytes of a string or template
 // literal and reports each backslash whose following character is not in
 // `whitelist`. `base` is the source offset of `raw[0]` so reported ranges
@@ -128,21 +142,18 @@ func reportStringEscapes(ctx *Context, raw string, base int, whitelist string, i
       continue
     }
     if isUselessStringEscape(next, whitelist) {
+      message := uselessEscapeMessage(raw[i+1:])
       // Only emit a fix when both surrounding bytes are plain ASCII so
       // deleting one byte cannot corrupt a multi-byte sequence.
       if next < 0x80 {
         ctx.ReportRangeFix(
           base+i,
           base+i+1,
-          "Unnecessary escape character: \\"+string(next)+".",
+          message,
           TextEdit{Pos: base + i, End: base + i + 1, Text: ""},
         )
       } else {
-        ctx.ReportRange(
-          base+i,
-          base+i+1,
-          "Unnecessary escape character: \\"+string(next)+".",
-        )
+        ctx.ReportRange(base+i, base+i+1, message)
       }
     }
     i++ // skip the escaped char so `\\\\` doesn't double-report.
@@ -151,7 +162,9 @@ func reportStringEscapes(ctx *Context, raw string, base int, whitelist string, i
 
 // reportRegexEscapes walks the pattern body of a regex literal and reports
 // backslashes that escape non-special characters. `base` is the source offset
-// of `raw[0]`. Character-class context (`[…]`) widens the legal set slightly.
+// of `raw[0]`. Character-class context (`[…]`) widens the legal set slightly,
+// and the trailing `v` (unicodeSets) flag widens it further because more
+// punctuation is meaningful inside a class in that mode.
 func reportRegexEscapes(ctx *Context, raw string, base int) {
   if len(raw) < 3 || raw[0] != '/' {
     return
@@ -163,6 +176,12 @@ func reportRegexEscapes(ctx *Context, raw string, base int) {
     return
   }
   body := raw[1:closing]
+  // Flags follow the closing slash. The `v` (unicodeSets) flag promotes the
+  // ClassSetSyntaxCharacters to meaningful members of a character class, so
+  // their escapes must be preserved there; deleting one corrupts the source.
+  // Mirrors ESLint selecting REGEX_CLASSSET_CHARACTER_ESCAPES over
+  // REGEX_GENERAL_ESCAPES on that flag.
+  unicodeSets := strings.IndexByte(raw[closing+1:], 'v') >= 0
   inClass := false
   for i := 0; i < len(body); i++ {
     ch := body[i]
@@ -178,29 +197,39 @@ func reportRegexEscapes(ctx *Context, raw string, base int) {
       continue
     }
     next := body[i+1]
-    if isUselessRegexEscape(next, inClass) {
+    if isUselessRegexEscape(next, inClass, unicodeSets) {
       // base + 1 (for the leading `/`) + i is the byte offset of the
       // backslash in the source.
       pos := base + 1 + i
+      message := uselessEscapeMessage(body[i+1:])
       if next < 0x80 {
         ctx.ReportRangeFix(
           pos,
           pos+1,
-          "Unnecessary escape character: \\"+string(next)+".",
+          message,
           TextEdit{Pos: pos, End: pos + 1, Text: ""},
         )
       } else {
-        ctx.ReportRange(
-          pos,
-          pos+1,
-          "Unnecessary escape character: \\"+string(next)+".",
-        )
+        ctx.ReportRange(pos, pos+1, message)
       }
     }
     i++ // consume the escaped character.
   }
 }
 
+// uselessEscapeMessage renders the diagnostic for one redundant backslash.
+// `rest` is the raw source starting at the escaped character, of which only
+// the leading UTF-8 rune is named. Decoding is required because the escape
+// target may be multi-byte: converting the lone lead byte would reinterpret it
+// as the code point of the same numeric value, so `\你` (lead byte 0xE4) would
+// accuse `ä` (U+00E4). ESLint canonical names the whole code point as well.
+// A byte that is not valid UTF-8 decodes to U+FFFD, which keeps the message
+// itself well-formed.
+func uselessEscapeMessage(rest string) string {
+  escaped, _ := utf8.DecodeRuneInString(rest)
+  return "Unnecessary escape character: \\" + string(escaped) + "."
+}
+
 // isUselessStringEscape reports whether a backslash before `ch` is redundant
 // inside a string or template literal. The `whitelist` contains the characters
 // that are valid escape targets for the specific literal kind (string vs template).
@@ -212,10 +241,16 @@ func isUselessStringEscape(ch byte, whitelist string) bool {
   if strings.IndexByte(whitelist, ch) >= 0 {
     return false
   }
+  // Digits 1-9 are octal-shaped (`no-octal-escape` owns those; `0` is in
+  // the whitelist). Deleting the backslash of `\1`…`\7` changes the cooked
+  // string value, and upstream ESLint skips backslash-digit entirely, so
+  // `\8`/`\9` are exempt too for oracle parity.
+  if ch >= '1' && ch <= '9' {
+    return false
+  }
   // ASCII letters that aren't in the whitelist are user-error escapes
-  // like `\a`, `\m`. Digits 1-9 are octal-shaped (`no-octal-escape`
-  // owns those). `0` is in the whitelist. Punctuation that isn't in the
-  // whitelist (e.g., `\.`) is also redundant.
+  // like `\a`, `\m`. Punctuation that isn't in the whitelist (e.g., `\.`)
+  // is also redundant.
   return true
 }
 
@@ -224,12 +259,18 @@ func isUselessStringEscape(ch byte, whitelist string) bool {
 // character class, which narrows the set of meaningful meta-char escapes:
 // most regex meta-chars (`.`, `*`, `+`, `?`, `(`, `)`, `{`, `}`, `|`, `^`,
 // `$`, `/`) are literal inside a class, so escaping them there is noise.
-func isUselessRegexEscape(ch byte, inClass bool) bool {
+// `unicodeSets` is true for a `v`-flag regex, where the ClassSetSyntaxCharacters
+// regain meaning inside a class and their escapes are therefore required.
+func isUselessRegexEscape(ch byte, inClass, unicodeSets bool) bool {
   if ch < 0x20 {
     return false
   }
   if inClass {
-    if strings.IndexByte(regexClassValidEscapes, ch) >= 0 {
+    classEscapes := regexClassValidEscapes
+    if unicodeSets {
+      classEscapes = regexClassSetValidEscapes
+    }
+    if strings.IndexByte(classEscapes, ch) >= 0 {
       return false
     }
   } else if strings.IndexByte(regexNonClassValidEscapes, ch) >= 0 {
@@ -258,33 +299,6 @@ func isUselessRegexEscape(ch byte, inClass bool) bool {
   return true
 }
 
-// isInsideTaggedTemplate reports whether `node` is the template payload of
-// a TaggedTemplateExpression. Two AST shapes reach here:
-//
-//   - `KindNoSubstitutionTemplateLiteral` — the direct child of a
-//     TaggedTemplateExpression's Template slot.
-//   - `KindTemplateHead/Middle/Tail` — wrapped in TemplateSpan and
-//     TemplateExpression nodes; the TemplateExpression's parent is the
-//     TaggedTemplateExpression.
-func isInsideTaggedTemplate(node *shimast.Node) bool {
-  if node == nil || node.Parent == nil {
-    return false
-  }
-  parent := node.Parent
-  if parent.Kind == shimast.KindTaggedTemplateExpression {
-    return true
-  }
-  // Walk up at most two more hops to reach the TaggedTemplateExpression
-  // for the spans family.
-  for i := 0; i < 2 && parent.Parent != nil; i++ {
-    parent = parent.Parent
-    if parent.Kind == shimast.KindTaggedTemplateExpression {
-      return true
-    }
-  }
-  return false
-}
-
 func init() {
   Register(noUselessEscape{})
 }

package/linthost/rules_format_arrow_parens.go

@@ -17,13 +17,16 @@ import (
 // other shape (`(x: T)`, `({ x })`, `(...x)`, `(x = 1)`, `(x?)`, `(x, y)`,
 // `()`) keeps its parentheses in both modes, exactly as Prettier does.
 // `async x => x` is handled too: the modifier sits before the parameter, so
-// the parameter-name span is unaffected.
+// the parameter-name span is unaffected. A legal trailing comma (`(x,) => x`)
+// counts as already parenthesized — a trailing comma can only exist inside a
+// parameter-list paren pair — so "always" leaves it alone and "avoid" deletes
+// the comma together with the parens (`x => x`, matching Prettier).
 //
 // The rule rewrites only the parameter span (`x` <-> `(x)`), never the body
 // or the `=>`, so a chained arrow `a => b => …` has each eligible arm
 // normalized independently. Idempotent: a parameter already in the
 // preferred shape compares equal and emits nothing.
-type formatArrowParens struct{}
+type formatArrowParens struct{ optionsRule }
 
 type formatArrowParensOptions struct {
   Prefer string `json:"prefer"`
@@ -90,9 +93,13 @@ func (formatArrowParens) Check(ctx *Context, node *shimast.Node) {
 
   // Is the parameter already wrapped in `(` … `)`? Scan over whitespace on
   // each side; the sole parameter of an arrow is delimited by the
-  // parameter-list parens when present.
+  // parameter-list parens when present. The forward scan starts at the
+  // parameter *list*'s end, not the name's: the list span covers a legal
+  // trailing comma (`(x,)` — that is how the AST records HasTrailingComma),
+  // so a trailing-comma list is classified as wrapped instead of the `,`
+  // byte aborting the scan and mis-reporting a bare name.
   openParen := scanBackForByte(src, nameStart, '(')
-  closeParen := scanForwardForByte(src, nameEnd, ')')
+  closeParen := scanForwardForByte(src, arrow.Parameters.End(), ')')
   wrapped := openParen >= 0 && closeParen >= 0
 
   switch prefer {
@@ -189,7 +196,10 @@ func arrowParamRegionHasComment(src string, paramPos, nameStart, nameEnd int) bo
   // paren so a comment between `)` and `=>` (`(x) /* c */ => x`) — which in
   // "avoid" mode would otherwise be stranded when the parens are stripped — is
   // also detected (Prettier keeps the parens of an arrow with such a dangling
-  // comment).
+  // comment). Likewise tolerate one trailing comma before the paren so a
+  // comment on either side of it (`(x /* c */,) => x`, `(x, /* c */) => x`) —
+  // which the "avoid" deletion would destroy — is also detected.
+  sawComma := false
   sawParen := false
   for i := nameEnd; i+1 < len(src); i++ {
     c := src[i]
@@ -199,6 +209,10 @@ func arrowParamRegionHasComment(src string, paramPos, nameStart, nameEnd int) bo
     if c == '/' && (src[i+1] == '*' || src[i+1] == '/') {
       return true
     }
+    if c == ',' && !sawComma && !sawParen {
+      sawComma = true
+      continue
+    }
     if c == ')' && !sawParen {
       sawParen = true
       continue

package/linthost/rules_format_bracket_spacing.go

@@ -22,7 +22,7 @@ import (
 // and an empty `{}` has no interior to pad. It rewrites just the whitespace
 // run immediately inside each brace, so it never disturbs the contents.
 // Idempotent: a pair already in the preferred shape compares equal.
-type formatBracketSpacing struct{}
+type formatBracketSpacing struct{ optionsRule }
 
 type formatBracketSpacingOptions struct {
   Spacing *bool `json:"spacing"`

package/linthost/rules_format_clause_join.go

@@ -23,7 +23,7 @@ import (
 // `format/indent` (leading whitespace of a line) or `format/print-width`
 // (interior reflow). Idempotent: once joined the gap holds no newline
 // and the rule abstains.
-type formatClauseJoin struct{}
+type formatClauseJoin struct{ optionsRule }
 
 // formatClauseJoinOptions mirrors the printWidth/indent keys the rule
 // needs to decide whether the joined line fits. The config layer mirrors

package/linthost/rules_format_declaration_header.go

@@ -46,7 +46,7 @@ import (
 // breaking heritage clause at once), a header carrying comments, or a
 // type/parameter that is itself multi-line makes the rule ABSTAIN, so it
 // never emits a header it cannot reproduce exactly.
-type formatDeclarationHeader struct{}
+type formatDeclarationHeader struct{ optionsRule }
 
 type formatDeclarationHeaderOptions struct {
   PrintWidth *int    `json:"printWidth"`
@@ -172,7 +172,7 @@ func (formatDeclarationHeader) Check(ctx *Context, node *shimast.Node) {
     // with a non-empty body; an interface (any body) and an empty body
     // keep `{` glued to the last header line (so an empty body reads
     // `… {}`). isClass && !emptyBody captures that.
-    brace := headerBrace(isClass, emptyBody, base)
+    brace := headerBrace(isClass, emptyBody, base, layout.eol)
     target, ok = brokenDeclarationHeader(src, base, prefix, typeParams, paramTexts, clauses, layout, brace, emptyBody, isClass)
     if !ok {
       return // unverified combination: abstain
@@ -194,6 +194,11 @@ type declarationHeaderLayout struct {
   printWidth int
   tabWidth   int
   oneLevel   string
+  // eol is the newline the reflow builders synthesize. It mirrors
+  // loadFormatLayout: `"\n"` by default, `"\r\n"` under endOfLine:"crlf",
+  // so a reflowed CRLF header stays consistently CRLF instead of gaining
+  // lone LFs.
+  eol string
 }
 
 func (l declarationHeaderLayout) indent(base string, depth int) string {
@@ -203,7 +208,7 @@ func (l declarationHeaderLayout) indent(base string, depth int) string {
 func loadDeclarationHeaderLayout(ctx *Context) declarationHeaderLayout {
   var opts formatDeclarationHeaderOptions
   _ = ctx.DecodeOptions(&opts)
-  l := declarationHeaderLayout{printWidth: 80, tabWidth: 2, oneLevel: "  "}
+  l := declarationHeaderLayout{printWidth: 80, tabWidth: 2, oneLevel: "  ", eol: "\n"}
   if opts.PrintWidth != nil && *opts.PrintWidth > 0 {
     l.printWidth = *opts.PrintWidth
   }
@@ -215,6 +220,9 @@ func loadDeclarationHeaderLayout(ctx *Context) declarationHeaderLayout {
   } else if opts.TabWidth != nil && *opts.TabWidth > 0 {
     l.oneLevel = strings.Repeat(" ", *opts.TabWidth)
   }
+  if opts.EndOfLine != nil && *opts.EndOfLine == "crlf" {
+    l.eol = "\r\n"
+  }
   return l
 }
 
@@ -392,11 +400,11 @@ func multiClauseHeader(prefix string, clauses []heritageClauseText, layout decla
   indent1 := layout.indent(base, 1)
   indent2 := layout.indent(base, 2)
   for ci, c := range clauses {
-    b.WriteString("\n")
+    b.WriteString(layout.eol)
     b.WriteString(indent1)
     b.WriteString(c.keyword)
     inlineWidth := visualWidth(indent1+c.keyword+" "+strings.Join(c.types, ", "), layout.tabWidth)
-    if ci == len(clauses)-1 && !strings.HasPrefix(brace, "\n") {
+    if ci == len(clauses)-1 && !strings.HasPrefix(brace, layout.eol) {
       inlineWidth += visualWidth(brace, layout.tabWidth)
     }
     if inlineWidth <= layout.printWidth {
@@ -405,7 +413,7 @@ func multiClauseHeader(prefix string, clauses []heritageClauseText, layout decla
       continue
     }
     for i, t := range c.types {
-      b.WriteString("\n")
+      b.WriteString(layout.eol)
       b.WriteString(indent2)
       b.WriteString(t)
       if i < len(c.types)-1 {
@@ -427,7 +435,7 @@ func multiTypeHeader(prefix string, clause heritageClauseText, layout declaratio
   indent1 := layout.indent(base, 1)
   inline := indent1 + clause.keyword + " " + strings.Join(clause.types, ", ")
   inlineWidth := visualWidth(inline, layout.tabWidth)
-  if !strings.HasPrefix(brace, "\n") {
+  if !strings.HasPrefix(brace, layout.eol) {
     inlineWidth += visualWidth(brace, layout.tabWidth)
   }
   if emptyBody {
@@ -437,16 +445,16 @@ func multiTypeHeader(prefix string, clause heritageClauseText, layout declaratio
     inlineWidth++
   }
   if inlineWidth <= layout.printWidth {
-    return prefix + "\n" + inline + brace
+    return prefix + layout.eol + inline + brace
   }
 
   var b strings.Builder
   b.WriteString(prefix)
-  b.WriteString("\n")
+  b.WriteString(layout.eol)
   b.WriteString(indent1)
   b.WriteString(clause.keyword)
   for i, t := range clause.types {
-    b.WriteString("\n")
+    b.WriteString(layout.eol)
     b.WriteString(layout.indent(base, 2))
     b.WriteString(t)
     if i < len(clause.types)-1 {
@@ -524,14 +532,15 @@ func singleGenericHeritageHeader(src, base, prefix string, typeParams, heritage
   b.WriteString(keyword)
   b.WriteString(" ")
   b.WriteString(typeName)
-  b.WriteString("<\n")
+  b.WriteString("<")
+  b.WriteString(layout.eol)
   for i, a := range args {
     b.WriteString(layout.indent(base, 1))
     b.WriteString(a)
     if i < len(args)-1 {
       b.WriteString(",")
     }
-    b.WriteString("\n")
+    b.WriteString(layout.eol)
   }
   b.WriteString(base)
   b.WriteString("> {")
@@ -541,10 +550,11 @@ func singleGenericHeritageHeader(src, base, prefix string, typeParams, heritage
 // headerBrace returns the opening-brace fragment that closes a broken
 // header. Prettier puts `{` on its own line only for a class with a
 // non-empty body; an interface and any empty body keep it glued to the
-// last header line.
-func headerBrace(isClass, emptyBody bool, base string) string {
+// last header line. `eol` is the synthesized newline (LF or CRLF) so the
+// own-line brace matches the file's line endings.
+func headerBrace(isClass, emptyBody bool, base, eol string) string {
   if isClass && !emptyBody {
-    return "\n" + base + "{"
+    return eol + base + "{"
   }
   return " {"
 }
@@ -579,11 +589,13 @@ func typeParamExplodeHeader(
 ) string {
   var b strings.Builder
   b.WriteString(prefix)
-  b.WriteString("<\n")
+  b.WriteString("<")
+  b.WriteString(layout.eol)
   paramIndent := layout.indent(base, 1)
   for _, p := range typeParams.Nodes {
     b.WriteString(renderExplodedTypeParam(src, p, layout, paramIndent))
-    b.WriteString(",\n")
+    b.WriteString(",")
+    b.WriteString(layout.eol)
   }
   b.WriteString(base)
   b.WriteString(">")
@@ -594,7 +606,7 @@ func typeParamExplodeHeader(
     //   >
     //     extends IPage.IRequest {
     c := clauses[0]
-    b.WriteString("\n")
+    b.WriteString(layout.eol)
     b.WriteString(layout.indent(base, 1))
     b.WriteString(c.keyword)
     b.WriteString(" ")
@@ -628,7 +640,7 @@ func renderExplodedTypeParam(src string, p *shimast.Node, layout declarationHead
         head := strings.TrimRight(src[start:defStart], " \t") // ends in `=`
         def := strings.TrimSpace(src[defStart:end])
         if head != "" && def != "" {
-          return paramIndent + head + "\n" + paramIndent + layout.oneLevel + def
+          return paramIndent + head + layout.eol + paramIndent + layout.oneLevel + def
         }
       }
     }

package/linthost/rules_format_indent.go

@@ -31,7 +31,7 @@ import (
 //
 // Idempotent: a correctly-indented statement compares equal in step 3
 // and emits nothing.
-type formatIndent struct{}
+type formatIndent struct{ optionsRule }
 
 func (formatIndent) Name() string   { return "format/indent" }
 func (formatIndent) IsFormat() bool { return true }

package/linthost/rules_format_jsdoc.go

@@ -25,7 +25,7 @@ import (
 // `/** ... */` blocks; it deliberately avoids relying on the JSDoc AST
 // because comment attachment is a moving target across TypeScript
 // versions.
-type formatJSDoc struct{}
+type formatJSDoc struct{ optionsRule }
 
 // formatJSDocOptions mirrors `TtscLintRuleOptions.JSDoc`. The
 // `tagSynonyms` map layers on top of the built-in synonym table so

package/linthost/rules_format_orphan_semi.go

@@ -24,7 +24,7 @@ import (
 // is left alone, dropping a redundant `;` safely depends on the
 // surrounding semicolon policy and is out of scope here. Idempotent:
 // once merged the gap holds no newline, so the rule finds nothing to do.
-type formatOrphanSemi struct{}
+type formatOrphanSemi struct{ optionsRule }
 
 // formatOrphanSemiOptions carries the effective `semi` setting, mirrored
 // from format.semi by the config layer. Defaults to true (semicolons),

package/linthost/rules_format_parameter_properties.go

@@ -25,13 +25,15 @@ import (
 // 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{}
+type formatParameterProperties struct{ optionsRule }
 
-// formatParameterPropertiesOptions carries the indentation settings the
-// rewrite needs. The config layer mirrors format.tabWidth/useTabs in.
+// formatParameterPropertiesOptions carries the indentation + EOL settings
+// the rewrite needs. The config layer mirrors
+// format.tabWidth/useTabs/endOfLine in.
 type formatParameterPropertiesOptions struct {
-  TabWidth *int  `json:"tabWidth"`
-  UseTabs  *bool `json:"useTabs"`
+  TabWidth  *int    `json:"tabWidth"`
+  UseTabs   *bool   `json:"useTabs"`
+  EndOfLine *string `json:"endOfLine"`
 }
 
 func (formatParameterProperties) Name() string   { return "format/parameter-properties" }
@@ -111,10 +113,18 @@ func (formatParameterProperties) Check(ctx *Context, node *shimast.Node) {
   } else if opts.TabWidth != nil && *opts.TabWidth > 0 {
     oneLevel = strings.Repeat(" ", *opts.TabWidth)
   }
+  // The synthesized break mirrors loadFormatLayout: `"\n"` by default,
+  // `"\r\n"` under endOfLine:"crlf", so a broken CRLF constructor keeps
+  // consistent line endings instead of gaining lone LFs.
+  eol := "\n"
+  if opts.EndOfLine != nil && *opts.EndOfLine == "crlf" {
+    eol = "\r\n"
+  }
   inner := indent + oneLevel
 
   var b strings.Builder
-  b.WriteString("(\n")
+  b.WriteString("(")
+  b.WriteString(eol)
   for i, p := range params {
     if p == nil {
       return
@@ -129,7 +139,7 @@ func (formatParameterProperties) Check(ctx *Context, node *shimast.Node) {
     if i < len(params)-1 {
       b.WriteByte(',')
     }
-    b.WriteByte('\n')
+    b.WriteString(eol)
   }
   b.WriteString(indent)
   b.WriteByte(')')

package/linthost/rules_format_print_width.go

@@ -49,7 +49,7 @@ import (
 // configured severities. Reuses the `error` severity caveat from
 // other format rules: only set `error` once the full reflow coverage
 // is mature.
-type formatPrintWidth struct{}
+type formatPrintWidth struct{ optionsRule }
 
 // formatPrintWidthOptions mirrors `TtscLintRuleOptions.PrintWidth`.
 //

package/linthost/rules_format_quote_props.go

@@ -20,7 +20,7 @@ import (
 // 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 formatQuoteProps struct{ optionsRule }
 
 type formatQuotePropsOptions struct {
   Mode string `json:"mode"`

package/linthost/rules_format_quotes.go

@@ -23,7 +23,7 @@ import (
 // quotes corrupts working code. Template literals, no-substitution
 // template literals, and JSX text nodes use distinct AST kinds and are
 // also intentionally out of scope.
-type formatQuotes struct{}
+type formatQuotes struct{ optionsRule }
 
 // formatQuotesOptions mirrors `TtscLintRuleOptions.Quotes`. Prefer accepts
 // `"double"` (the default, enforces double quotes) or `"single"` (enforces