Fix type mismatch error in reflowMultilineStringLiterals (swiftlang#979)

Author: dongdong867

.github/workflows/pull_request.yml

@@ -20,3 +20,9 @@ jobs:
     with:
       license_header_check_project_name: "Swift.org"
       api_breakage_check_allowlist_path: "api-breakages.txt"
+  perf:
+    name: Test
+    uses: ahoppen/github-workflows/.github/workflows/performance_test.yml@performance-test
+    with:
+      command: "echo Test: 1"
+      sensitivity: 0

.github/workflows/scripts/compare-performance-measurements.swift

@@ -0,0 +1,90 @@
+import Foundation
+
+func printToStderr(_ value: String) {
+  fputs(value, stderr)
+}
+
+func extractMeasurements(output: String) -> [String: Double] {
+  var measurements: [String: Double] = [:]
+  for line in output.split(separator: "\n") {
+    guard let colonPosition = line.lastIndex(of: ":") else {
+      printToStderr("Ignoring following measurement line because it doesn't contain a colon: \(line)")
+      continue
+    }
+    let beforeColon = String(line[..<colonPosition]).trimmingCharacters(in: .whitespacesAndNewlines)
+    let afterColon = String(line[line.index(after: colonPosition)...]).trimmingCharacters(
+      in: .whitespacesAndNewlines
+    )
+    guard let value = Double(afterColon) else {
+      printToStderr("Ignoring following measurement line because the value can't be parsed as a Double: \(line)")
+      continue
+    }
+    measurements[beforeColon] = value
+  }
+  return measurements
+}
+
+extension Double {
+  func round(toDecimalDigits decimalDigits: Int) -> Double {
+    return (self * pow(10, Double(decimalDigits))).rounded() / pow(10, Double(decimalDigits))
+  }
+}
+
+func run(
+  baselinePerformanceOutput: String,
+  changedPerformanceOutput: String,
+  sensitivityPercentage: Double
+) -> (output: String, hasDetectedSignificantChange: Bool) {
+  let baselineMeasurements = extractMeasurements(output: baselinePerformanceOutput)
+  let changedMeasurements = extractMeasurements(output: changedPerformanceOutput)
+
+  var hasDetectedSignificantChange = false
+  var output = ""
+  for (measurementName, baselineValue) in baselineMeasurements.sorted(by: { $0.key < $1.key }) {
+    guard let changedValue = changedMeasurements[measurementName] else {
+      output += "🛑 \(measurementName) not present after changes\n"
+      continue
+    }
+    let differencePercentage = (changedValue - baselineValue) / baselineValue * 100
+    let rawMeasurementsText = "(baseline: \(baselineValue), after changes: \(changedValue))"
+    if differencePercentage < -sensitivityPercentage {
+      output +=
+        "🎉 \(measurementName) improved by \(-differencePercentage.round(toDecimalDigits: 3))% \(rawMeasurementsText)\n"
+      hasDetectedSignificantChange = true
+    } else if differencePercentage > sensitivityPercentage {
+      output +=
+        "⚠️ \(measurementName) regressed by \(differencePercentage.round(toDecimalDigits: 3))% \(rawMeasurementsText)\n"
+      hasDetectedSignificantChange = true
+    } else {
+      output +=
+        "➡️ \(measurementName) did not change significantly with \(differencePercentage.round(toDecimalDigits: 3))% \(rawMeasurementsText)\n"
+    }
+  }
+  return (output, hasDetectedSignificantChange)
+}
+
+guard CommandLine.arguments.count > 2 else {
+  print("Expected at least two parameters: The baseline performance output and the changed performance output")
+  exit(1)
+}
+
+let baselinePerformanceOutput = CommandLine.arguments[1]
+let changedPerformanceOutput = CommandLine.arguments[2]
+
+let sensitivityPercentage =
+  if CommandLine.arguments.count > 3, let percentage = Double(CommandLine.arguments[3]) {
+    percentage
+  } else {
+    1.0 /* percent */
+  }
+
+let (output, hasDetectedSignificantChange) = run(
+  baselinePerformanceOutput: baselinePerformanceOutput,
+  changedPerformanceOutput: changedPerformanceOutput,
+  sensitivityPercentage: sensitivityPercentage
+)
+
+print(output)
+if hasDetectedSignificantChange {
+  exit(1)
+}

Documentation/Configuration.md

@@ -204,7 +204,30 @@ switch someValue {
 ---
 
 ### `reflowMultilineStringLiterals`
-**type:** `string`
+
+> [!NOTE]
+> This setting should be specified as a string value (e.g. `"never"`)
+> For backward compatibility with swift-format version 601.0.0, the configuration also accepts the legacy object format where the setting is specified as an object with a single key (e.g., ⁠`{ "never": {} }`).
+
+**type:** `string` or `object` (legacy)
+
+**example:**
+
+For all versions above 601.0.0, the configuration should be specified as a string, for example:
+```json
+{
+  "reflowMultilineStringLiterals": "never"
+}
+```
+
+For version 601.0.0, the configuration should be specified as an object, for example:
+```json
+{
+  "reflowMultilineStringLiterals": {
+    "never": {}
+  }
+}
+```
 
 **description:** Determines how multiline string literals should reflow when formatted.
 

Sources/SwiftFormat/API/Configuration.swift

@@ -197,7 +197,7 @@ public struct Configuration: Codable, Equatable {
   public var multiElementCollectionTrailingCommas: Bool
 
   /// Determines how multiline string literals should reflow when formatted.
-  public enum MultilineStringReflowBehavior: Codable {
+  public enum MultilineStringReflowBehavior: String, Codable {
     /// Never reflow multiline string literals.
     case never
     /// Reflow lines in string literal that exceed the maximum line length. For example with a line length of 10:
@@ -241,20 +241,36 @@ public struct Configuration: Codable, Equatable {
     case always
 
     var isNever: Bool {
-      switch self {
-      case .never:
-        return true
-      default:
-        return false
-      }
+      self == .never
     }
 
     var isAlways: Bool {
+      self == .always
+    }
+  }
+
+  /// A private enum created to maintain backward compatibility with swift-format version 601.0.0,
+  /// which had a `MultilineStringReflowBehavior` enum without a String raw type.
+  ///
+  /// In version 601.0.0, the `reflowMultilineStringLiterals` configuration was encoded as an object
+  /// with a single key (e.g., `{ "never": {} }`) rather than as a string (e.g., `"never"`). This
+  /// enum allows decoding from both formats:
+  /// - First, we attempt to decode as a String using `MultilineStringReflowBehavior`
+  /// - If that fails, we fall back to this legacy format
+  /// - If both attempts fail, an error will be thrown
+  ///
+  /// This approach preserves compatibility without requiring a configuration version bump.
+  private enum LegacyMultilineStringReflowBehavior: Codable {
+    case never
+    case onlyLinesOverLength
+    case always
+
+    /// Converts this legacy enum to the corresponding `MultilineStringReflowBehavior` value.
+    func toMultilineStringReflowBehavior() -> MultilineStringReflowBehavior {
       switch self {
-      case .always:
-        return true
-      default:
-        return false
+      case .never: .never
+      case .always: .always
+      case .onlyLinesOverLength: .onlyLinesOverLength
       }
     }
   }
@@ -371,9 +387,31 @@ public struct Configuration: Codable, Equatable {
       )
       ?? defaults.multiElementCollectionTrailingCommas
 
-    self.reflowMultilineStringLiterals =
-      try container.decodeIfPresent(MultilineStringReflowBehavior.self, forKey: .reflowMultilineStringLiterals)
-      ?? defaults.reflowMultilineStringLiterals
+    self.reflowMultilineStringLiterals = try {
+      // Try to decode `reflowMultilineStringLiterals` as a string
+      // This handles configurations using the String raw value format (e.g. "never").
+      // If an error occurs, we'll silently bypass it and fall back to the legacy behavior.
+      if let behavior = try? container.decodeIfPresent(
+        MultilineStringReflowBehavior.self,
+        forKey: .reflowMultilineStringLiterals
+      ) {
+        return behavior
+      }
+
+      // If the modern format fails, try to decode as an object with a single key.
+      // This handles configurations from swift-format v601.0.0 (e.g. { "never": {} }).
+      // If an error occurs in this step, we'll propagate it to the caller.
+      if let legacyBehavior = try container.decodeIfPresent(
+        LegacyMultilineStringReflowBehavior.self,
+        forKey: .reflowMultilineStringLiterals
+      ) {
+        return legacyBehavior.toMultilineStringReflowBehavior()
+      }
+
+      // If the key is not present in the configuration at all, use the default value.
+      return defaults.reflowMultilineStringLiterals
+    }()
+
     self.indentBlankLines =
       try container.decodeIfPresent(
         Bool.self,

Tests/SwiftFormatTests/API/ConfigurationTests.swift

@@ -64,4 +64,44 @@ final class ConfigurationTests: XCTestCase {
     let path = #"\\mount\test.swift"#
     XCTAssertNil(Configuration.url(forConfigurationFileApplyingTo: URL(fileURLWithPath: path)))
   }
+
+  func testDecodingReflowMultilineStringLiteralsAsString() throws {
+    let testCases: [String: Configuration.MultilineStringReflowBehavior] = [
+      "never": .never,
+      "always": .always,
+      "onlyLinesOverLength": .onlyLinesOverLength,
+    ]
+
+    for (jsonString, expectedBehavior) in testCases {
+      let jsonData = """
+        {
+            "reflowMultilineStringLiterals": "\(jsonString)"
+        }
+        """.data(using: .utf8)!
+
+      let config = try JSONDecoder().decode(Configuration.self, from: jsonData)
+      XCTAssertEqual(config.reflowMultilineStringLiterals, expectedBehavior)
+    }
+  }
+
+  func testDecodingReflowMultilineStringLiteralsAsObject() throws {
+
+    let testCases: [String: Configuration.MultilineStringReflowBehavior] = [
+      "{ \"never\": {} }": .never,
+      "{ \"always\": {} }": .always,
+      "{ \"onlyLinesOverLength\": {} }": .onlyLinesOverLength,
+    ]
+
+    for (jsonString, expectedBehavior) in testCases {
+      let jsonData = """
+        {
+            "reflowMultilineStringLiterals": \(jsonString)
+        }
+        """.data(using: .utf8)!
+
+      let config = try JSONDecoder().decode(Configuration.self, from: jsonData)
+      XCTAssertEqual(config.reflowMultilineStringLiterals, expectedBehavior)
+    }
+  }
+
 }

api-breakages.txt

@@ -13,4 +13,8 @@ API breakage: enum Finding.Severity has been removed
 API breakage: var Finding.severity has been removed
 API breakage: var FindingCategorizing.defaultSeverity has been removed
 API breakage: var FindingCategorizing.defaultSeverity has been removed
-API breakage: func Rule.diagnose(_:on:severity:anchor:notes:) has been renamed to func diagnose(_:on:anchor:notes:)
+API breakage: func Rule.diagnose(_:on:severity:anchor:notes:) has been renamed to func diagnose(_:on:anchor:notes:)
+API breakage: func Configuration.MultilineStringReflowBehavior.hash(into:) has been removed
+API breakage: func Configuration.MultilineStringReflowBehavior.encode(to:) has been removed
+API breakage: var Configuration.MultilineStringReflowBehavior.hashValue has been removed
+API breakage: constructor Configuration.MultilineStringReflowBehavior.init(from:) has been removed