@ttsc/lint 0.25.0 → 0.26.1

package/linthost/rules_format_brace_continuation.go

@@ -0,0 +1,267 @@
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// formatBraceContinuation places a continuation keyword against the clause it
+// continues, mirroring Prettier. The rule is one decision read in two
+// directions, taken from the shape of the preceding clause:
+//
+//   - the clause is a block, so the keyword shares its closing brace's line:
+//     `} else {`, `} catch (e) {`, `} finally {`, `} while (ready);`
+//   - the clause is not a block, so the keyword starts its own line:
+//     `if (a) x();` then `else y();`, and `do tick();` then `while (ready);`
+//
+// Both halves belong to one rule because they are the same decision. Splitting
+// them across two owners lets a source satisfy neither, which is what the
+// formatter did before: it never touched this boundary at all, so an
+// Allman-braced file survived `ttsc format` unchanged and a one-line
+// `if (a) x(); else y();` stayed on one line.
+//
+// The rule rewrites only the gap between the preceding clause's last byte and
+// the continuation keyword's first byte. No structural format rule contends for
+// it: `format/clause-join` rewrites the gap AFTER a header token,
+// `format/statement-split` splits statement-list members, and `format/indent`
+// visits statement-list members, closing-brace lines, and member headers.
+// `format/whitespace`'s trailing-whitespace trim does land inside the gap when
+// the clause line ends in spaces; the host drops one of the two findings and the
+// survivor re-fires on the next cascade pass, so the file still converges.
+//
+// A comment in the gap makes the rule abstain rather than relocate it, the same
+// abstention `format/clause-join` and `format/statement-split` apply. Idempotent
+// in both directions: once the keyword sits where it belongs the gap already
+// holds the target text and the rule emits nothing.
+type formatBraceContinuation struct{ optionsRule }
+
+// formatBraceContinuationOptions carries only the EOL setting. The push-down
+// direction copies the owning statement's own indent verbatim rather than
+// synthesizing one, so tabWidth and useTabs would decide nothing here and the
+// rule takes the same trimmed option surface `format/whitespace` does. The JSON
+// tag matches the `format` block key the config layer mirrors in (see
+// expandFormatBlock).
+type formatBraceContinuationOptions struct {
+  EndOfLine *string `json:"endOfLine"`
+}
+
+func (formatBraceContinuation) Name() string   { return "format/brace-continuation" }
+func (formatBraceContinuation) IsFormat() bool { return true }
+
+func (formatBraceContinuation) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindIfStatement,
+    shimast.KindTryStatement,
+    shimast.KindDoStatement,
+  }
+}
+
+// braceContinuation is one keyword placement: the clause that precedes it and
+// the keyword that continues it.
+type braceContinuation struct {
+  // previous is the clause the keyword continues. Its `End()` is the left edge
+  // of the gap, and whether it is a block decides the direction.
+  previous *shimast.Node
+  // keyword is the exact lexeme expected at the right edge of the gap. The
+  // following node cannot bound the scan: a catch clause and a finally block
+  // both start at the preceding clause's end, so their Pos() is the gap's left
+  // edge, not its right. Matching the lexeme instead is also what makes a
+  // comment in the gap detectable, since the first non-whitespace byte is then
+  // the comment rather than the keyword.
+  keyword string
+}
+
+func (formatBraceContinuation) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.File == nil || node == nil {
+    return
+  }
+  var opts formatBraceContinuationOptions
+  _ = ctx.DecodeOptions(&opts)
+  eol := "\n"
+  if opts.EndOfLine != nil && *opts.EndOfLine == "crlf" {
+    eol = "\r\n"
+  }
+  src := ctx.File.Text()
+  for _, continuation := range braceContinuations(node) {
+    placeBraceContinuation(ctx, src, node, continuation, eol)
+  }
+}
+
+// braceContinuations returns every continuation keyword `node` carries, paired
+// with the clause it continues.
+func braceContinuations(node *shimast.Node) []braceContinuation {
+  switch node.Kind {
+  case shimast.KindIfStatement:
+    stmt := node.AsIfStatement()
+    if stmt == nil || stmt.ElseStatement == nil || stmt.ThenStatement == nil {
+      return nil
+    }
+    return []braceContinuation{{previous: stmt.ThenStatement, keyword: "else"}}
+  case shimast.KindTryStatement:
+    stmt := node.AsTryStatement()
+    if stmt == nil || stmt.TryBlock == nil {
+      return nil
+    }
+    out := make([]braceContinuation, 0, 2)
+    previous := stmt.TryBlock.AsNode()
+    if stmt.CatchClause != nil {
+      out = append(out, braceContinuation{previous: previous, keyword: "catch"})
+      previous = stmt.CatchClause
+    }
+    if stmt.FinallyBlock != nil {
+      out = append(out, braceContinuation{previous: previous, keyword: "finally"})
+    }
+    return out
+  case shimast.KindDoStatement:
+    stmt := node.AsDoStatement()
+    if stmt == nil || stmt.Statement == nil || stmt.Expression == nil {
+      return nil
+    }
+    return []braceContinuation{{previous: stmt.Statement, keyword: "while"}}
+  }
+  return nil
+}
+
+func placeBraceContinuation(
+  ctx *Context,
+  src string,
+  node *shimast.Node,
+  continuation braceContinuation,
+  eol string,
+) {
+  previous := continuation.previous
+  if previous == nil {
+    return
+  }
+  gapStart := previous.End()
+  if gapStart < 0 || gapStart > len(src) {
+    return
+  }
+  // The gap is the whitespace run after the preceding clause. The bytes that
+  // follow it must be the continuation keyword itself: a comment there is
+  // content the rewrite would delete, and it shows up as a first non-whitespace
+  // byte that is not the keyword.
+  keywordStart := gapStart
+  for keywordStart < len(src) && isBraceContinuationGapByte(src[keywordStart]) {
+    keywordStart++
+  }
+  if !braceContinuationKeywordAt(src, keywordStart, continuation.keyword) {
+    return
+  }
+
+  want := " "
+  if !braceContinuationEndsInBlock(previous) {
+    // A non-block clause pushes the keyword onto its own line, indented to the
+    // statement that owns it. The whole gap is the target, so a keyword already
+    // on its own line at the wrong column is corrected by the same comparison
+    // instead of being ceded to a rule that never visits that line.
+    indent, ok := braceContinuationIndent(src, node)
+    if !ok {
+      return
+    }
+    want = eol + indent
+  }
+  if src[gapStart:keywordStart] == want {
+    return
+  }
+  ctx.ReportRangeFix(
+    gapStart,
+    keywordStart,
+    "Continuation keyword should sit against the clause it continues.",
+    TextEdit{Pos: gapStart, End: keywordStart, Text: want},
+  )
+}
+
+// braceContinuationIndent returns the leading whitespace of the line the
+// statement starts on, which is the column Prettier gives the pushed-down
+// keyword, and reports whether that column is knowable yet.
+//
+// A statement sharing its line with something else has no column of its own,
+// and nothing would repair a keyword pushed to column zero: `format/indent`
+// visits statement-list members, closing-brace lines, and member headers, and a
+// continuation-keyword line is none of the three. So the rule abstains, lets
+// `format/statement-split` give the statement its own line first, and reads the
+// real column on the next cascade pass. `format/indent` takes the same
+// not-first-on-its-line abstention for the same reason.
+func braceContinuationIndent(src string, node *shimast.Node) (string, bool) {
+  start := shimscanner.SkipTrivia(src, node.Pos())
+  if start < 0 || start > len(src) {
+    return "", false
+  }
+  lineStart := lineStartOffset(src, start)
+  indentEnd := lineStart
+  for indentEnd < start && (src[indentEnd] == ' ' || src[indentEnd] == '\t') {
+    indentEnd++
+  }
+  // A label prefix is part of the statement's own line rather than another
+  // statement sharing it, and nothing downstream would ever give a labeled body
+  // its own line, so refusing here would strand the keyword permanently.
+  if !isBraceContinuationLabelPrefix(src[indentEnd:start]) {
+    return "", false
+  }
+  return src[lineStart:indentEnd], true
+}
+
+// isBraceContinuationLabelPrefix reports whether `prefix` is empty or a run of
+// `identifier :` labels, the only thing allowed to precede a statement on the
+// line whose indent the pushed-down keyword adopts.
+func isBraceContinuationLabelPrefix(prefix string) bool {
+  for {
+    prefix = strings.TrimLeft(prefix, " \t")
+    if prefix == "" {
+      return true
+    }
+    name := 0
+    for name < len(prefix) && isBraceContinuationIdentifierByte(prefix[name]) {
+      name++
+    }
+    if name == 0 {
+      return false
+    }
+    rest := strings.TrimLeft(prefix[name:], " \t")
+    if !strings.HasPrefix(rest, ":") {
+      return false
+    }
+    prefix = rest[1:]
+  }
+}
+
+// braceContinuationEndsInBlock reports whether the keyword shares the preceding
+// clause's last line, which is what decides the direction. The predicate is the
+// clause's kind, not its last byte: a `switch` consequent and an Annex-B
+// `function` consequent both end in `}` and Prettier still pushes `else` onto
+// its own line after them. A catch clause is the one non-block kind that shares
+// its line, because the try printer always spaces `} finally`.
+func braceContinuationEndsInBlock(previous *shimast.Node) bool {
+  return previous.Kind == shimast.KindBlock || previous.Kind == shimast.KindCatchClause
+}
+
+// braceContinuationKeywordAt reports whether `keyword` starts at `offset` as a
+// whole token. The trailing boundary matters: `finally` must not match the
+// `final` prefix of an identifier a comment left exposed.
+func braceContinuationKeywordAt(src string, offset int, keyword string) bool {
+  end := offset + len(keyword)
+  if offset < 0 || end > len(src) || src[offset:end] != keyword {
+    return false
+  }
+  return end == len(src) || !isBraceContinuationIdentifierByte(src[end])
+}
+
+// isBraceContinuationIdentifierByte reports whether `c` can appear inside an
+// identifier, so a keyword is only accepted as a whole token.
+func isBraceContinuationIdentifierByte(c byte) bool {
+  return c == 0x5f || c == 0x24 ||
+    (c >= 0x61 && c <= 0x7a) || (c >= 0x41 && c <= 0x5a) || (c >= 0x30 && c <= 0x39)
+}
+
+// isBraceContinuationGapByte reports whether `c` is whitespace that may appear
+// between a clause and the keyword continuing it.
+func isBraceContinuationGapByte(c byte) bool {
+  return c == ' ' || c == '\t' || c == '\r' || c == '\n'
+}
+
+func init() {
+  Register(formatBraceContinuation{})
+}

package/linthost/rules_format_clause_join.go

@@ -13,16 +13,38 @@ import (
 //  if (a)
 //    b();
 //
-// becomes `if (a) b();` when the joined line fits printWidth. The same
-// applies to `for`, `for-in`, `for-of`, and `while` headers. A braced
-// body, a body that already shares the header line, a multi-line body,
-// or a join that would overflow printWidth is left untouched.
+// becomes `if (a) b();` when the joined line fits printWidth. The covered set
+// is Prettier's, not the set whose header happens to end in `)`: the `if`
+// consequent and alternate, the `for`, `for-in`, `for-of`, and `while` bodies,
+// the `do` body, the `with` body, and a labeled statement's body. A braced
+// body, a body that already shares the header line, a multi-line body, or a
+// join that would overflow printWidth is left untouched.
 //
-// The rule only ever rewrites the whitespace gap between a header's
-// closing `)` and the controlled statement, so its edits never overlap
-// `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.
+// Two clauses join unconditionally because Prettier gives them no group of
+// their own: an `else` whose alternate is another `if` (the `else if` chain),
+// and a labeled statement, which prints `label: statement` on one line whatever
+// the statement is, braces included. Those are the only clauses that can hoist a
+// multi-line body, and their continuation lines move by the same column delta
+// their first line travels, so the join does not settle on output Prettier would
+// still reindent.
+//
+// A continuation line whose newline sits inside a string, a template, or a
+// block comment is skipped rather than shifted: those bytes are content, and
+// moving them would change what the program prints or what a comment says. The
+// join itself still happens, because abandoning it leaves `format/indent` to
+// move the body's interior anyway and settles the file on a hybrid layout
+// Prettier never emits.
+//
+// The rule rewrites the whitespace gap between the clause's own header token
+// and the controlled statement, and, when it hoists a multi-line body, the
+// leading whitespace of that body's continuation lines. That surface overlaps
+// `format/indent`, which owns the same column for a hoisted body that contains
+// a block and cedes it only for a braceless control-flow body. The two agree on
+// the target column, so a collision costs a dropped finding and a re-fire rather
+// than a fight. Hoisting also contends with a nested join over the same bytes,
+// so a staircase settles roughly one level per cascade pass. Idempotent: once
+// joined the gap holds no newline, the shift compares against the text it would
+// write, and the rule abstains.
 type formatClauseJoin struct{ optionsRule }
 
 // formatClauseJoinOptions mirrors the printWidth/indent keys the rule
@@ -46,6 +68,9 @@ func (formatClauseJoin) Visits() []shimast.Kind {
     shimast.KindForStatement,
     shimast.KindForInStatement,
     shimast.KindForOfStatement,
+    shimast.KindDoStatement,
+    shimast.KindWithStatement,
+    shimast.KindLabeledStatement,
   }
 }
 
@@ -63,24 +88,67 @@ func (formatClauseJoin) Check(ctx *Context, node *shimast.Node) {
   if opts.TabWidth != nil && *opts.TabWidth > 0 {
     tabWidth = *opts.TabWidth
   }
-  joinClauseBody(ctx, ctx.File.Text(), node, clauseControlledBody(node), printWidth, tabWidth)
+  src := ctx.File.Text()
+  for _, target := range clauseControlledBodies(node) {
+    joinClauseBody(ctx, src, node, target, printWidth, tabWidth)
+  }
 }
 
-// clauseControlledBody returns the single controlled statement of a
-// control-flow header, the `then` branch for `if`, the loop body for
-// the iteration statements. The `else` branch is intentionally excluded:
-// its body is anchored after the `else` keyword rather than a `)`, so it
-// does not share this rule's `)`-anchored join shape.
-func clauseControlledBody(node *shimast.Node) *shimast.Node {
+// clauseJoinTarget is one joinable clause body plus the token that ends the
+// clause header immediately before it. The anchor is what generalizes the rule
+// past the `)`-headed statements: `else` and `do` end in a keyword, a labeled
+// statement ends in `:`, and requiring the exact token still keeps a comment
+// between header and body from being swallowed.
+type clauseJoinTarget struct {
+  body   *shimast.Node
+  anchor string
+  // alwaysJoin marks a clause Prettier keeps on the header line regardless of
+  // the body's own line count or the joined width: an `else if` chain and a
+  // labeled statement.
+  alwaysJoin bool
+}
+
+// clauseControlledBodies returns every clause body of `node` that Prettier
+// keeps on its header line, paired with the token that header ends in. The set
+// is Prettier's, not the AST's: the `if` consequent and alternate, the loop
+// bodies, the `do` body, the `with` body, and a labeled statement's body.
+func clauseControlledBodies(node *shimast.Node) []clauseJoinTarget {
   switch node.Kind {
   case shimast.KindIfStatement:
-    return node.AsIfStatement().ThenStatement
+    stmt := node.AsIfStatement()
+    if stmt == nil {
+      return nil
+    }
+    targets := []clauseJoinTarget{{body: stmt.ThenStatement, anchor: ")"}}
+    if stmt.ElseStatement != nil {
+      targets = append(targets, clauseJoinTarget{
+        body:   stmt.ElseStatement,
+        anchor: "else",
+        // Prettier prints an `else if` chain flat, so the alternate being an
+        // `if` joins even when that nested statement spans lines.
+        alwaysJoin: stmt.ElseStatement.Kind == shimast.KindIfStatement,
+      })
+    }
+    return targets
   case shimast.KindWhileStatement:
-    return node.AsWhileStatement().Statement
+    return []clauseJoinTarget{{body: node.AsWhileStatement().Statement, anchor: ")"}}
   case shimast.KindForStatement:
-    return node.AsForStatement().Statement
+    return []clauseJoinTarget{{body: node.AsForStatement().Statement, anchor: ")"}}
   case shimast.KindForInStatement, shimast.KindForOfStatement:
-    return node.AsForInOrOfStatement().Statement
+    return []clauseJoinTarget{{body: node.AsForInOrOfStatement().Statement, anchor: ")"}}
+  case shimast.KindDoStatement:
+    return []clauseJoinTarget{{body: node.AsDoStatement().Statement, anchor: "do"}}
+  case shimast.KindWithStatement:
+    return []clauseJoinTarget{{body: node.AsWithStatement().Statement, anchor: ")"}}
+  case shimast.KindLabeledStatement:
+    // A label carries no group of its own in Prettier: `label: statement` is
+    // one line whatever the statement is, so the body may be a block and may
+    // span lines.
+    return []clauseJoinTarget{{
+      body:       node.AsLabeledStatement().Statement,
+      anchor:     ":",
+      alwaysJoin: true,
+    }}
   }
   return nil
 }
@@ -89,18 +157,25 @@ func joinClauseBody(
   ctx *Context,
   src string,
   node *shimast.Node,
-  body *shimast.Node,
+  target clauseJoinTarget,
   printWidth int,
   tabWidth int,
 ) {
-  if body == nil || body.Kind == shimast.KindBlock {
+  body := target.body
+  if body == nil {
     return
   }
-  // An empty-statement body (`while (x)\n;`) glues directly to the header with
-  // NO space: Prettier's adjustClause special-cases EmptyStatement and returns
-  // the bare `;` (`while (x);`), only prepending a space when the empty
-  // statement carries a leading comment. This rule's gap->" " rewrite cannot
-  // produce the spaceless `);` glue, so abstain and leave the source shape.
+  // A braced body already owns its own line layout, except behind a label,
+  // where Prettier writes `label: {`.
+  if body.Kind == shimast.KindBlock && !target.alwaysJoin {
+    return
+  }
+  // An empty-statement body glues directly to the header with NO space:
+  // Prettier's adjustClause special-cases EmptyStatement and returns the bare
+  // `;` (`while (x);`, `else;`, `do;`, `label:;`), only prepending a space when
+  // the empty statement carries a leading comment. This rule joins with a
+  // single space and deliberately does not take on the spaceless variant, so it
+  // abstains and leaves the source shape rather than emitting `while (x) ;`.
   if body.Kind == shimast.KindEmptyStatement {
     return
   }
@@ -110,24 +185,29 @@ func joinClauseBody(
     return
   }
   // The gap is the whitespace run immediately before the body. Walk back
-  // over horizontal whitespace and newlines; the byte before it must be
-  // the header's closing `)` so a comment between header and body (which
+  // over horizontal whitespace and newlines; the bytes before it must be the
+  // clause's own header token so a comment between header and body (which
   // SkipTrivia would have stepped over) can never be swallowed.
   gapStart := bodyStart
   for gapStart > 0 && isClauseGapByte(src[gapStart-1]) {
     gapStart--
   }
-  if gapStart == 0 || src[gapStart-1] != ')' {
+  anchorStart := gapStart - len(target.anchor)
+  if anchorStart < 0 || src[anchorStart:gapStart] != target.anchor {
     return
   }
   gap := src[gapStart:bodyStart]
   if !strings.Contains(gap, "\n") {
     return // body already shares the header line
   }
-  // The header and the body must each be single-line; a multi-line body
-  // (e.g. a nested clause not yet joined) waits for the cascade to settle
-  // its inner join first.
+  // The header line is measured from the token that opens the clause. For a
+  // `)`-headed statement and a label that is the statement's own start; for
+  // `else` and `do` it is the keyword, which is where Prettier starts the line
+  // it would print.
   headerStart := shimscanner.SkipTrivia(src, node.Pos())
+  if isClauseAnchorWord(target.anchor) {
+    headerStart = anchorStart
+  }
   if headerStart < 0 || headerStart > gapStart {
     return
   }
@@ -135,28 +215,197 @@ func joinClauseBody(
   if strings.ContainsRune(src[headerLineStart:gapStart], '\n') {
     return
   }
-  if strings.ContainsRune(src[bodyStart:bodyEnd], '\n') {
-    return
+  if !target.alwaysJoin {
+    // The body must be single-line; a multi-line body (e.g. a nested clause
+    // not yet joined) waits for the cascade to settle its inner join first.
+    if strings.ContainsRune(src[bodyStart:bodyEnd], '\n') {
+      return
+    }
+    joined := visualWidth(src[headerLineStart:gapStart], tabWidth) + 1 +
+      visualWidth(src[bodyStart:bodyEnd], tabWidth)
+    if joined > printWidth {
+      return
+    }
   }
-  joined := visualWidth(src[headerLineStart:gapStart], tabWidth) + 1 +
-    visualWidth(src[bodyStart:bodyEnd], tabWidth)
-  if joined > printWidth {
-    return
+  edits := []TextEdit{{Pos: gapStart, End: bodyStart, Text: " "}}
+  // Hoisting the body's first line moves its base column. Every continuation
+  // line has to move with it, or the join settles on output Prettier would
+  // still reindent (#1139). Only an alwaysJoin clause can reach a multi-line
+  // body; the others already abstained above.
+  if strings.ContainsRune(src[bodyStart:bodyEnd], '\n') {
+    edits = append(edits, reindentJoinedClauseBody(
+      ctx, src, headerLineStart, bodyStart, bodyEnd, loadFormatLayout(ctx),
+    )...)
   }
   ctx.ReportRangeFix(
     gapStart,
     bodyStart,
     "Single-statement clause body should join its header line.",
-    TextEdit{Pos: gapStart, End: bodyStart, Text: " "},
+    edits...,
   )
 }
 
+// reindentJoinedClauseBody returns the edits that move a hoisted body's
+// continuation lines by the same column delta its first line travels.
+//
+// The delta is the header line's own indent minus the indent of the line the
+// body currently starts on, because the body's first line lands on the header
+// line and Prettier prints its continuations relative to that. Measuring from
+// the anchor token instead would charge the width of a `} ` prefix and shift
+// every continuation line two columns too far.
+//
+// A line the shift must not touch is skipped, not made to abandon the join.
+// Abandoning is strictly worse: `format/indent` still moves the body's interior
+// to its post-join column, so the file settles on a hybrid layout Prettier never
+// emits, which is the very property this shift exists to remove. Three kinds of
+// line are skipped: one whose newline sits inside a string, template, or block
+// comment, where the bytes are content rather than layout; a blank one, which
+// has no column; and one whose indent is shorter than an outdent needs.
+func reindentJoinedClauseBody(
+  ctx *Context,
+  src string,
+  headerLineStart int,
+  bodyStart int,
+  bodyEnd int,
+  layout formatLayout,
+) []TextEdit {
+  protected := collectClauseJoinProtectedRanges(ctx.File, src)
+  headerIndentEnd := headerLineStart
+  for headerIndentEnd < len(src) &&
+    (src[headerIndentEnd] == ' ' || src[headerIndentEnd] == '\t') {
+    headerIndentEnd++
+  }
+  bodyLineStart := lineStartOffset(src, bodyStart)
+  delta := visualWidth(src[headerLineStart:headerIndentEnd], layout.tabWidth) -
+    visualWidth(src[bodyLineStart:bodyStart], layout.tabWidth)
+  if delta == 0 {
+    return nil
+  }
+  var edits []TextEdit
+  for offset := bodyStart; offset < bodyEnd; offset++ {
+    if src[offset] != '\n' {
+      continue
+    }
+    if inTemplate(protected, offset) {
+      continue
+    }
+    lineStart := offset + 1
+    indentEnd := lineStart
+    for indentEnd < bodyEnd && (src[indentEnd] == ' ' || src[indentEnd] == '\t') {
+      indentEnd++
+    }
+    if indentEnd >= bodyEnd || src[indentEnd] == '\n' || src[indentEnd] == '\r' {
+      continue // a blank line carries no column
+    }
+    width := visualWidth(src[lineStart:indentEnd], layout.tabWidth) + delta
+    if width < 0 {
+      continue
+    }
+    next := clauseJoinIndentOfWidth(layout, width)
+    if src[lineStart:indentEnd] == next {
+      continue
+    }
+    edits = append(edits, TextEdit{Pos: lineStart, End: indentEnd, Text: next})
+  }
+  return edits
+}
+
+// clauseJoinIndentOfWidth renders a column count in the project's own
+// indentation unit, so a tab-indented file keeps its tabs instead of being
+// silently respaced by the shift.
+func clauseJoinIndentOfWidth(layout formatLayout, width int) string {
+  if width <= 0 {
+    return ""
+  }
+  if layout.useTabs && layout.tabWidth > 0 {
+    // A width that is not a whole number of tabs keeps the remainder in spaces
+    // rather than dropping every tab, which is the respacing this render exists
+    // to prevent.
+    return layout.indent(width/layout.tabWidth) +
+      strings.Repeat(" ", width%layout.tabWidth)
+  }
+  return strings.Repeat(" ", width)
+}
+
+// collectClauseJoinProtectedRanges returns every byte span whose interior
+// newlines carry content rather than layout: template literals, string literals
+// spanning a line continuation, and block comments. Shifting a line inside one
+// changes what the program prints or what a comment says.
+func collectClauseJoinProtectedRanges(file *shimast.SourceFile, src string) []byteRange {
+  ranges := collectTemplateRanges(file, src)
+  var walk func(node *shimast.Node)
+  walk = func(node *shimast.Node) {
+    if node == nil {
+      return
+    }
+    if node.Kind == shimast.KindStringLiteral {
+      pos := shimscanner.SkipTrivia(src, node.Pos())
+      end := node.End()
+      if pos >= 0 && end <= len(src) && end > pos {
+        ranges = append(ranges, byteRange{pos: pos, end: end})
+      }
+    }
+    node.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  if file != nil && file.Statements != nil {
+    for _, stmt := range file.Statements.Nodes {
+      walk(stmt)
+    }
+  }
+  forEachCommentToken(file, func(kind shimast.Kind, start, end int) {
+    if kind != shimast.KindMultiLineCommentTrivia {
+      return
+    }
+    // Only a comment Prettier reprints verbatim is content. An indentable one,
+    // every continuation line starting with `*`, is realigned by Prettier to the
+    // current indentation, so protecting it would leave a well-formed JSDoc
+    // block misaligned behind a hoisted body.
+    if isIndentableBlockComment(src, start, end) {
+      return
+    }
+    ranges = append(ranges, byteRange{pos: start, end: end})
+  })
+  return ranges
+}
+
+// isIndentableBlockComment reports whether every continuation line of a block
+// comment begins with `*`, which is the shape Prettier reindents rather than
+// reproducing byte for byte.
+func isIndentableBlockComment(src string, start, end int) bool {
+  if start < 0 || end > len(src) || end <= start {
+    return false
+  }
+  body := src[start:end]
+  if !strings.Contains(body, "\n") {
+    return false
+  }
+  for _, line := range strings.Split(body, "\n")[1:] {
+    trimmed := strings.TrimLeft(line, " \t\r")
+    if !strings.HasPrefix(trimmed, "*") {
+      return false
+    }
+  }
+  return true
+}
+
 // isClauseGapByte reports whether `c` is whitespace that may appear in
 // the gap between a clause header and its controlled statement.
 func isClauseGapByte(c byte) bool {
   return c == ' ' || c == '\t' || c == '\r' || c == '\n'
 }
 
+// isClauseAnchorWord reports whether an anchor is a keyword rather than
+// punctuation, which decides where the width budget starts measuring. The
+// anchor needs no identifier-boundary check: it is read backward from the AST
+// body's own position, so the token before the gap is the clause's real keyword
+// and an identifier ending in `else` or `do` cannot reach it.
+func isClauseAnchorWord(anchor string) bool {
+  return anchor == "else" || anchor == "do"
+}
+
 // visualWidth returns the display-column width of `s`: a tab expands to a flat
 // `tabWidth` columns and everything else is charged by displayWidth, which is
 // Prettier's own measurement. The only approximation left is the flat tab