Fix missing newline for opening quote for multilines strings

Author: kimdv

Sources/SwiftBasicFormat/BasicFormat.swift

@@ -180,20 +180,41 @@ open class BasicFormat: SyntaxRewriter {
     }
   }
 
-  /// Whether a trailing newline on `token` should be added.
-  open func requiresTrailingNewline(_ token: TokenSyntax) -> Bool {
-    // We don't want to add newlines inside string interpolation
-    if isInsideStringInterpolation(token) && token.tokenKind != .multilineStringQuote {
-      return false
-    }
-
-    let syntaxToken: Syntax = Syntax(token)
-    switch syntaxToken.keyPathInParent {
-    case \StringLiteralExprSyntax.openQuote:
-      return token.tokenKind == .multilineStringQuote
-    default:
-      return false
-    }
+  open func requiresNewline(between first: TokenSyntax?, and second: TokenSyntax?) -> Bool {
+      switch (first?.tokenKind, second?.tokenKind) {
+      case (.atSign, _),
+          (.colon, _),
+          (.comma, _),
+          (.eof, _),
+          (.equal, _),
+          (.identifier, .comma),
+          (.identifier, .leftBrace),
+          (.identifier, .leftParen),
+          (.identifier, .period),
+          (.identifier, .rightParen),
+          (.keyword, .arrow),
+          (.keyword(.await), .identifier),
+          (.keyword(.async), _),
+          (.keyword(.false), _),
+          (.keyword(.func), _),
+          (.keyword(.let), .identifier),
+          (.keyword(.let), .wildcard),
+          (.keyword(.throws), .rightBrace),
+          (.keyword(.true), _),
+          (.keyword(.var), .identifier),
+          (.keyword(.var), .wildcard),
+          (.leftParen, _),
+          (.period, .identifier),
+          (.rightParen, .identifier),
+          (.rightParen, .keyword(.async)),
+          (.rightSquareBracket, _),
+          (_, .colon),
+          (_, .eof),
+          (_, .equal):
+          return false
+      default:
+          return true
+      }
   }
 
   open func requiresWhitespace(between first: TokenSyntax?, and second: TokenSyntax?) -> Bool {
@@ -281,15 +302,6 @@ open class BasicFormat: SyntaxRewriter {
     return true
   }
 
-  open func requiresNewline(between first: TokenSyntax?, and second: TokenSyntax?) -> Bool {
-    switch (first?.tokenKind, second?.tokenKind) {
-    case (.multilineStringQuote, .stringSegment):
-      return true
-    default:
-      return false
-    }
-  }
-
   /// Whether the formatter should consider this token as being mutable.
   /// This allows the diagnostic generator to only assume that missing nodes
   /// will be mutated. Thus, if two tokens need to be separated by a space, it
@@ -368,7 +380,7 @@ open class BasicFormat: SyntaxRewriter {
     var leadingTrivia = token.leadingTrivia
     var trailingTrivia = token.trailingTrivia
 
-    if requiresLeadingNewline(token) {
+    if requiresNewline(between: previousToken, and: token) {
       // Add a leading newline if the token requires it unless
       //  - it already starts with a newline or
       //  - the previous token ends with a newline
@@ -393,6 +405,12 @@ open class BasicFormat: SyntaxRewriter {
       anchorPoints[token] = currentIndentationLevel
     }
 
+    if requiresNewline(between: token, and: nextToken) {
+      if !trailingTrivia.endsWithNewline && !nextTokenWillStartWithNewline {
+        trailingTrivia += .newline
+      }
+    }
+
     // Add a trailing space to the token unless
     //  - it already ends with a whitespace or
     //  - the next token will start starts with a newline after the rewrite

Sources/SwiftParserDiagnostics/MissingNodesError.swift

@@ -22,7 +22,7 @@ fileprivate func findCommonAncestor(_ nodes: [Syntax]) -> Syntax? {
 }
 
 class NoNewlinesFormat: BasicFormat {
-  override func requiresLeadingNewline(_ token: TokenSyntax) -> Bool {
+  override func requiresNewline(between first: TokenSyntax?, and second: TokenSyntax?) -> Bool {
     return false
   }
 }

Tests/SwiftSyntaxBuilderTest/StringLiteralExprSyntaxTests.swift

@@ -334,4 +334,44 @@ final class StringLiteralExprSyntaxTests: XCTestCase {
       """#
     )
   }
+
+  func testMultiStringOpeningQuote() {
+    assertBuildResult(
+      StringLiteralExprSyntax(openQuote: .multilineStringQuoteToken(), content: "a", closeQuote: .multilineStringQuoteToken()),
+      #"""
+      """
+      a
+      """
+      """#
+    )
+
+    assertBuildResult(
+      StringLiteralExprSyntax(
+        openQuote: .multilineStringQuoteToken(),
+        segments: StringLiteralSegmentsSyntax {
+          .expressionSegment(
+            ExpressionSegmentSyntax(
+              expressions: TupleExprElementListSyntax {
+                TupleExprElementSyntax(
+                  expression: StringLiteralExprSyntax(
+                    openQuote: .multilineStringQuoteToken(),
+                    content: "a",
+                    closeQuote: .multilineStringQuoteToken()
+                  )
+                )
+              }
+            )
+          )
+        },
+        closeQuote: .multilineStringQuoteToken()
+      ),
+      #"""
+      """
+      \("""
+      a
+      """)
+      """
+      """#
+    )
+  }
 }