@ttsc/lint 0.19.2 → 0.20.0

package/linthost/rules_format_clause_join.go

@@ -158,18 +158,21 @@ func isClauseGapByte(c byte) bool {
 }
 
 // visualWidth returns the display-column width of `s`: a tab expands to a flat
-// `tabWidth` columns and every other rune is charged its display width via
-// runeWidth (combining marks 0, wide East-Asian/emoji 2), matching displayWidth.
-// The only approximation left is the flat tab expansion (no tab-stop rounding),
-// which never changes a real clause-join decision.
+// `tabWidth` columns and everything else is charged by displayWidth, which is
+// Prettier's own measurement. The only approximation left is the flat tab
+// expansion (no tab-stop rounding), which never changes a real clause-join
+// decision.
+//
+// Split on tabs rather than walked per rune, because displayWidth is not a sum
+// over runes: an emoji sequence is measured whole, and splitting it would
+// charge its parts.
 func visualWidth(s string, tabWidth int) int {
   width := 0
-  for _, r := range s {
-    if r == '\t' {
+  for i, segment := range strings.Split(s, "\t") {
+    if i > 0 {
       width += tabWidth
-      continue
     }
-    width += runeWidth(r)
+    width += displayWidth(segment)
   }
   return width
 }

package/linthost/rules_format_indent.go

@@ -150,13 +150,69 @@ func (formatIndent) Check(ctx *Context, node *shimast.Node) {
         return
       }
       lineStart := lineStartOffset(src, closeBrace)
-      // The `}` must be the first non-whitespace byte on its line; a brace
-      // sharing a line with content (`} else {`, `{ x }`) is not this
-      // rule's to move.
+      // A `}` sharing its line with content splits into two cases, and
+      // abstaining on both is what let the cascade converge on a malformed
+      // block. When the block opened on this same line it is a one-line block
+      // the cascade left whole (`{ x }`), and the brace is not this rule's to
+      // move. When the block opened earlier, the statement split already broke
+      // the body onto its own lines and stranded the brace at the end of the
+      // last statement — a hybrid Prettier never produces, and a fixed point,
+      // because nothing else claimed that brace. This rule takes it, so the two
+      // stay edit-disjoint within a pass instead of both abstaining.
+      stranded := false
       for i := lineStart; i < closeBrace; i++ {
         if src[i] != ' ' && src[i] != '\t' {
+          stranded = true
+          break
+        }
+      }
+      if stranded {
+        // An empty body is `{}` in Prettier however its header wrapped, so a
+        // `}` whose only preceding content on the line is its own `{` is never
+        // this rule's to move. Checked first, and independently of the frame
+        // span below: `format/declaration-header` deliberately GLUES `{}` to
+        // the last line of a broken class or interface header, and that head
+        // starts lines above the brace, so the span test alone would unglue on
+        // the next pass exactly what that rule just gathered.
+        if bodyIsEmptyAtBrace(src, lineStart, closeBrace) {
+          return
+        }
+        // A frame that begins on the brace's own line is still whole
+        // (`{ x }`, `class C { m() {} }` before anything has split): the
+        // cascade has not broken the body out yet, so there is nothing for the
+        // brace to be consistent with. Once another pass moves the body onto
+        // its own lines the frame spans lines, this test stops holding, and
+        // the brace is claimed then.
+        //
+        // Measured on the frame node, which for a Block, ModuleBlock,
+        // CaseBlock, or type literal IS its `{`, and for a class or interface
+        // is the first byte of the declaration. The declaration start is never
+        // below its own `{`, so a body that has been broken out still reads as
+        // spanning; the one shape where the two differ — a wrapped header over
+        // a one-line body — is a shape Prettier expands as well.
+        if start := shimscanner.SkipTrivia(src, block.Pos()); start < 0 ||
+          start > len(src) || lineStartOffset(src, start) == lineStart {
+          return
+        }
+        if indentCededToReflow(block) || cededUnderBracelessBody(block) ||
+          typeLiteralIndentCeded(src, block, ownerDepth, layout) ||
+          cededUnderWrappedFunctionExpression(src, block) ||
+          cededByChainedArrowAncestor(block) {
           return
         }
+        // Replace the run of spaces and tabs before the brace rather than
+        // inserting beside it, so a re-run finds the brace already alone on its
+        // line and this branch never fires twice.
+        gap := closeBrace
+        for gap > lineStart && (src[gap-1] == ' ' || src[gap-1] == '\t') {
+          gap--
+        }
+        edits = append(edits, TextEdit{
+          Pos:  gap,
+          End:  closeBrace,
+          Text: layout.eol + layout.indent(ownerDepth),
+        })
+        return
       }
       // indentCededToReflow walks block.Parent upward, the same ancestor
       // chain a body statement would, so a callback / expression-nested
@@ -186,11 +242,21 @@ func (formatIndent) Check(ctx *Context, node *shimast.Node) {
         return
       }
       want := layout.indent(depth)
+      // A member or clause label sharing a line with the `{` that opened its
+      // body, or with the member before it, is the other half of the stranded
+      // brace: nothing else claims it, so a flat `class C { m() { … } }` or
+      // `switch (n) { case 1: … }` had no first edit and the whole cascade
+      // stalled on it. Breaking it out is what lets the statement split and the
+      // brace pass see the multi-line frame they act on.
+      pos := shimscanner.SkipTrivia(src, header.Pos())
+      if breakOntoOwnLine(src, header, pos, depth, want, layout, &edits) {
+        return
+      }
       decorators := header.Decorators()
       if len(decorators) == 0 {
         // Undecorated member: header.Pos() is the declaration's first byte,
         // so its line is the only one to align.
-        reindentHeaderLine(src, shimscanner.SkipTrivia(src, header.Pos()), want, &edits)
+        reindentHeaderLine(src, pos, want, &edits)
         return
       }
       // A decorated member spans multiple physical lines when its decorators
@@ -563,6 +629,91 @@ func reindentHeaderLine(src string, pos int, want string, edits *[]TextEdit) {
   *edits = append(*edits, TextEdit{Pos: lineStart, End: pos, Text: want})
 }
 
+// bodyIsEmptyAtBrace reports whether the only thing before `closeBrace` on its
+// line, past horizontal whitespace, is the `{` that opened the same body.
+func bodyIsEmptyAtBrace(src string, lineStart int, closeBrace int) bool {
+  probe := closeBrace
+  for probe > lineStart && (src[probe-1] == ' ' || src[probe-1] == '\t') {
+    probe--
+  }
+  return probe > 0 && src[probe-1] == '{'
+}
+
+// frameLineIsWhereDepthSays reports whether the line a frame opens on is
+// indented to exactly the depth the block model computes for it. It is
+// typeLiteralIndentCeded's test, generalized: when it does not hold, some other
+// owner (a printer reflow, a wrapped initializer, a chain continuation) placed
+// the frame, and a member indented to `layout.indent(memberDepth)` would land
+// at a column unrelated to its own `{`.
+func frameLineIsWhereDepthSays(
+  src string,
+  frame *shimast.Node,
+  frameDepth int,
+  layout formatLayout,
+) bool {
+  if frame == nil {
+    return false
+  }
+  open := shimscanner.SkipTrivia(src, frame.Pos())
+  if open < 0 || open > len(src) {
+    return false
+  }
+  lineStart := lineStartOffset(src, open)
+  i := lineStart
+  for i < len(src) && (src[i] == ' ' || src[i] == '\t') {
+    i++
+  }
+  return src[lineStart:i] == layout.indent(frameDepth)
+}
+
+// breakOntoOwnLine moves a member or clause header that shares its line with
+// earlier content down to a line of its own at `want`, and reports whether it
+// emitted that edit. It replaces the run of spaces and tabs before the header
+// rather than inserting beside it, so a re-run finds the header already alone
+// on its line and this never fires twice.
+//
+// A type-literal member is exempt. Prettier expands a class or interface body
+// unconditionally, but an object TYPE keeps the author's shape when the source
+// wrote no line break after `{` — `type T = { a: number }` stays one line — so
+// breaking its members out would reformat conforming source. The type
+// literal's own `}` is not exempt: a member already on its own line above a
+// stranded `}` is a shape Prettier does not produce either way.
+//
+// A frame whose own line is not at the column the depth model computes is
+// exempt too. `want` is derived from block nesting alone, so under a wrapped
+// initializer (`const C: Ctor =\n  class { m() {} };`) it names a column
+// shallower than the `{` the member belongs to, and breaking there would place
+// the member left of its own frame.
+func breakOntoOwnLine(
+  src string,
+  header *shimast.Node,
+  pos int,
+  depth int,
+  want string,
+  layout formatLayout,
+  edits *[]TextEdit,
+) bool {
+  if pos < 0 || pos > len(src) {
+    return false
+  }
+  if header.Parent != nil && header.Parent.Kind == shimast.KindTypeLiteral {
+    return false
+  }
+  if !frameLineIsWhereDepthSays(src, header.Parent, depth-1, layout) {
+    return false
+  }
+  lineStart := lineStartOffset(src, pos)
+  gap := pos
+  for gap > lineStart && (src[gap-1] == ' ' || src[gap-1] == '\t') {
+    gap--
+  }
+  if gap == lineStart {
+    return false
+  }
+  *edits = append(*edits, TextEdit{Pos: gap, End: pos, Text: layout.eol + want})
+  return true
+}
+
 // memberDeclarationStart returns the byte offset where a decorated member's
 // actual declaration begins (just past its last leading decorator), or -1
 // when the member has no decorators. The declaration start is the first

package/linthost/rules_format_print_width.go

@@ -157,15 +157,13 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   // 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) &&
+  // Some layouts break regardless of width: function composition, same-kind
+  // nested arrays/objects, and any non-empty expression-position block. Such a
+  // shape can sit below a fitting call, array, conditional, object member, or
+  // parenthesized expression, so fastPathForcesBreak walks the whole subtree the
+  // structured printer can reach. Skip the fast path when it finds one; every
+  // other fitting flat node is byte-identical after reflow.
+  if !fastPathForcesBreak(node, src) &&
     !sliceContainsNewline(src, start, end) &&
     printOpts.StartingColumn+displayWidth(src[start:end])+trailingWidth <= printOpts.PrintWidth {
     return
@@ -315,15 +313,7 @@ func trailingLineWidth(src string, end int, tabWidth int) int {
     tabWidth = 2
   }
   lineEnd := trailingSuffixEnd(src, end)
-  col := 0
-  for _, r := range src[end:lineEnd] {
-    if r == '\t' {
-      col += tabWidth - (col % tabWidth)
-    } else {
-      col += runeWidth(r)
-    }
-  }
-  return col
+  return displayWidthFromColumn(src[end:lineEnd], tabWidth, 0)
 }
 
 // trailingSuffixEnd returns the byte offset where the node's un-movable
@@ -376,14 +366,9 @@ func maxLineWidth(text string, startingColumn, trailingWidth, tabWidth int) int
   lines := strings.Split(text, "\n")
   widest := 0
   for i, line := range lines {
-    width := 0
-    for _, r := range line {
-      if r == '\t' {
-        width += tabWidth - (width % tabWidth)
-      } else if r != '\r' {
-        width += runeWidth(r)
-      }
-    }
+    // A `\r` left by a CRLF split charges nothing: displayWidth reads it as the
+    // control character it is, exactly as Prettier's own loop does.
+    width := displayWidthFromColumn(line, tabWidth, 0)
     if i == 0 {
       width += startingColumn
     }
@@ -409,15 +394,7 @@ func leadingColumn(src string, pos int, tabWidth int) int {
     tabWidth = 2
   }
   lineStart := lineStartOffset(src, pos)
-  col := 0
-  for _, r := range src[lineStart:pos] {
-    if r == '\t' {
-      col += tabWidth - (col % tabWidth)
-    } else {
-      col += runeWidth(r)
-    }
-  }
-  return col
+  return displayWidthFromColumn(src[lineStart:pos], tabWidth, 0)
 }
 
 // lineLeadingIndent returns the visual column of the first non-blank

package/linthost/rules_format_quote_props.go

@@ -1,25 +1,29 @@
 package linthost
 
 import (
+  "strconv"
+
   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`:
+// formatQuoteProps normalizes quoting of object keys and method/type-member
+// names, mirroring Prettier's `quoteProps` except for the documented semantic
+// preservation of `__proto__` and non-ASCII identifier keys:
 //
 //   - "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.
+//   - "consistent": if ANY object key needs quotes, quote its removable
+//     identifier siblings; 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.
+// mode, so the rule can never produce an invalid key. Class fields remain
+// outside the surface because Prettier preserves their quoted spelling.
 type formatQuoteProps struct{ optionsRule }
 
 type formatQuotePropsOptions struct {
@@ -30,15 +34,21 @@ func (formatQuoteProps) Name() string   { return "format/quote-props" }
 func (formatQuoteProps) IsFormat() bool { return true }
 
 func (formatQuoteProps) Visits() []shimast.Kind {
-  return []shimast.Kind{shimast.KindObjectLiteralExpression}
+  return []shimast.Kind{
+    shimast.KindObjectLiteralExpression,
+    shimast.KindClassDeclaration,
+    shimast.KindClassExpression,
+    shimast.KindInterfaceDeclaration,
+    shimast.KindTypeLiteral,
+  }
 }
 
 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 {
+  members, isObject := quotePropsMembers(node)
+  if len(members) == 0 {
     return
   }
   var opts formatQuotePropsOptions
@@ -56,27 +66,39 @@ func (formatQuoteProps) Check(ctx *Context, node *shimast.Node) {
   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").
+  // with its bare identifier. bare collects identifier keys that need quotes
+  // when a mixed object is normalized under `consistent`.
   type removableKey struct {
     start, end int
     ident      string
   }
+  type bareKey struct {
+    start, end int
+    text       string
+  }
   var removable []removableKey
+  var bare []bareKey
   anyMustStayQuoted := false
 
-  for _, prop := range obj.Properties.Nodes {
+  for _, prop := range members {
     if prop == nil {
       continue
     }
     name := propertyKeyName(prop)
-    if name == nil || name.Kind != shimast.KindStringLiteral {
+    if name == nil {
       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
+      return // give up on the whole holder rather than risk a partial edit
+    }
+    if name.Kind == shimast.KindIdentifier {
+      bare = append(bare, bareKey{start: ks, end: ke, text: src[ks:ke]})
+      continue
+    }
+    if name.Kind != shimast.KindStringLiteral {
+      continue
     }
     ident := unquotableIdentifier(src[ks:ke])
     if ident == "" {
@@ -86,19 +108,22 @@ func (formatQuoteProps) Check(ctx *Context, node *shimast.Node) {
     removable = append(removable, removableKey{start: ks, end: ke, ident: ident})
   }
 
-  if len(removable) == 0 {
-    return
+  var edits []TextEdit
+  // Prettier's consistency rule applies to object literals only. Class and
+  // type members still follow the as-needed direction because they do not
+  // form an object-key group in Prettier's printer.
+  if mode == "consistent" && isObject && anyMustStayQuoted {
+    for _, key := range bare {
+      edits = append(edits, TextEdit{Pos: key.start, End: key.end, Text: strconv.Quote(key.text)})
+    }
+  } else {
+    for _, key := range removable {
+      edits = append(edits, TextEdit{Pos: key.start, End: key.end, Text: key.ident})
+    }
   }
-  // In "consistent" mode, if any key must stay quoted, the whole object is
-  // kept quoted, so unquote nothing.
-  if mode == "consistent" && anyMustStayQuoted {
+  if len(edits) == 0 {
     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,
@@ -107,8 +132,41 @@ func (formatQuoteProps) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
-// propertyKeyName returns the static name node of an object-literal property
-// (assignment, method, or accessor), or nil when it has no static name.
+// quotePropsMembers returns the members whose static names are governed by
+// Prettier's quoteProps option. Class fields are intentionally excluded:
+// Prettier preserves their quoted spelling, while class methods, interface
+// members, and type-literal members follow the normal as-needed rule.
+func quotePropsMembers(node *shimast.Node) ([]*shimast.Node, bool) {
+  if node == nil {
+    return nil, false
+  }
+  switch node.Kind {
+  case shimast.KindObjectLiteralExpression:
+    if obj := node.AsObjectLiteralExpression(); obj != nil && obj.Properties != nil {
+      return obj.Properties.Nodes, true
+    }
+  case shimast.KindClassDeclaration:
+    if decl := node.AsClassDeclaration(); decl != nil && decl.Members != nil {
+      return decl.Members.Nodes, false
+    }
+  case shimast.KindClassExpression:
+    if expr := node.AsClassExpression(); expr != nil && expr.Members != nil {
+      return expr.Members.Nodes, false
+    }
+  case shimast.KindInterfaceDeclaration:
+    if decl := node.AsInterfaceDeclaration(); decl != nil && decl.Members != nil {
+      return decl.Members.Nodes, false
+    }
+  case shimast.KindTypeLiteral:
+    if literal := node.AsTypeLiteralNode(); literal != nil && literal.Members != nil {
+      return literal.Members.Nodes, false
+    }
+  }
+  return nil, false
+}
+
+// propertyKeyName returns the static name node of a member governed by
+// quoteProps, or nil when the member has no static name or is a class field.
 func propertyKeyName(prop *shimast.Node) *shimast.Node {
   switch prop.Kind {
   case shimast.KindPropertyAssignment:
@@ -117,7 +175,9 @@ func propertyKeyName(prop *shimast.Node) *shimast.Node {
     }
   case shimast.KindMethodDeclaration,
     shimast.KindGetAccessor,
-    shimast.KindSetAccessor:
+    shimast.KindSetAccessor,
+    shimast.KindMethodSignature,
+    shimast.KindPropertySignature:
     return prop.Name()
   }
   return nil
@@ -146,7 +206,8 @@ func unquotableIdentifier(raw string) string {
     // 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).
+    // semantics, so ttsc deliberately keeps it quoted even though Prettier
+    // does not.
     return ""
   }
   for i := 0; i < len(inner); i++ {

package/linthost/rules_format_statement_split.go

@@ -61,12 +61,30 @@ func (formatStatementSplit) Check(ctx *Context, node *shimast.Node) {
   layout := loadFormatLayout(ctx)
   src := ctx.File.Text()
   var edits []TextEdit
+  scannedCommentLists := map[*shimast.Node]bool{}
+  commentLists := map[*shimast.Node]bool{}
   forEachStatementInList(ctx.File, func(stmt *shimast.Node, depth int) {
     // Empty statements (`;`) carry no content. Splitting each one onto
     // its own line only multiplies blank-ish noise, so abstain.
     if stmt.Kind == shimast.KindEmptyStatement {
       return
     }
+    // Preflight the whole immediate statement list before splitting any one
+    // entry. Otherwise an early statement can move before a later boundary
+    // comment makes that later statement abstain, leaving a half-formatted
+    // list (`case 1:\n  f(); /* keep */ break;`). The structured printer also
+    // abstains on this boundary, so statement-split must preserve the same
+    // all-or-nothing safety floor.
+    if indentCededToReflow(stmt) {
+      parent := stmt.Parent
+      if parent != nil && !scannedCommentLists[parent] {
+        scannedCommentLists[parent] = true
+        commentLists[parent] = statementListHasInterStatementComment(src, parent)
+      }
+      if parent != nil && commentLists[parent] {
+        return
+      }
+    }
     start := shimscanner.SkipTrivia(src, stmt.Pos())
     if start <= 0 || start > len(src) {
       return
@@ -104,6 +122,17 @@ func (formatStatementSplit) Check(ctx *Context, node *shimast.Node) {
     if stmt.Kind == shimast.KindBlock && firstStatementAfterCaseLabel(stmt) {
       return
     }
+    // A statement sharing its line with the `{` that opened its own block,
+    // where that block sits in expression position, has no brace owner:
+    // format/indent cedes such a block's `}` to format/print-width, so
+    // breaking the body out here would strand the brace on the last statement
+    // and make that hybrid the cascade's fixed point — the one shape neither
+    // rule can undo. Leave the block whole and let the printer decide whether
+    // it reflows. The two rules read the same predicate, so they cede the same
+    // blocks.
+    if indentCededToReflow(stmt) && sharesLineWithBlockOpenBrace(src, stmt, start) {
+      return
+    }
     // The gap between the previous statement and this one must be pure
     // whitespace. A `//` or `/*` anywhere from the previous statement's
     // end to this one would be eaten by the replacement, so abstain. The
@@ -130,6 +159,58 @@ func (formatStatementSplit) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
+// statementListHasInterStatementComment reports whether a block, module,
+// source file, or switch clause has a comment between two consecutive
+// statements. Prefix comments remain owned by the existing per-statement gap
+// guard; suffix comments do not affect a split. Scanning every interior gap up
+// front prevents an edit before one boundary from partially formatting a list
+// whose later boundary is intentionally immutable.
+func statementListHasInterStatementComment(src string, parent *shimast.Node) bool {
+  if parent == nil {
+    return false
+  }
+  var statements []*shimast.Node
+  switch parent.Kind {
+  case shimast.KindSourceFile, shimast.KindBlock, shimast.KindModuleBlock:
+    statements = parent.Statements()
+  case shimast.KindCaseClause, shimast.KindDefaultClause:
+    clause := parent.AsCaseOrDefaultClause()
+    if clause != nil && clause.Statements != nil {
+      statements = clause.Statements.Nodes
+    }
+  default:
+    return false
+  }
+  for i := 1; i < len(statements); i++ {
+    previous, next := statements[i-1], statements[i]
+    if previous == nil || next == nil {
+      continue
+    }
+    nextStart := shimscanner.SkipTrivia(src, next.Pos())
+    if gapHasComment(src, previous.End(), nextStart) {
+      return true
+    }
+  }
+  return false
+}
+
+// sharesLineWithBlockOpenBrace reports whether `start`, the first byte of a
+// statement, sits on the same physical line as the `{` of the Block that
+// directly contains it. It is the test for "this block is still written on one
+// line", which is the state in which splitting the body out would strand the
+// closing brace.
+func sharesLineWithBlockOpenBrace(src string, stmt *shimast.Node, start int) bool {
+  block := stmt.Parent
+  if block == nil || block.Kind != shimast.KindBlock {
+    return false
+  }
+  open := shimscanner.SkipTrivia(src, block.Pos())
+  if open < 0 || open >= len(src) || src[open] != '{' {
+    return false
+  }
+  return lineStartOffset(src, open) == lineStartOffset(src, start)
+}
+
 // gapHasComment reports whether the byte range [start, end) contains the
 // opening bytes of a `//` or `/*` comment. The split rule abstains when
 // the inter-statement gap carries a comment so its line-break insertion