SwiftIDEUtilsTest: Add tests for FixItApplier

Author: AnthonyLatsis

Tests/SwiftIDEUtilsTest/FixItApplierTests.swift

@@ -0,0 +1,293 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+@_spi(FixItApplier) import SwiftIDEUtils
+import SwiftSyntax
+import XCTest
+
+private extension SourceEdit {
+  init(range: Range<Int>, replacement: String) {
+    self.init(
+      range: AbsolutePosition(utf8Offset: range.lowerBound)..<AbsolutePosition(utf8Offset: range.upperBound),
+      replacement: replacement
+    )
+  }
+}
+
+class FixItApplierApplyEditsTests: XCTestCase {
+  func testNoEdits() {
+    assertAppliedEdits(
+      to: "var x = 1",
+      edits: [],
+      output: "var x = 1"
+    )
+  }
+
+  func testSingleEdit() {
+    assertAppliedEdits(
+      to: "var  x = 1",
+      edits: [
+        .init(range: 0..<4, replacement: "let")
+      ],
+      output: "let x = 1"
+    )
+  }
+
+  func testMultipleNonOverlappingInsertionsSingleLine() {
+    assertAppliedEdits(
+      to: "x = 1",
+      edits: [
+        .init(range: 0..<0, replacement: "var "),
+        .init(range: 1..<1, replacement: "var "),
+        .init(range: 2..<2, replacement: "var "),
+      ],
+      output: "var xvar  var = 1"
+    )
+  }
+
+  func testMultipleAdjacentReplacementsSingleLine() {
+    assertAppliedEdits(
+      to: "let x = 1",
+      edits: [
+        .init(range: 0..<5, replacement: "_"),
+        .init(range: 5..<8, replacement: " == "),
+        .init(range: 8..<9, replacement: "2"),
+      ],
+      output: "_ == 2"
+    )
+  }
+
+  func testMultipleNonOverlappingEditsSingleLine() {
+    assertAppliedEdits(
+      to: "var x = foo(1, 2)",
+      edits: [
+        .init(range: 0..<5, replacement: "_"),  // Replacement
+        .init(range: 6..<7, replacement: "="),  // Replacement
+        .init(range: 12..<12, replacement: "331"),  // Insertion
+        .init(range: 8..<11, replacement: ""),  // Deletion
+        // Adjacent, not overlapping.
+        .init(range: 16..<16, replacement: "33"),  // Insertion
+        .init(range: 15..<16, replacement: "11"),  // Replacement
+      ],
+      output: "_ = (3311, 1133)"
+    )
+  }
+
+  func testMultipleNonOverlappingEditsOnDifferentLines() {
+    assertAppliedEdits(
+      to: """
+        var x = 1
+        var y = 2
+        var z = 3
+        var w = foo(1, 2)
+        """,
+      edits: [
+        .init(range: 0..<3, replacement: "let"),  // Replacement
+        .init(range: 19..<19, replacement: "44"),  // Insertion
+        .init(range: 20..<24, replacement: ""),  // Deletion
+        .init(range: 38..<41, replacement: "fooo"),  // Replacement
+        .init(range: 46..<46, replacement: "33"),  // Insertion
+        .init(range: 30..<34, replacement: ""),  // Deletion
+      ],
+      output: """
+        let x = 1
+        var y = 244
+        z = 3
+        w = fooo(1, 233)
+        """
+    )
+  }
+
+  func testMultipleNonOverlappingEditsAcrossLines() {
+    assertAppliedEdits(
+      to: """
+        var x = 1
+        let y = 2
+        var w = 3
+        let z = 4
+        """,
+      edits: [
+        .init(range: 6..<17, replacement: ""),
+        .init(range: 17..<28, replacement: "= 5"),
+      ],
+      output: """
+        var x = 53
+        let z = 4
+        """
+    )
+  }
+
+  func testMultipleOverlappingEditsSingleLine1() {
+    assertAppliedEdits(
+      to: "var foo = 1",
+      edits: [
+        .init(range: 0..<5, replacement: "ab"),
+        .init(range: 3..<7, replacement: "cd"),
+      ],
+      // The second edit is skipped.
+      possibleOutputs: ["aboo = 1", "varcd = 1"]
+    )
+  }
+
+  func testMultipleOverlappingEditsSingleLine2() {
+    assertAppliedEdits(
+      to: "var x = 1",
+      edits: [
+        .init(range: 0..<5, replacement: "_"),
+        .init(range: 0..<5, replacement: "_"),
+        .init(range: 8..<8, replacement: "1"),
+        .init(range: 0..<5, replacement: "_"),
+        .init(range: 0..<3, replacement: "let"),
+      ],
+      possibleOutputs: ["_ = 11", "let x = 11"]
+    )
+  }
+
+  func testMultipleOverlappingInsertions() {
+    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"
+    )
+  }
+
+  func testOverlappingReplacementAndInsertion() {
+    assertAppliedEdits(
+      to: "var x = 1",
+      edits: [
+        .init(range: 0..<5, replacement: "_"),  // Replacement
+        .init(range: 2..<2, replacement: ""),  // Empty edit
+      ],
+      // Empty edit never overlaps with anything.
+      output: "_ = 1"
+    )
+
+    assertAppliedEdits(
+      to: "var x = 1",
+      edits: [
+        .init(range: 0..<5, replacement: "_"),  // Replacement
+        .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"]
+    )
+  }
+}
+
+/// 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]
+) {
+  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
+    }
+
+    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`.
+private func assertAppliedEdits(
+  to tree: SourceFileSyntax,
+  edits: [SourceEdit],
+  output: String
+) {
+  assertAppliedEdits(to: tree, edits: edits, possibleOutputs: [output])
+}
+
+// Grabbed from https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Permutations.swift
+
+private extension MutableCollection where Self: BidirectionalCollection {
+  mutating func reverse(subrange: Range<Index>) {
+    if subrange.isEmpty { return }
+    var lower = subrange.lowerBound
+    var upper = subrange.upperBound
+    while lower < upper {
+      formIndex(before: &upper)
+      swapAt(lower, upper)
+      formIndex(after: &lower)
+    }
+  }
+}
+
+private extension MutableCollection where Self: BidirectionalCollection, Element: Comparable {
+  /// Permutes this collection's elements through all the lexical orderings.
+  ///
+  /// Call `nextPermutation()` repeatedly starting with the collection in sorted
+  /// order. When the full cycle of all permutations has been completed, the
+  /// collection will be back in sorted order and this method will return
+  /// `false`.
+  ///
+  /// - Returns: A Boolean value indicating whether the collection still has
+  ///   remaining permutations. When this method returns `false`, the collection
+  ///   is in ascending order according to `areInIncreasingOrder`.
+  ///
+  /// - Complexity: O(*n*), where *n* is the length of the collection.
+  mutating func nextPermutation(upperBound: Index? = nil) -> Bool {
+    // Ensure we have > 1 element in the collection.
+    guard !isEmpty else { return false }
+    var i = index(before: endIndex)
+    if i == startIndex { return false }
+
+    let upperBound = upperBound ?? endIndex
+
+    while true {
+      let ip1 = i
+      formIndex(before: &i)
+
+      // Find the last ascending pair (ie. ..., a, b, ... where a < b)
+      if self[i] < self[ip1] {
+        // Find the last element greater than self[i]
+        // swift-format-ignore: NeverForceUnwrap
+        // This is _always_ at most `ip1` due to if statement above
+        let j = lastIndex(where: { self[i] < $0 })!
+
+        // At this point we have something like this:
+        //    0, 1, 4, 3, 2
+        //       ^        ^
+        //       i        j
+        swapAt(i, j)
+        self.reverse(subrange: ip1..<endIndex)
+
+        // Only return if we've made a change within ..<upperBound region
+        if i < upperBound {
+          return true
+        } else {
+          i = index(before: endIndex)
+          continue
+        }
+      }
+
+      if i == startIndex {
+        self.reverse()
+        return false
+      }
+    }
+  }
+}