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.
+  ///     Defaults 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.
+  ///     Defaults 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,22 @@ 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 {
+            if allowDuplicateInsertions {
+              return false
+            }
+
+            return edit == remainingEdit
+          }
+
+          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

@@ -166,7 +166,9 @@ class FixItApplierApplyEditsTests: XCTestCase {
         .init(range: 3..<7, replacement: "cd"),
       ],
       // The second edit is skipped.
-      possibleOutputs: ["aboo = 1", "varcd = 1"]
+      outputs: [
+        .init(oneOf: "aboo = 1", "varcd = 1")
+      ]
     )
   }
 
@@ -180,19 +182,36 @@ class FixItApplierApplyEditsTests: XCTestCase {
         .init(range: 0..<5, replacement: "_"),
         .init(range: 0..<3, replacement: "let"),
       ],
-      possibleOutputs: ["_ = 11", "let x = 11"]
+      outputs: [
+        .init(oneOf: "_ = 11", "let x = 11")
+      ]
     )
   }
 
   func testOverlappingInsertions() {
+    assertAppliedEdits(
+      to: "x = 1",
+      edits: [
+        .init(range: 1..<1, replacement: "y"),
+        .init(range: 1..<1, replacement: "z"),
+      ],
+      outputs: [
+        .init(oneOf: "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: [
+        .init(deterministic: "var var var x = 2", allowDuplicateInsertions: true),
+        .init(deterministic: "var x = 2", allowDuplicateInsertions: false),
+      ]
     )
   }
 
@@ -214,47 +233,105 @@ 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(oneOf: "_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`.
+/// Represents an output expectation.
+private struct OutputExpectation {
+  var possibleOutputs: [String]
+  var allowDuplicateInsertions: Bool?
+  var line: UInt
+
+  /// Create a deterministic output expectation for the given value of
+  /// `allowDuplicateInsertions`. If `allowDuplicateInsertions` is `nil`,
+  /// the expectation holds for both `true` and `false`.
+  init(
+    deterministic output: String,
+    allowDuplicateInsertions: Bool? = nil,
+    line: UInt = #line
+  ) {
+    self.possibleOutputs = [output]
+    self.allowDuplicateInsertions = allowDuplicateInsertions
+    self.line = line
+  }
+
+  /// Create a "one of the given possible outputs" expectation for the given
+  /// value of `allowDuplicateInsertions`. If `allowDuplicateInsertions` is
+  /// `nil`, the expectation holds for both `true` and `false`.
+  init(
+    oneOf possibleOutputs: String...,
+    allowDuplicateInsertions: Bool? = nil,
+    line: UInt = #line
+  ) {
+    self.possibleOutputs = possibleOutputs
+    self.allowDuplicateInsertions = allowDuplicateInsertions
+    self.line = line
+  }
+}
+
+/// 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],
-  line: UInt = #line
+  outputs: [OutputExpectation]
 ) {
-  precondition(!possibleOutputs.isEmpty)
+  precondition(!outputs.isEmpty)
 
-  var indices = Array(edits.indices)
-  while true {
-    let editsPermutation = indices.map { edits[$0] }
+  NEXT_OUTPUT: for output in outputs {
+    let allowDuplicateInsertionsValues =
+      if let value = output.allowDuplicateInsertions {
+        [value]
+      } else {
+        [true, false]
+      }
 
-    let actualOutput = FixItApplier.apply(edits: editsPermutation, to: tree)
-    guard possibleOutputs.contains(actualOutput) else {
-      XCTFail(
-        """
-        Actual output \"\(actualOutput)\" does not match one of \(possibleOutputs)
-        Edits:
-          \(editsPermutation)
-        """,
-        line: line
-      )
-      return
-    }
+    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] }
 
-    let keepGoing = indices.nextPermutation()
-    guard keepGoing else {
-      break
+      for allowDuplicateInsertionsValue in allowDuplicateInsertionsValues {
+        let actualOutput = FixItApplier.apply(
+          edits: editsPermutation,
+          to: tree,
+          allowDuplicateInsertions: allowDuplicateInsertionsValue
+        )
+
+        guard possibleOutputs.contains(actualOutput) else {
+          XCTFail(
+            """
+            Actual output \"\(actualOutput)\" does not match one of \(possibleOutputs)
+            Edits:
+              \(editsPermutation)
+            allowDuplicateInsertions:
+              \(allowDuplicateInsertionsValue)
+            """,
+            line: output.line
+          )
+
+          // 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],
@@ -264,8 +341,9 @@ private func assertAppliedEdits(
   assertAppliedEdits(
     to: tree,
     edits: edits,
-    possibleOutputs: [output],
-    line: line
+    outputs: [
+      .init(deterministic: output, allowDuplicateInsertions: nil, line: line)
+    ]
   )
 }