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,10 @@ class FixItApplierApplyEditsTests: XCTestCase {
         .init(range: 3..<7, replacement: "cd"),
       ],
       // The second edit is skipped.
-      possibleOutputs: ["aboo = 1", "varcd = 1"]
+      outputs: [
+        .init("aboo = 1"),
+        .init("varcd = 1"),
+      ]
     )
   }
 
@@ -148,19 +151,37 @@ class FixItApplierApplyEditsTests: XCTestCase {
         .init(range: 0..<5, replacement: "_"),
         .init(range: 0..<3, replacement: "let"),
       ],
-      possibleOutputs: ["_ = 11", "let x = 11"]
+      outputs: [
+        .init("_ = 11"),
+        .init("let x = 11"),
+      ]
     )
   }
 
   func testMultipleOverlappingInsertions() {
+    assertAppliedEdits(
+      to: "x = 1",
+      edits: [
+        .init(range: 1..<1, replacement: "y"),
+        .init(range: 1..<1, replacement: "z"),
+      ],
+      outputs: [
+        .init("xyz = 1"),
+        .init("xzy = 1"),
+      ]
+    )
+
     assertAppliedEdits(
       to: "x = 1",
       edits: [
         .init(range: 0..<0, replacement: "var "),
         .init(range: 0..<0, replacement: "var "),
         .init(range: 0..<0, replacement: "var "),
       ],
-      output: "var var var x = 1"
+      outputs: [
+        .init("var var var x = 1", allowDuplicateInsertions: true),
+        .init("var x = 1", allowDuplicateInsertions: false),
+      ]
     )
   }
 
@@ -182,28 +203,69 @@ 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: [
+        .init("_x = 1"),
+        .init("_ a= 1"),
+      ]
     )
   }
 }
 
+private struct Output {
+  var result: String
+  var allowDuplicateInsertions: Bool?
+
+  init(_ result: String, allowDuplicateInsertions: Bool? = nil) {
+    self.result = result
+    self.allowDuplicateInsertions = allowDuplicateInsertions
+  }
+}
+
 /// 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 func assertAppliedEdits(
   to tree: SourceFileSyntax,
   edits: [SourceEdit],
-  possibleOutputs: [String]
+  outputs: [Output]
 ) {
-  precondition(!possibleOutputs.isEmpty)
+  precondition(!outputs.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)")
+  func assertAppliedEdits(
+    permutation: [SourceEdit],
+    allowDuplicateInsertions: Bool
+  ) {
+    // Filter out the results that match this setting.
+    let viableResults: [String] = outputs.compactMap { output in
+      if output.allowDuplicateInsertions == !allowDuplicateInsertions {
+        return nil
+      }
+
+      return output.result
+    }
+
+    guard !viableResults.isEmpty else {
       return
     }
 
+    let result = FixItApplier.apply(
+      edits: permutation,
+      to: tree,
+      allowDuplicateInsertions: allowDuplicateInsertions
+    )
+
+    guard viableResults.contains(result) else {
+      XCTFail("\"\(result)\" is not equal to either of \(viableResults)")
+      return
+    }
+  }
+
+  var indices = Array(edits.indices)
+  while true {
+    let permutation = indices.map { edits[$0] }
+
+    assertAppliedEdits(permutation: permutation, allowDuplicateInsertions: true)
+    assertAppliedEdits(permutation: permutation, allowDuplicateInsertions: false)
+
     let keepGoing = indices.nextPermutation()
     guard keepGoing else {
       break
@@ -218,7 +280,13 @@ private func assertAppliedEdits(
   edits: [SourceEdit],
   output: String
 ) {
-  assertAppliedEdits(to: tree, edits: edits, possibleOutputs: [output])
+  assertAppliedEdits(
+    to: tree,
+    edits: edits,
+    outputs: [
+      .init(output)
+    ]
+  )
 }
 
 // Grabbed from https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Permutations.swift