Store the replacement string in IncrementalEdit

IIRC the main reason that `IncrementalEdit` didn’t contain the replacement string was that the edits needed to be transferred over XPC at some point and transferring strings over XPC is always a little tricky. Since the actual contents weren’t actually needed, the actual contents weren’t actually needed.

I would like to use `ConcurrentEdits(fromSequential:)` in SourceKit-LSP and for that I need the actual replacement contents. Instead of rolling our own sequential to concurrent replacement (which is non-trivial), let’s re-use the one in SwiftSyntax.

Author: ahoppen

Sources/SwiftParser/IncrementalParseTransition.swift

@@ -347,17 +347,22 @@ public struct ConcurrentEdits: Sendable {
         if existingEdit.replacementRange.intersectsOrTouches(editToAdd.range) {
           let intersectionLength =
             existingEdit.replacementRange.intersected(editToAdd.range).length
+          let replacement: [UInt8]
+          replacement =
+            existingEdit.replacement.prefix(max(0, editToAdd.offset - existingEdit.replacementRange.offset))
+            + editToAdd.replacement
+            + existingEdit.replacement.suffix(max(0, existingEdit.replacementRange.endOffset - editToAdd.endOffset))
           editToAdd = IncrementalEdit(
             offset: Swift.min(existingEdit.offset, editToAdd.offset),
             length: existingEdit.length + editToAdd.length - intersectionLength,
-            replacementLength: existingEdit.replacementLength + editToAdd.replacementLength - intersectionLength
+            replacement: replacement
           )
           editIndicesMergedWithNewEdit.append(index)
         } else if existingEdit.offset < editToAdd.endOffset {
           editToAdd = IncrementalEdit(
             offset: editToAdd.offset - existingEdit.replacementLength + existingEdit.length,
             length: editToAdd.length,
-            replacementLength: editToAdd.replacementLength
+            replacement: editToAdd.replacement
           )
         }
       }

Sources/SwiftSyntax/Utils.swift

@@ -50,8 +50,12 @@ public struct ByteSourceRange: Equatable, Sendable {
 public struct IncrementalEdit: Equatable, Sendable {
   /// The byte range of the original source buffer that the edit applies to.
   public let range: ByteSourceRange
+
+  /// The UTF-8 bytes that should be inserted as part of the edit
+  public let replacement: [UInt8]
+
   /// The length of the edit replacement in UTF8 bytes.
-  public let replacementLength: Int
+  public var replacementLength: Int { replacement.count }
 
   public var offset: Int { return range.offset }
 
@@ -64,14 +68,25 @@ public struct IncrementalEdit: Equatable, Sendable {
     return ByteSourceRange(offset: offset, length: replacementLength)
   }
 
+  @available(*, deprecated, message: "Use IncrementalEdit(range:replacement:) instead")
   public init(range: ByteSourceRange, replacementLength: Int) {
     self.range = range
-    self.replacementLength = replacementLength
+    self.replacement = Array(repeating: UInt8(ascii: " "), count: replacementLength)
   }
 
+  @available(*, deprecated, message: "Use IncrementalEdit(offset:length:replacement:) instead")
   public init(offset: Int, length: Int, replacementLength: Int) {
     self.range = ByteSourceRange(offset: offset, length: length)
-    self.replacementLength = replacementLength
+    self.replacement = Array(repeating: UInt8(ascii: " "), count: replacementLength)
+  }
+
+  public init(offset: Int, length: Int, replacement: [UInt8]) {
+    self.range = ByteSourceRange(offset: offset, length: length)
+    self.replacement = replacement
+  }
+
+  public init(offset: Int, length: Int, replacement: String) {
+    self.init(offset: offset, length: length, replacement: Array(replacement.utf8))
   }
 
   public func intersectsOrTouchesRange(_ other: ByteSourceRange) -> Bool {

Sources/_SwiftSyntaxTestSupport/IncrementalParseTestUtils.swift

@@ -182,10 +182,7 @@ public func extractEditsAndSources(from source: String) -> (edits: ConcurrentEdi
         from: source.index(after: startIndex),
         to: separateIndex
       ),
-      replacementLength: source.utf8.distance(
-        from: source.index(after: separateIndex),
-        to: endIndex
-      )
+      replacement: Array(source.utf8[source.index(after: separateIndex)..<endIndex])
     )
     originalSource += source[source.index(after: startIndex)..<separateIndex]
 
@@ -213,12 +210,8 @@ public func extractEditsAndSources(from source: String) -> (edits: ConcurrentEdi
 public func applyEdits(
   _ edits: [IncrementalEdit],
   concurrent: Bool,
-  to testString: String,
-  replacementChar: Character = "?"
+  to testString: String
 ) -> String {
-  guard let replacementAscii = replacementChar.asciiValue else {
-    fatalError("replacementChar must be an ASCII character")
-  }
   var edits = edits
   if concurrent {
     XCTAssert(ConcurrentEdits._isValidConcurrentEditArray(edits))
@@ -232,7 +225,7 @@ public func applyEdits(
   for edit in edits {
     assert(edit.endOffset <= bytes.count)
     bytes.removeSubrange(edit.offset..<edit.endOffset)
-    bytes.insert(contentsOf: [UInt8](repeating: replacementAscii, count: edit.replacementLength), at: edit.offset)
+    bytes.insert(contentsOf: edit.replacement, at: edit.offset)
   }
   return String(bytes: bytes, encoding: .utf8)!
 }