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
@@ -85,10 +92,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)
+ ]
  )
 }