Fix multiline string indentation

Author: kimdv

CodeGeneration/Sources/generate-swiftsyntax/templates/basicformat/BasicFormatFile.swift

@@ -92,11 +92,14 @@ let basicFormatFile = SourceFileSyntax(leadingTrivia: generateCopyrightHeader(fo
         if requiresTrailingSpace(node) && trailingTrivia.isEmpty {
           trailingTrivia += .space
         }
-        if let keyPath = getKeyPath(Syntax(node)), requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false) {
+        if let keyPath = getKeyPath(Syntax(node)), requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false), !shouldOmitNewline(node) {
           leadingTrivia = .newline + leadingTrivia
         }
-        leadingTrivia = leadingTrivia.indented(indentation: indentation)
-        trailingTrivia = trailingTrivia.indented(indentation: indentation)
+        var isOnNewline: Bool = (lastRewrittenToken?.trailingTrivia.pieces.last?.isNewline == true)
+        if case .stringSegment(let text) = lastRewrittenToken?.tokenKind {
+          isOnNewline = isOnNewline || (text.last?.isNewline == true)
+        }
+        leadingTrivia = leadingTrivia.indented(indentation: indentation, isOnNewline: isOnNewline)
         let rewritten = TokenSyntax(
           node.tokenKind,
           leadingTrivia: leadingTrivia,
@@ -110,6 +113,25 @@ let basicFormatFile = SourceFileSyntax(leadingTrivia: generateCopyrightHeader(fo
       """
     )
 
+    DeclSyntax(
+      """
+      /// If this returns `true`, ``BasicFormat`` will not wrap `node` to a new line. This can be used to e.g. keep string interpolation segments on a single line.
+      /// - Parameter node: the node that is being visited
+      /// - Returns: returns true if newline should be omitted
+      open func shouldOmitNewline(_ node: TokenSyntax) -> Bool {
+        var ancestor: Syntax = Syntax(node)
+        while let parent = ancestor.parent {
+          ancestor = parent
+          if ancestor.is(ExpressionSegmentSyntax.self) {
+            return true
+          }
+        }
+
+        return false
+      }
+      """
+    )
+
     try FunctionDeclSyntax("open func shouldIndent(_ keyPath: AnyKeyPath) -> Bool") {
       try SwitchExprSyntax("switch keyPath") {
         for node in SYNTAX_NODES where !node.isBase {

Sources/SwiftBasicFormat/Trivia+Indented.swift

@@ -13,25 +13,35 @@
 import SwiftSyntax
 
 extension Trivia {
-  func indented(indentation: TriviaPiece) -> Trivia {
+  /// Makes sure each newline of this trivia is followed by `indentation`. If this is not the case, the existing indentation is extended to `indentation`.
+  /// `isOnNewline` determines whether the trivia starts on a new line. If this is the case, the function makes sure that the returned trivia starts with `indentation`.
+  func indented(indentation: TriviaPiece, isOnNewline: Bool = false) -> Trivia {
     var indentedPieces: [TriviaPiece] = []
     for (index, piece) in self.enumerated() {
-      let nextPiece = index < pieces.count - 1 ? pieces[index + 1] : nil
-      indentedPieces.append(piece)
-      if piece.isNewline {
-        switch (nextPiece, indentation) {
-        case (.spaces(let nextPieceSpaces)?, .spaces(let indentationSpaces)):
+      let previousPieceIsNewline: Bool
+      if index == 0 {
+        previousPieceIsNewline = isOnNewline
+      } else {
+        previousPieceIsNewline = pieces[index - 1].isNewline
+      }
+      if previousPieceIsNewline {
+        switch (piece, indentation) {
+        case (.spaces(let nextPieceSpaces), .spaces(let indentationSpaces)):
           if nextPieceSpaces < indentationSpaces {
             indentedPieces.append(.spaces(indentationSpaces - nextPieceSpaces))
           }
-        case (.tabs(let nextPieceTabs)?, .tabs(let indentationTabs)):
+        case (.tabs(let nextPieceTabs), .tabs(let indentationTabs)):
           if nextPieceTabs < indentationTabs {
             indentedPieces.append(.tabs(indentationTabs - nextPieceTabs))
           }
         default:
           indentedPieces.append(indentation)
         }
       }
+      indentedPieces.append(piece)
+    }
+    if self.pieces.last?.isNewline == true {
+      indentedPieces.append(indentation)
     }
     return Trivia(pieces: indentedPieces)
   }

Sources/SwiftBasicFormat/generated/BasicFormat.swift

@@ -54,11 +54,14 @@ open class BasicFormat: SyntaxRewriter {
     if requiresTrailingSpace(node) && trailingTrivia.isEmpty {
       trailingTrivia += .space
     }
-    if let keyPath = getKeyPath(Syntax(node)), requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false) {
+    if let keyPath = getKeyPath(Syntax(node)), requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false), !shouldOmitNewline(node) {
       leadingTrivia = .newline + leadingTrivia
     }
-    leadingTrivia = leadingTrivia.indented(indentation: indentation)
-    trailingTrivia = trailingTrivia.indented(indentation: indentation)
+    var isOnNewline: Bool = (lastRewrittenToken?.trailingTrivia.pieces.last?.isNewline == true)
+    if case .stringSegment(let text) = lastRewrittenToken?.tokenKind {
+      isOnNewline = isOnNewline || (text.last?.isNewline == true)
+    }
+    leadingTrivia = leadingTrivia.indented(indentation: indentation, isOnNewline: isOnNewline)
     let rewritten = TokenSyntax(
         node.tokenKind, 
         leadingTrivia: leadingTrivia, 
@@ -71,6 +74,21 @@ open class BasicFormat: SyntaxRewriter {
     return rewritten
   }
 
+  /// If this returns `true`, ``BasicFormat`` will not wrap `node` to a new line. This can be used to e.g. keep string interpolation segments on a single line.
+  /// - Parameter node: the node that is being visited
+  /// - Returns: returns true if newline should be omitted
+  open func shouldOmitNewline(_ node: TokenSyntax) -> Bool {
+    var ancestor: Syntax = Syntax(node)
+    while let parent = ancestor.parent {
+      ancestor = parent
+      if ancestor.is(ExpressionSegmentSyntax.self) {
+        return true
+      }
+    }
+
+    return false
+  }
+  
   open func shouldIndent(_ keyPath: AnyKeyPath) -> Bool {
     switch keyPath {
     case \AccessorBlockSyntax.accessors:

Tests/SwiftSyntaxBuilderTest/StringLiteralTests.swift

@@ -259,11 +259,11 @@ final class StringLiteralTests: XCTestCase {
       buildable,
       #"""
       assertionFailure("""
-            Error validating child at index \(index) of \(nodeKind):
-            Node did not satisfy any node choice requirement.
-            Validation failures:
-            \(nonNilErrors.map({ "- \($0.description)" }).joined(separator: "\n"))
-            """, file: file, line: line)
+          Error validating child at index \(index) of \(nodeKind):
+          Node did not satisfy any node choice requirement.
+          Validation failures:
+          \(nonNilErrors.map({ "- \($0.description)" }).joined(separator: "\n"))
+          """, file: file, line: line)
       """#
     )
   }
@@ -286,10 +286,10 @@ final class StringLiteralTests: XCTestCase {
       #"""
       if true {
           assertionFailure("""
-                  Error validating child at index
-                  Node did not satisfy any node choice requirement.
-                  Validation failures:
-                  """)
+              Error validating child at index
+              Node did not satisfy any node choice requirement.
+              Validation failures:
+              """)
       }
       """#
     )
@@ -316,10 +316,10 @@ final class StringLiteralTests: XCTestCase {
       if true {
           assertionFailure(
               """
-                  Error validating child at index
-                  Node did not satisfy any node choice requirement.
-                  Validation failures:
-                  """
+              Error validating child at index
+              Node did not satisfy any node choice requirement.
+              Validation failures:
+              """
           )
       }
       """#