Add option to configure multiline string reflow.

New option `.reflowMultilineStringLiterals` configures whether or not existing escaped newlines should be respected. When true, existing escaped newlines will not be respected and strings will reflow. When false, existing strings will not reflow. This means when false, once reflow happens it will not occur again unless the newlines are manually removed.

Author: thunderseethe

Sources/SwiftFormat/API/Configuration+Default.swift

@@ -40,5 +40,6 @@ extension Configuration {
     self.spacesAroundRangeFormationOperators = false
     self.noAssignmentInExpressions = NoAssignmentInExpressionsConfiguration()
     self.multiElementCollectionTrailingCommas = true
+    self.reflowMultilineStringLiterals = false
   }
 }

Sources/SwiftFormat/API/Configuration.swift

@@ -45,6 +45,7 @@ public struct Configuration: Codable, Equatable {
     case spacesAroundRangeFormationOperators
     case noAssignmentInExpressions
     case multiElementCollectionTrailingCommas
+    case reflowMultilineStringLiterals
   }
 
   /// A dictionary containing the default enabled/disabled states of rules, keyed by the rules'
@@ -194,6 +195,30 @@ public struct Configuration: Codable, Equatable {
   /// ```
   public var multiElementCollectionTrailingCommas: Bool
 
+  /// Determines if multiline strings literals should be reflowed, or if user inserted esacped newlines should be respected.
+  ///
+  /// Given the string literal:
+  /// ```swift
+  /// """
+  /// lines are \
+  /// kept short \
+  /// ```
+  ///
+  /// When `false` (default), the literal will not be reflowed:
+  /// ```swift
+  /// """
+  /// lines are \
+  /// kept short \
+  /// ```
+  ///
+  /// When `true`, the literal will reflow to fill up line length:
+  /// ```swift
+  /// """
+  /// lines are kept short
+  /// """
+  /// ```
+  public var reflowMultilineStringLiterals: Bool
+
   /// Creates a new `Configuration` by loading it from a configuration file.
   public init(contentsOf url: URL) throws {
     let data = try Data(contentsOf: url)
@@ -287,6 +312,10 @@ public struct Configuration: Codable, Equatable {
         Bool.self, forKey: .multiElementCollectionTrailingCommas)
     ?? defaults.multiElementCollectionTrailingCommas
 
+    self.reflowMultilineStringLiterals =
+      try container.decodeIfPresent(Bool.self, forKey: .reflowMultilineStringLiterals)
+      ?? defaults.reflowMultilineStringLiterals
+
     // If the `rules` key is not present at all, default it to the built-in set
     // so that the behavior is the same as if the configuration had been
     // default-initialized. To get an empty rules dictionary, one can explicitly
@@ -321,6 +350,7 @@ public struct Configuration: Codable, Equatable {
     try container.encode(indentSwitchCaseLabels, forKey: .indentSwitchCaseLabels)
     try container.encode(noAssignmentInExpressions, forKey: .noAssignmentInExpressions)
     try container.encode(multiElementCollectionTrailingCommas, forKey: .multiElementCollectionTrailingCommas)
+    try container.encode(reflowMultilineStringLiterals, forKey: .reflowMultilineStringLiterals)
     try container.encode(rules, forKey: .rules)
   }
 

Sources/SwiftFormat/PrettyPrint/TokenStreamCreator.swift

@@ -2523,9 +2523,9 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
 
     let emitSegmentTextTokens =
       isMultiLineString
-        ? { segment in  self.emitMultilineSegmentTextTokens(breakKind: breakKind, segment: segment) }
+        ? { (segment) in  self.emitMultilineSegmentTextTokens(breakKind: breakKind, segment: segment) }
         // For single line strings we don't allow line breaks, so emit the string as a single `.syntax` token
-        : { segment in self.appendToken(.syntax(String(segment))) }
+        : { (segment) in self.appendToken(.syntax(String(segment))) }
 
     let segmentText = node.content.text
     if segmentText.hasSuffix("\n") {
@@ -2543,6 +2543,13 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
       emitSegmentTextTokens(segmentText[...])
     }
 
+    if !config.reflowMultilineStringLiterals && node.trailingTrivia.containsBackslashes {
+      // Segments with trailing backslashes won't end with a literal newline; the backslash is
+      // considered trivia. To preserve the original text and wrapping, we need to manually render
+      // the backslash and a break into the token stream.
+      appendToken(.syntax("\\"))
+      appendToken(.break(breakKind, newlines: .hard(count: 1)))
+    }
     return .skipChildren
   }
 

Tests/SwiftFormatTests/PrettyPrint/StringTests.swift

@@ -1,3 +1,5 @@
+@_spi(Rules) @_spi(Testing) import SwiftFormat
+
 final class StringTests: PrettyPrintTestCase {
   func testStrings() {
     let input =
@@ -75,6 +77,31 @@ final class StringTests: PrettyPrintTestCase {
     assertPrettyPrintEqual(input: input, expected: expected, linelength: 30)
   }
 
+  func testMultilineStringIsNotReformattedWithReflowDisabled() {
+    let input =
+      #"""
+      let someString =
+        """
+        lines \
+        are \
+        short.
+        """
+      """#
+
+    let expected =
+      #"""
+      let someString =
+        """
+        lines \
+        are \
+        short.
+        """
+
+      """#
+
+    assertPrettyPrintEqual(input: input, expected: expected, linelength: 30)
+  }
+
   func testMultilineStringWithInterpolations() {
     let input =
         #"""
@@ -392,7 +419,9 @@ final class StringTests: PrettyPrintTestCase {
 
       """#
 
-    assertPrettyPrintEqual(input: input, expected: expected, linelength: 20)
+    var config = Configuration.forTesting
+    config.reflowMultilineStringLiterals = true
+    assertPrettyPrintEqual(input: input, expected: expected, linelength: 20, configuration: config)
   }
 
   func testMultilineStringInParenthesizedExpression() {