diff --git a/Sources/SwiftIDEUtils/FixItApplier.swift b/Sources/SwiftIDEUtils/FixItApplier.swift
index de5785ff941..6253710930d 100644
--- a/Sources/SwiftIDEUtils/FixItApplier.swift
+++ b/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: any SyntaxProtocol
+    to tree: some SyntaxProtocol,
+    allowDuplicateInsertions: Bool = true
   ) -> String {
     let messages = messages ?? diagnostics.compactMap { $0.fixIts.first?.message.message }
 
@@ -43,51 +46,89 @@ 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)
   }
 
-  /// Apply the given edits to the syntax tree.
+  /// Applies the given edits to the given syntax tree.
   ///
   /// - Parameters:
-  ///   - edits: The edits to apply to the syntax tree
-  ///   - tree: he syntax tree to which the edits should be applied.
-  /// - Returns: A `String` representation of the modified syntax tree after applying the edits.
+  ///   - 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: any SyntaxProtocol
+    to tree: some SyntaxProtocol,
+    allowDuplicateInsertions: Bool = true
   ) -> String {
     var edits = edits
     var source = tree.description
 
-    while let edit = edits.first {
-      edits = Array(edits.dropFirst())
+    for var editIndex in edits.indices {
+      let edit = edits[editIndex]
+
+      // Empty edits do nothing.
+      guard !edit.isEmpty else {
+        continue
+      }
+
+      do {
+        let utf8 = source.utf8
+        let startIndex = utf8.index(utf8.startIndex, offsetBy: edit.startUtf8Offset)
+        let endIndex = utf8.index(utf8.startIndex, offsetBy: edit.endUtf8Offset)
+
+        source.replaceSubrange(startIndex..<endIndex, with: edit.replacement)
+      }
+
+      // Drop any subsequent edits that conflict with one we just applied, and
+      // adjust the range of the rest.
+      while edits.formIndex(after: &editIndex) != edits.endIndex {
+        let remainingEdit = edits[editIndex]
+
+        // Empty edits do nothing.
+        guard !remainingEdit.isEmpty else {
+          continue
+        }
+
+        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
+            }
 
-      let startIndex = source.utf8.index(source.utf8.startIndex, offsetBy: edit.startUtf8Offset)
-      let endIndex = source.utf8.index(source.utf8.startIndex, offsetBy: edit.endUtf8Offset)
+            return edit == remainingEdit
+          }
 
-      source.replaceSubrange(startIndex..<endIndex, with: edit.replacement)
+          // Edits conflict in the following cases:
+          //
+          // - Their ranges have a common element.
+          // - One's range is empty and its lower bound is strictly within the
+          //   other's range. So 0..<2 also conflicts with 1..<1, but not with
+          //   0..<0 or 2..<2.
+          //
+          return edit.endUtf8Offset > remainingEdit.startUtf8Offset
+            && edit.startUtf8Offset < remainingEdit.endUtf8Offset
+        }
 
-      edits = edits.compactMap { remainingEdit -> SourceEdit? in
-        if remainingEdit.replacementRange.overlaps(edit.replacementRange) {
-          // The edit overlaps with the previous edit. We can't apply both
-          // without conflicts. Apply the one that's listed first and drop the
-          // later edit.
-          return nil
+        guard !shouldDropRemainingEdit() else {
+          // Drop the edit by swapping it for an empty one.
+          edits[editIndex] = SourceEdit()
+          continue
         }
 
         // If the remaining edit starts after or at the end of the edit that we just applied,
         // shift it by the current edit's difference in length.
         if edit.endUtf8Offset <= remainingEdit.startUtf8Offset {
-          let startPosition = AbsolutePosition(
-            utf8Offset: remainingEdit.startUtf8Offset - edit.replacementRange.count + edit.replacementLength.utf8Length
-          )
-          let endPosition = AbsolutePosition(
-            utf8Offset: remainingEdit.endUtf8Offset - edit.replacementRange.count + edit.replacementLength.utf8Length
-          )
-          return SourceEdit(range: startPosition..<endPosition, replacement: remainingEdit.replacement)
-        }
+          let shift = edit.replacementLength.utf8Length - edit.range.count
+          let startPosition = AbsolutePosition(utf8Offset: remainingEdit.startUtf8Offset + shift)
+          let endPosition = AbsolutePosition(utf8Offset: remainingEdit.endUtf8Offset + shift)
 
-        return remainingEdit
+          edits[editIndex] = SourceEdit(range: startPosition..<endPosition, replacement: remainingEdit.replacement)
+        }
       }
     }
 
@@ -95,6 +136,13 @@ public enum FixItApplier {
   }
 }
 
+private extension Collection {
+  func formIndex(after index: inout Index) -> Index {
+    self.formIndex(after: &index) as Void
+    return index
+  }
+}
+
 private extension SourceEdit {
   var startUtf8Offset: Int {
     return range.lowerBound.utf8Offset
@@ -104,7 +152,15 @@ private extension SourceEdit {
     return range.upperBound.utf8Offset
   }
 
-  var replacementRange: Range<Int> {
-    return startUtf8Offset..<endUtf8Offset
+  var isEmpty: Bool {
+    self.range.isEmpty && self.replacement.isEmpty
+  }
+
+  init() {
+    self = SourceEdit(
+      range: AbsolutePosition(utf8Offset: 0)..<AbsolutePosition(utf8Offset: 0),
+      replacement: []
+    )
+    precondition(self.isEmpty)
   }
 }
diff --git a/Sources/SwiftSyntax/AbsolutePosition.swift b/Sources/SwiftSyntax/AbsolutePosition.swift
index bd2ce4efe9d..dfd49784f7b 100644
--- a/Sources/SwiftSyntax/AbsolutePosition.swift
+++ b/Sources/SwiftSyntax/AbsolutePosition.swift
@@ -21,11 +21,17 @@ public struct AbsolutePosition: Comparable, Hashable, Sendable {
     self.utf8Offset = utf8Offset
   }
 
+  public static func < (lhs: AbsolutePosition, rhs: AbsolutePosition) -> Bool {
+    return lhs.utf8Offset < rhs.utf8Offset
+  }
+}
+
+extension AbsolutePosition: Strideable {
   public func advanced(by offset: Int) -> AbsolutePosition {
-    return AbsolutePosition(utf8Offset: self.utf8Offset + offset)
+    AbsolutePosition(utf8Offset: self.utf8Offset + offset)
   }
 
-  public static func < (lhs: AbsolutePosition, rhs: AbsolutePosition) -> Bool {
-    return lhs.utf8Offset < rhs.utf8Offset
+  public func distance(to other: AbsolutePosition) -> Int {
+    self.utf8Offset.distance(to: other.utf8Offset)
   }
 }
diff --git a/Tests/SwiftIDEUtilsTest/FixItApplierTests.swift b/Tests/SwiftIDEUtilsTest/FixItApplierTests.swift
new file mode 100644
index 00000000000..d45be14f3c5
--- /dev/null
+++ b/Tests/SwiftIDEUtilsTest/FixItApplierTests.swift
@@ -0,0 +1,418 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 testNonOverlappingInsertions() {
+    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 testAdjacentReplacements() {
+    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 testNonOverlappingReplacementAndInsertion() {
+    assertAppliedEdits(
+      to: "var x = 1",
+      edits: [
+        .init(range: 0..<3, replacement: "let"),  // Replacement
+        .init(range: 0..<0, replacement: "a"),  // Insertion
+      ],
+      output: "alet x = 1"
+    )
+
+    assertAppliedEdits(
+      to: "var x = 1",
+      edits: [
+        .init(range: 0..<5, replacement: "a"),  // Replacement
+        .init(range: 5..<5, replacement: "b"),  // Insertion
+      ],
+      output: "ab = 1"
+    )
+  }
+
+  func testNonOverlappingEditsSingleLine() {
+    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 testNonOverlappingEditsMultiline() {
+    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 testNonOverlappingEditsCrossLine() {
+    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 testDuplicateReplacements() {
+    assertAppliedEdits(
+      to: "var x = 1",
+      edits: [
+        .init(range: 0..<3, replacement: "let"),
+        .init(range: 0..<3, replacement: "let"),
+        .init(range: 0..<3, replacement: "let"),
+      ],
+      output: "let x = 1"
+    )
+  }
+
+  func testOverlappingEdits1() {
+    assertAppliedEdits(
+      to: "var foo = 1",
+      edits: [
+        .init(range: 0..<5, replacement: "ab"),
+        .init(range: 3..<7, replacement: "cd"),
+      ],
+      // The second edit is skipped.
+      outputs: [
+        .init(oneOf: "aboo = 1", "varcd = 1")
+      ]
+    )
+  }
+
+  func testOverlappingEdits2() {
+    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"),
+      ],
+      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 "),
+      ],
+      outputs: [
+        .init(deterministic: "var var var x = 2", allowDuplicateInsertions: true),
+        .init(deterministic: "var x = 2", allowDuplicateInsertions: false),
+      ]
+    )
+  }
+
+  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
+      ],
+      outputs: [
+        .init(oneOf: "_ = 1", "vaar x = 1")
+      ]
+    )
+  }
+}
+
+/// 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],
+  outputs: [OutputExpectation]
+) {
+  precondition(!outputs.isEmpty)
+
+  NEXT_OUTPUT: for output in outputs {
+    let allowDuplicateInsertionsValues =
+      if let value = output.allowDuplicateInsertions {
+        [value]
+      } else {
+        [true, false]
+      }
+
+    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
+        )
+
+        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` and for `allowDuplicateInsertions`
+/// both `true` and `false`.
+private func assertAppliedEdits(
+  to tree: SourceFileSyntax,
+  edits: [SourceEdit],
+  output: String,
+  line: UInt = #line
+) {
+  assertAppliedEdits(
+    to: tree,
+    edits: edits,
+    outputs: [
+      .init(deterministic: output, allowDuplicateInsertions: nil, line: line)
+    ]
+  )
+}
+
+// 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
+      }
+    }
+  }
+}