@ttsc/lint 0.19.3 → 0.20.0

package/linthost/print_nodes_array.go

@@ -1,7 +1,10 @@
 package linthost
 
 import (
+  "strings"
+
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // printArrayLiteral renders an ArrayLiteralExpression with width-aware
@@ -127,19 +130,18 @@ func arrayForcesBreak(node *shimast.Node) bool {
   return arrayShouldForceBreak(arr.Elements.Nodes)
 }
 
-// fastPathForcesBreak reports whether `node`, OR a force-breaking node nested
-// within the subtree a reflow of `node` would print (its call/new arguments and
-// array elements, recursively), must explode even though it fits flat. Prettier
-// breaks such a descendant — an array `shouldBreak` or a function-composition
-// call/new — when the enclosing node reflows; ttsc's print-width fast path
-// returns first while the descendant abstains via hasReflowAncestor, leaving
-// both flat (`new Map([["a", 1], ["b", 2]])`, `foo([[1, 2], [3, 4]])`). So the
-// fast path must consult this, not only the visited node itself.
-func fastPathForcesBreak(node *shimast.Node) bool {
+// fastPathForcesBreak reports whether `node`, or a force-breaking node nested
+// within the subtree its structured printer reaches, must explode even though
+// the outer source fits flat. It follows call/new arguments, array elements,
+// function bodies, conditional parts, parenthesized expressions, and printable
+// object-member bodies. The forced descendant can be a same-kind composite
+// array, a function-composition call, or a non-empty block. Without the walk,
+// the outer node's fast path would return before the descendant could deny it.
+func fastPathForcesBreak(node *shimast.Node, src string) bool {
   if node == nil {
     return false
   }
-  if callForcesFunctionBreak(node) || arrayForcesBreak(node) {
+  if callForcesFunctionBreak(node) || arrayForcesBreak(node) || blockForcesBreak(node, src) {
     return true
   }
   var children []*shimast.Node
@@ -156,6 +158,16 @@ func fastPathForcesBreak(node *shimast.Node) bool {
     if a := node.AsArrayLiteralExpression(); a != nil && a.Elements != nil {
       children = a.Elements.Nodes
     }
+  case shimast.KindArrowFunction, shimast.KindFunctionExpression:
+    children = append(children, functionLikeBody(node))
+  case shimast.KindConditionalExpression:
+    if conditional := node.AsConditionalExpression(); conditional != nil {
+      children = append(children, conditional.Condition, conditional.WhenTrue, conditional.WhenFalse)
+    }
+  case shimast.KindParenthesizedExpression:
+    if parenthesized := node.AsParenthesizedExpression(); parenthesized != nil {
+      children = append(children, parenthesized.Expression)
+    }
   case shimast.KindObjectLiteralExpression:
     // A force-breaking array/object nested in an object PROPERTY value
     // (`{ m: [[1, 2], [3, 4]] }`) must also deny the fast path: the value
@@ -164,22 +176,83 @@ func fastPathForcesBreak(node *shimast.Node) bool {
     // would stay flat where Prettier breaks them.
     if o := node.AsObjectLiteralExpression(); o != nil && o.Properties != nil {
       for _, p := range o.Properties.Nodes {
-        if p != nil && p.Kind == shimast.KindPropertyAssignment {
-          if pa := p.AsPropertyAssignment(); pa != nil && pa.Initializer != nil {
-            children = append(children, pa.Initializer)
-          }
+        if p == nil {
+          continue
+        }
+        switch p.Kind {
+        case shimast.KindPropertyAssignment,
+          shimast.KindMethodDeclaration,
+          shimast.KindGetAccessor,
+          shimast.KindSetAccessor:
+          children = append(children, functionLikeBody(p))
         }
       }
     }
   }
   for _, ch := range children {
-    if fastPathForcesBreak(ch) {
+    if fastPathForcesBreak(ch, src) {
       return true
     }
   }
   return false
 }
 
+// blockForcesBreak reports whether `node` is a block Prettier expands even
+// when it fits: one carrying a statement or a comment. Whitespace-only `{}` is
+// the empty negative twin and remains flat.
+func blockForcesBreak(node *shimast.Node, src string) bool {
+  if node == nil || node.Kind != shimast.KindBlock {
+    return false
+  }
+  block := node.AsBlock()
+  if block == nil || block.Statements == nil {
+    return false
+  }
+  if len(block.Statements.Nodes) > 0 {
+    return true
+  }
+  start := shimscanner.SkipTrivia(src, node.Pos())
+  end := node.End()
+  return start >= 0 && end > start+1 && end <= len(src) &&
+    src[start] == '{' && src[end-1] == '}' &&
+    strings.TrimSpace(src[start+1:end-1]) != ""
+}
+
+// functionLikeBody returns the part of an arrow, function expression, or
+// object member that an enclosing reflow prints structurally.
+func functionLikeBody(node *shimast.Node) *shimast.Node {
+  if node == nil {
+    return nil
+  }
+  switch node.Kind {
+  case shimast.KindArrowFunction:
+    if arrow := node.AsArrowFunction(); arrow != nil {
+      return arrow.Body
+    }
+  case shimast.KindFunctionExpression:
+    if function := node.AsFunctionExpression(); function != nil {
+      return function.Body
+    }
+  case shimast.KindPropertyAssignment:
+    if property := node.AsPropertyAssignment(); property != nil {
+      return property.Initializer
+    }
+  case shimast.KindMethodDeclaration:
+    if method := node.AsMethodDeclaration(); method != nil {
+      return method.Body
+    }
+  case shimast.KindGetAccessor:
+    if accessor := node.AsGetAccessorDeclaration(); accessor != nil {
+      return accessor.Body
+    }
+  case shimast.KindSetAccessor:
+    if accessor := node.AsSetAccessorDeclaration(); accessor != nil {
+      return accessor.Body
+    }
+  }
+  return nil
+}
+
 // isConciselyPrintedArray reports whether an array should use Prettier's
 // concise "fill" layout: at least one element and every element a numeric
 // literal (optionally a `+`/`-` signed numeric). Prettier packs such arrays

package/linthost/print_nodes_call.go

@@ -206,15 +206,17 @@ func printArgList(ctx *PrintContext, list *shimast.NodeList, addComma bool, deco
     forceFnBreak = false
   }
   hugFirst := !hugLast && !forceFnBreak && shouldHugFirstArgument(ctx, list.Nodes)
+  hugLastBreakClose := hugLast && lastArgumentBreaksAfterArrow(list.Nodes)
   shape := listShape{
-    OpenTok:      "(",
-    CloseTok:     ")",
-    Items:        items,
-    Space:        false,
-    AddComma:     addComma,
-    HugLast:      hugLast,
-    HugLastForce: forceHugLast,
-    HugFirst:     hugFirst,
+    OpenTok:           "(",
+    CloseTok:          ")",
+    Items:             items,
+    Space:             false,
+    AddComma:          addComma,
+    HugLast:           hugLast,
+    HugLastBreakClose: hugLastBreakClose,
+    HugLastForce:      forceHugLast,
+    HugFirst:          hugFirst,
     // A non-empty array second argument reaches HugFirst only via the
     // React-hook deps branch of shouldHugFirstArgument; let that deps array
     // break one-per-line instead of being pinned flat on the close line.
@@ -228,6 +230,18 @@ func printArgList(ctx *PrintContext, list *shimast.NodeList, addComma bool, deco
   return printList(ctx, shape), covered
 }
 
+// lastArgumentBreaksAfterArrow reports the trailing arrow shape whose hugged
+// layout keeps the opening line through `=>` but leaves the call's closing
+// parenthesis on its own line after the expression body.
+func lastArgumentBreaksAfterArrow(args []*shimast.Node) bool {
+  if len(args) == 0 || args[len(args)-1] == nil ||
+    args[len(args)-1].Kind != shimast.KindArrowFunction {
+    return false
+  }
+  arrow := args[len(args)-1].AsArrowFunction()
+  return arrow != nil && arrowBodyBreaksAfterArrow(arrow.Body)
+}
+
 // testCalleePatterns is Prettier's exact testCallCalleePatterns set (the dotted
 // callee chains its isTestCallCallee matches). Matching the precise set, rather
 // than "any base with a {only,skip,…} tail", avoids both over-matching
@@ -500,20 +514,17 @@ func anyLeadingItemBreaks(items []Doc) bool {
   return false
 }
 
-// shouldHugLastArgument reports whether the final entry of `args` is a
-// shape Prettier keeps hugging the closing paren: an object or array
-// literal, a function expression, or an arrow function whose body is a
-// block, an object literal, or an array literal. Hugging only applies
-// when that argument is genuinely the last one; a callback in the
-// middle of the list does not trigger the shape.
+// shouldHugLastArgument reports whether the final entry of `args` is a shape
+// Prettier keeps attached to the call's opening line: an object or array
+// literal, a function expression, or an arrow function whose body has an
+// expandable layout. A block/object/array body also hugs the closing paren; a
+// call/conditional/JSX body breaks after `=>` and closes the outer list on its
+// own line. Hugging only applies when the argument is genuinely last.
 //
-// An arrow with any other expression body (`(x) => x.id`) is
-// deliberately excluded. Such a body carries no internal break point,
-// so the hugging shape — a flat `Concat` with no Group — would pin the
-// whole call to one line even when that line overflows printWidth.
-// Routing it through the normal list shape instead lets the argument
-// list explode onto its own line when the call does not fit, which is
-// what Prettier does.
+// An arrow with any other expression body (`(x) => x.id`) is deliberately
+// excluded. It carries no internal break point, so the hugging shape would pin
+// the whole call to one line even when it overflows printWidth. The normal list
+// shape can instead explode that argument onto its own line.
 func shouldHugLastArgument(args []*shimast.Node) bool {
   if len(args) == 0 {
     return false
@@ -544,11 +555,11 @@ func shouldHugLastArgument(args []*shimast.Node) bool {
   return true
 }
 
-// lastArgHuggableShape reports whether `node` is the shape Prettier keeps
-// hugging the closing paren: an object/array literal, a function expression,
-// or an arrow whose body is a block, object, or array. An expression-bodied
-// arrow (`(x) => x.id`) is excluded: it has no internal break point, so the
-// flat hugging Concat would pin an overflowing call to one line.
+// lastArgHuggableShape reports whether `node` has a Prettier-style expandable
+// last-argument layout. Objects, arrays, and functions expand internally; an
+// arrow with a call/conditional/JSX body can break immediately after `=>`.
+// Other concise arrows (`(x) => x.id`) have no internal break point and are
+// excluded so an overflowing call can use the ordinary exploded list.
 func lastArgHuggableShape(last *shimast.Node) bool {
   switch last.Kind {
   case shimast.KindFunctionExpression:
@@ -595,14 +606,10 @@ func lastArgHuggableShape(last *shimast.Node) bool {
       // explodes the whole list. A block body hugs regardless (handled above).
       return arrow.Type == nil || arrow.Type.Kind != shimast.KindTypeReference
     }
+    return arrowBodyBreaksAfterArrow(body)
   }
   // DEFERRED (architectural, not a one-line predicate fix; do not re-add to the
   // switch above without the supporting layout work):
-  //   - A call/conditional/JSX-expression arrow body. Prettier's couldExpandArg
-  //     hugs it, but ttsc emits the arrow signature (`=> `) verbatim with no
-  //     break point after `=>`, so hugging here would force the FIRST group
-  //     inside the call instead of breaking after `=>` — a different shape, not
-  //     parity. Needs a break-after-`=>` arrow-body layout variant first.
   //   - A trailing `as`/`satisfies` cast wrapping a huggable last argument.
   //     Prettier's couldExpandArg recurses into the cast, but ttsc does not
   //     dispatch KindAsExpression (it prints verbatim), so forceBreakFirstGroup

package/linthost/print_nodes_control_flow.go

@@ -0,0 +1,319 @@
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// printControlFlowStatement renders a loop, `if`, `try`, or `switch` by
+// preserving its headers and clause keywords exactly as written while laying
+// out the blocks and statements they control.
+//
+// The preserved gaps keep `format/clause-join` as the owner of header spacing
+// and retain comments without minting new `else`, `catch`, or `finally`
+// tokens. A multi-line preserved gap taints coverage because its original
+// interior columns cannot be re-indented safely.
+//
+// A BRACELESS body is left alone entirely. Prettier indents it one level past
+// the header, which is layout the block-depth model has no frame for, and
+// `format/indent` cedes it for exactly that reason (`cededUnderBracelessBody`).
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printControlFlowStatement(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  switch node.Kind {
+  case shimast.KindForStatement,
+    shimast.KindForOfStatement,
+    shimast.KindForInStatement,
+    shimast.KindWhileStatement:
+    body := singleControlFlowBody(node)
+    if body == nil || body.Kind != shimast.KindBlock {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    return printNodeAroundChildren(ctx, node, []*shimast.Node{body})
+  case shimast.KindIfStatement:
+    children, ok := printableIfChildren(node)
+    if !ok {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    return printNodeAroundChildren(ctx, node, children)
+  case shimast.KindTryStatement:
+    children, ok := printableTryChildren(node)
+    if !ok {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    return printNodeAroundChildren(ctx, node, children)
+  case shimast.KindSwitchStatement:
+    stmt := node.AsSwitchStatement()
+    if stmt == nil || stmt.CaseBlock == nil {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    return printNodeAroundChildren(ctx, node, []*shimast.Node{stmt.CaseBlock})
+  }
+  return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+}
+
+// singleControlFlowBody returns the one statement a loop controls.
+func singleControlFlowBody(node *shimast.Node) *shimast.Node {
+  switch node.Kind {
+  case shimast.KindForStatement:
+    if stmt := node.AsForStatement(); stmt != nil {
+      return stmt.Statement
+    }
+  case shimast.KindForOfStatement, shimast.KindForInStatement:
+    if stmt := node.AsForInOrOfStatement(); stmt != nil {
+      return stmt.Statement
+    }
+  case shimast.KindWhileStatement:
+    if stmt := node.AsWhileStatement(); stmt != nil {
+      return stmt.Statement
+    }
+  }
+  return nil
+}
+
+// printableIfChildren returns the branches an if-printer may lay out. Every
+// concrete branch must be a block; an `else if` is accepted recursively because
+// its own printer applies the same invariant. A braceless branch makes the
+// whole statement fall back to verbatim rather than formatting only one half.
+func printableIfChildren(node *shimast.Node) ([]*shimast.Node, bool) {
+  if node == nil {
+    return nil, false
+  }
+  stmt := node.AsIfStatement()
+  if stmt == nil || stmt.ThenStatement == nil || stmt.ThenStatement.Kind != shimast.KindBlock {
+    return nil, false
+  }
+  children := []*shimast.Node{stmt.ThenStatement}
+  if stmt.ElseStatement == nil {
+    return children, true
+  }
+  if stmt.ElseStatement.Kind == shimast.KindBlock {
+    return append(children, stmt.ElseStatement), true
+  }
+  if stmt.ElseStatement.Kind == shimast.KindIfStatement {
+    if _, ok := printableIfChildren(stmt.ElseStatement); ok {
+      return append(children, stmt.ElseStatement), true
+    }
+  }
+  return nil, false
+}
+
+// printableTryChildren returns the try, catch, and finally blocks in source
+// order. The catch declaration stays in the preserved gap before its block.
+func printableTryChildren(node *shimast.Node) ([]*shimast.Node, bool) {
+  stmt := node.AsTryStatement()
+  if stmt == nil || stmt.TryBlock == nil {
+    return nil, false
+  }
+  children := []*shimast.Node{stmt.TryBlock}
+  if stmt.CatchClause != nil {
+    clause := stmt.CatchClause.AsCatchClause()
+    if clause == nil || clause.Block == nil {
+      return nil, false
+    }
+    children = append(children, clause.Block)
+  }
+  if stmt.FinallyBlock != nil {
+    children = append(children, stmt.FinallyBlock)
+  }
+  return children, true
+}
+
+// printNodeAroundChildren preserves the source gaps around selected children
+// and dispatches those children through the structured printer. The selected
+// ranges must be non-overlapping and in source order.
+func printNodeAroundChildren(ctx *PrintContext, node *shimast.Node, children []*shimast.Node) (Doc, bool) {
+  start := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  end := node.End()
+  if start < 0 || end < start || end > len(ctx.Source) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  cursor := start
+  covered := true
+  parts := make([]Doc, 0, len(children)*2+1)
+  for _, child := range children {
+    if child == nil {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    childStart := shimscanner.SkipTrivia(ctx.Source, child.Pos())
+    childEnd := child.End()
+    if childStart < cursor || childEnd < childStart || childEnd > end {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    gap := ctx.Source[cursor:childStart]
+    covered = covered && !strings.Contains(gap, "\n")
+    parts = append(parts, Text(gap))
+    childDoc, childCovered := PrintNode(ctx, child)
+    covered = covered && childCovered
+    parts = append(parts, childDoc)
+    cursor = childEnd
+  }
+  suffix := ctx.Source[cursor:end]
+  covered = covered && !strings.Contains(suffix, "\n")
+  parts = append(parts, Text(suffix))
+  return Concat(parts...), covered
+}
+
+// printSwitchCaseBlock renders the braces and clauses of a switch. Clauses are
+// indented once beneath the switch; their statements are indented once more.
+func printSwitchCaseBlock(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  block := node.AsCaseBlock()
+  start := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  end := node.End()
+  if block == nil || block.Clauses == nil || start < 0 || end <= start || end > len(ctx.Source) ||
+    ctx.Source[start] != '{' || ctx.Source[end-1] != '}' {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  if nodeHasNonItemComment(ctx, node, block.Clauses.Nodes) {
+    return verbatim(ctx, node), false
+  }
+  clauses := block.Clauses.Nodes
+  if len(clauses) == 0 {
+    return Text("{}"), true
+  }
+  docs := make([]Doc, 0, len(clauses))
+  covered := true
+  for _, clause := range clauses {
+    if clause == nil {
+      return verbatim(ctx, node), false
+    }
+    doc, childCovered := printSwitchClause(ctx, clause)
+    covered = covered && childCovered
+    docs = append(docs, doc)
+  }
+  body := joinPrintedNodes(ctx, clauses, docs)
+  return Concat(
+    Text("{"),
+    Indent(ctx.indentUnit(), Hardline(), body),
+    Hardline(),
+    Text("}"),
+  ), covered
+}
+
+// printSwitchClause renders `case` or `default` plus its statement list. A
+// block written on the clause header line stays there, matching Prettier's
+// `case X: {` layout; ordinary statements begin on the next indented line.
+func printSwitchClause(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  clause := node.AsCaseOrDefaultClause()
+  start := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  end := node.End()
+  if clause == nil || clause.Statements == nil || start < 0 || end < start || end > len(ctx.Source) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  if nodeHasNonItemComment(ctx, node, clause.Statements.Nodes) {
+    return verbatim(ctx, node), false
+  }
+  statements := clause.Statements.Nodes
+  if len(statements) == 0 {
+    source := strings.TrimRight(ctx.Source[start:end], " \t\r\n")
+    return Text(source), !strings.Contains(source, "\n")
+  }
+  if statements[0] == nil {
+    return verbatim(ctx, node), false
+  }
+  firstStart := shimscanner.SkipTrivia(ctx.Source, statements[0].Pos())
+  if firstStart < start || firstStart > end {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  header := strings.TrimRight(ctx.Source[start:firstStart], " \t\r\n")
+  covered := !strings.Contains(header, "\n")
+  docs := make([]Doc, 0, len(statements))
+  for _, statement := range statements {
+    if statement == nil {
+      return verbatim(ctx, node), false
+    }
+    doc, childCovered := PrintNode(ctx, statement)
+    covered = covered && childCovered
+    docs = append(docs, doc)
+  }
+  if statements[0] != nil && statements[0].Kind == shimast.KindBlock &&
+    lineStartOffset(ctx.Source, start) == lineStartOffset(ctx.Source, firstStart) {
+    parts := []Doc{Text(header), Text(" "), docs[0]}
+    if len(statements) > 1 {
+      rest := joinPrintedNodes(ctx, statements[1:], docs[1:])
+      parts = append(parts, Indent(ctx.indentUnit(), Hardline(), rest))
+    }
+    return Concat(parts...), covered
+  }
+  return Concat(
+    Text(header),
+    Indent(ctx.indentUnit(), Hardline(), joinPrintedNodes(ctx, statements, docs)),
+  ), covered
+}
+
+// printVariableStatement dispatches every initializer while preserving names,
+// type annotations, commas, modifiers, and the terminator verbatim.
+func printVariableStatement(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  stmt := node.AsVariableStatement()
+  if stmt == nil || stmt.DeclarationList == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  list := stmt.DeclarationList.AsVariableDeclarationList()
+  if list == nil || list.Declarations == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  children := make([]*shimast.Node, 0, len(list.Declarations.Nodes))
+  for _, declaration := range list.Declarations.Nodes {
+    if declaration == nil {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    value := declaration.AsVariableDeclaration()
+    if value != nil && value.Initializer != nil {
+      children = append(children, value.Initializer)
+    }
+  }
+  if len(children) == 0 {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  return printNodeAroundChildren(ctx, node, children)
+}
+
+// printThrowStatement preserves `throw` and its terminator while dispatching
+// the thrown expression so a nested callback or literal can reflow.
+func printThrowStatement(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  stmt := node.AsThrowStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  return printNodeAroundChildren(ctx, node, []*shimast.Node{stmt.Expression})
+}
+
+// joinPrintedNodes joins source-ordered nodes with hard lines while retaining
+// one author-written blank line. An empty-statement ASI guard remains glued to
+// the statement it protects, mirroring printBlock's established behavior.
+func joinPrintedNodes(ctx *PrintContext, nodes []*shimast.Node, docs []Doc) Doc {
+  parts := make([]Doc, 0, len(docs)*2)
+  for i, doc := range docs {
+    if i > 0 {
+      if nodes[i-1] != nil && nodes[i] != nil &&
+        nodes[i-1].Kind == shimast.KindEmptyStatement &&
+        !rangeHasNewline(ctx.Source, nodes[i-1].End(), shimscanner.SkipTrivia(ctx.Source, nodes[i].Pos())) {
+        parts = append(parts, doc)
+        continue
+      }
+      if nodes[i-1] != nil && nodes[i] != nil && blankLineBetweenStatements(ctx.Source, nodes[i-1].End(), nodes[i].Pos()) {
+        parts = append(parts, Literalline())
+      }
+      parts = append(parts, Hardline())
+    }
+    parts = append(parts, doc)
+  }
+  return Concat(parts...)
+}