FixItApplier: Add parameter for skipping duplicate insertions

Author: AnthonyLatsis

Sources/SwiftIDEUtils/FixItApplier.swift

@@ -27,12 +27,15 @@ public enum FixItApplier {
   ///   - filterByMessages: An optional array of message strings to filter which Fix-Its to apply.
   ///     If `nil`, the first Fix-It from each diagnostic is applied.
   ///   - tree: The syntax tree to which the Fix-Its will be applied.
+  ///   - allowDuplicateInsertions: Whether to apply duplicate insertions.
+  ///   Default to `true`.
   ///
   /// - Returns: A `String` representation of the modified syntax tree after applying the Fix-Its.
   public static func applyFixes(
     from diagnostics: [Diagnostic],
     filterByMessages messages: [String]?,
-    to tree: some SyntaxProtocol
+    to tree: some SyntaxProtocol,
+    allowDuplicateInsertions: Bool = true
   ) -> String {
     let messages = messages ?? diagnostics.compactMap { $0.fixIts.first?.message.message }
 
@@ -43,18 +46,22 @@ public enum FixItApplier {
       .filter { messages.contains($0.message.message) }
       .flatMap(\.edits)
 
-    return self.apply(edits: edits, to: tree)
+    return self.apply(edits: edits, to: tree, allowDuplicateInsertions: allowDuplicateInsertions)
   }
 
   /// Applies the given edits to the given syntax tree.
   ///
   /// - Parameters:
   ///   - edits: The edits to apply.
   ///   - tree: The syntax tree to which the edits should be applied.
+  ///   - allowDuplicateInsertions: Whether to apply duplicate insertions.
+  ///   Default to `true`.
+  ///
   /// - Returns: A `String` representation of the modified syntax tree.
   public static func apply(
     edits: [SourceEdit],
-    to tree: some SyntaxProtocol
+    to tree: some SyntaxProtocol,
+    allowDuplicateInsertions: Bool = true
   ) -> String {
     var edits = edits
     var source = tree.description
@@ -89,10 +96,21 @@ public enum FixItApplier {
           continue
         }
 
-        guard !remainingEdit.range.overlaps(edit.range) else {
-          // The edit overlaps with the previous edit. We can't apply both
-          // without conflicts. Drop this one by swapping it for a no-op
-          // edit.
+        func shouldDropRemainingEdit() -> Bool {
+          // Insertions never conflict between themselves, unless we were asked
+          // to drop duplicate insertions.
+          if edit.range.isEmpty && remainingEdit.range.isEmpty {
+            guard allowDuplicateInsertions else {
+              return edit == remainingEdit
+            }
+            return false
+          }
+
+          return remainingEdit.range.overlaps(edit.range)
+        }
+
+        guard !shouldDropRemainingEdit() else {
+          // Drop the edit by swapping it for an empty one.
           edits[editIndex] = SourceEdit()
           continue
         }

Tests/SwiftIDEUtilsTest/FixItApplierTests.swift

@@ -134,7 +134,9 @@ class FixItApplierApplyEditsTests: XCTestCase {
         .init(range: 3..<7, replacement: "cd"),
       ],
       // The second edit is skipped.
-      possibleOutputs: ["aboo = 1", "varcd = 1"]
+      outputs: [
+        .either(["aboo = 1", "varcd = 1"])
+      ]
     )
   }
 
@@ -148,19 +150,36 @@ class FixItApplierApplyEditsTests: XCTestCase {
         .init(range: 0..<5, replacement: "_"),
         .init(range: 0..<3, replacement: "let"),
       ],
-      possibleOutputs: ["_ = 11", "let x = 11"]
+      outputs: [
+        .either(["_ = 11", "let x = 11"])
+      ]
     )
   }
 
   func testMultipleOverlappingInsertions() {
+    assertAppliedEdits(
+      to: "x = 1",
+      edits: [
+        .init(range: 1..<1, replacement: "y"),
+        .init(range: 1..<1, replacement: "z"),
+      ],
+      outputs: [
+        .either(["xyz = 1", "xzy = 1"])
+      ]
+    )
+
     assertAppliedEdits(
       to: "x = 1",
       edits: [
         .init(range: 0..<0, replacement: "var "),
         .init(range: 0..<0, replacement: "var "),
+        .init(range: 4..<5, replacement: "2"),
         .init(range: 0..<0, replacement: "var "),
       ],
-      output: "var var var x = 1"
+      outputs: [
+        .output("var var var x = 2", allowDuplicateInsertions: true),
+        .output("var x = 2", allowDuplicateInsertions: false),
+      ]
     )
   }
 
@@ -182,43 +201,110 @@ class FixItApplierApplyEditsTests: XCTestCase {
         .init(range: 2..<2, replacement: "a"),  // Insertion
       ],
       // FIXME: This behavior where these edits are not considered overlapping doesn't feel desirable
-      possibleOutputs: ["_x = 1", "_ a= 1"]
+      outputs: [
+        .either(["_x = 1", "_ a= 1"])
+      ]
     )
   }
 }
 
-/// Asserts that at least one element in `possibleOutputs` matches the result
-/// of applying an array of edits to `input`, for all permutations of `edits`.
+private enum Output {
+  case output(String, allowDuplicateInsertions: Bool? = nil)
+  case either([String], allowDuplicateInsertions: Bool? = nil)
+
+  var possibleOutputs: [String] {
+    switch self {
+    case .output(let output, _):
+      return [output]
+    case .either(let outputs, _):
+      return outputs
+    }
+  }
+
+  var allowDuplicateInsertions: Bool? {
+    switch self {
+    case .output(_, let allowDuplicateInsertions),
+      .either(_, let allowDuplicateInsertions):
+      return allowDuplicateInsertions
+    }
+  }
+}
+
+/// Asserts that the given outputs match the result of applying an array of
+/// edits to `input`, for all permutations of `edits`.
 private func assertAppliedEdits(
   to tree: SourceFileSyntax,
   edits: [SourceEdit],
-  possibleOutputs: [String]
+  outputs: [Output]
 ) {
-  precondition(!possibleOutputs.isEmpty)
-
-  var indices = Array(edits.indices)
-  while true {
-    let result = FixItApplier.apply(edits: indices.map { edits[$0] }, to: tree)
-    guard possibleOutputs.contains(result) else {
-      XCTFail("\"\(result)\" is not equal to either of \(possibleOutputs)")
-      return
-    }
+  precondition(!outputs.isEmpty)
+
+  NEXT_OUTPUT: for output in outputs {
+    let allowDuplicateInsertionsValues =
+      switch output.allowDuplicateInsertions {
+      case .none:
+        [true, false]
+      case .some(let value):
+        [value]
+      }
+
+    let possibleOutputs = output.possibleOutputs
+
+    // Check this output against all permutations of edits.
+    var indices = Array(edits.indices)
+    while true {
+      let editsPermutation = indices.map { edits[$0] }
+
+      for allowDuplicateInsertionsValue in allowDuplicateInsertionsValues {
+        let actualOutput = FixItApplier.apply(
+          edits: editsPermutation,
+          to: tree,
+          allowDuplicateInsertions: allowDuplicateInsertionsValue
+        )
 
-    let keepGoing = indices.nextPermutation()
-    guard keepGoing else {
-      break
+        guard possibleOutputs.contains(actualOutput) else {
+          XCTFail(
+            """
+
+            Actual output:
+              \"\(actualOutput)\"
+            Expected output:
+              either of \(possibleOutputs)
+            Edits:
+              \(editsPermutation)
+            allowDuplicateInsertions:
+              \(allowDuplicateInsertionsValue)
+            """
+          )
+
+          // Fail once for all permutations to avoid excessive logging.
+          continue NEXT_OUTPUT
+        }
+      }
+
+      let keepGoing = indices.nextPermutation()
+      guard keepGoing else {
+        break
+      }
     }
   }
 }
 
 /// Asserts that `output` matches the result of applying an array of edits to
-/// `input`, for all permutations of `edits`.
+/// `input`, for all permutations of `edits` and for `allowDuplicateInsertions`
+/// both `true` and `false`.
 private func assertAppliedEdits(
   to tree: SourceFileSyntax,
   edits: [SourceEdit],
   output: String
 ) {
-  assertAppliedEdits(to: tree, edits: edits, possibleOutputs: [output])
+  assertAppliedEdits(
+    to: tree,
+    edits: edits,
+    outputs: [
+      .output(output, allowDuplicateInsertions: nil)
+    ]
+  )
 }
 
 // Grabbed from https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Permutations.swift