Merge SourceEdit and IncrementalEdit

Author: kimdv

Sources/SwiftIDEUtils/FixItApplier.swift

@@ -103,10 +103,6 @@ private extension SourceEdit {
     return range.upperBound.utf8Offset
   }
 
-  var replacementLength: Int {
-    return replacement.utf8.count
-  }
-
   var replacementRange: Range<Int> {
     return startUtf8Offset..<endUtf8Offset
   }

Sources/SwiftParser/IncrementalParseTransition.swift

@@ -162,7 +162,7 @@ struct IncrementalParseLookup {
 
     // Fast path check: if parser is past all the edits then any matching node
     // can be re-used.
-    if !edits.edits.isEmpty && edits.edits.last!.range.endOffset < node.position.utf8Offset {
+    if !edits.edits.isEmpty && edits.edits.last!.range.upperBound.utf8Offset < node.position.utf8Offset {
       return true
     }
 
@@ -172,15 +172,15 @@ struct IncrementalParseLookup {
       return false
     }
 
-    let nodeAffectRange = ByteSourceRange(
-      offset: node.position.utf8Offset,
-      length: nodeAffectRangeLength
-    )
+    let nodeAffectRange =
+      AbsolutePosition(
+        utf8Offset: node.position.utf8Offset
+      )..<AbsolutePosition(utf8Offset: node.position.utf8Offset + nodeAffectRangeLength)
 
     for edit in edits.edits {
       // Check if this node or the trivia of the next node has been edited. If
       // it has, we cannot reuse it.
-      if edit.range.offset > nodeAffectRange.endOffset {
+      if edit.range.lowerBound.utf8Offset > nodeAffectRange.upperBound.utf8Offset {
         // Remaining edits don't affect the node. (Edits are sorted)
         break
       }
@@ -195,16 +195,16 @@ struct IncrementalParseLookup {
   fileprivate func translateToPreEditOffset(_ postEditOffset: Int) -> Int? {
     var offset = postEditOffset
     for edit in edits.edits {
-      if edit.range.offset > offset {
+      if edit.range.lowerBound.utf8Offset > offset {
         // Remaining edits doesn't affect the position. (Edits are sorted)
         break
       }
-      if edit.range.offset + edit.replacementLength > offset {
+      if edit.range.lowerBound.utf8Offset + edit.replacementLength > offset {
         // This is a position inserted by the edit, and thus doesn't exist in
         // the pre-edit version of the file.
         return nil
       }
-      offset = offset - edit.replacementLength + edit.range.length
+      offset = offset - edit.replacementLength + edit.range.length.utf8Length
     }
     return offset
   }
@@ -303,11 +303,11 @@ public struct ConcurrentEdits: Sendable {
 
   /// The raw concurrent edits. Are guaranteed to satisfy the requirements
   /// stated above.
-  public let edits: [IncrementalEdit]
+  public let edits: [SourceEdit]
 
   /// Initialize this struct from edits that are already in a concurrent form
   /// and are guaranteed to satisfy the requirements posed above.
-  public init(concurrent: [IncrementalEdit]) throws {
+  public init(concurrent: [SourceEdit]) throws {
     if !Self.isValidConcurrentEditArray(concurrent) {
       throw ConcurrentEditsError.editsNotConcurrent
     }
@@ -323,7 +323,7 @@ public struct ConcurrentEdits: Sendable {
   ///  - insert 'z' at offset 2
   ///  to '012345' results in 'xyz012345'.
 
-  public init(fromSequential sequentialEdits: [IncrementalEdit]) {
+  public init(fromSequential sequentialEdits: [SourceEdit]) {
     do {
       try self.init(concurrent: Self.translateSequentialEditsToConcurrentEdits(sequentialEdits))
     } catch {
@@ -336,7 +336,7 @@ public struct ConcurrentEdits: Sendable {
   /// Construct a concurrent edits struct from a single edit. For a single edit,
   /// there is no differentiation between being it being applied concurrently
   /// or sequentially.
-  public init(_ single: IncrementalEdit) {
+  public init(_ single: SourceEdit) {
     do {
       try self.init(concurrent: [single])
     } catch {
@@ -345,29 +345,31 @@ public struct ConcurrentEdits: Sendable {
   }
 
   private static func translateSequentialEditsToConcurrentEdits(
-    _ edits: [IncrementalEdit]
-  ) -> [IncrementalEdit] {
-    var concurrentEdits: [IncrementalEdit] = []
+    _ edits: [SourceEdit]
+  ) -> [SourceEdit] {
+    var concurrentEdits: [SourceEdit] = []
     for editToAdd in edits {
       var editToAdd = editToAdd
       var editIndicesMergedWithNewEdit: [Int] = []
       for (index, existingEdit) in concurrentEdits.enumerated() {
-        if existingEdit.replacementRange.intersectsOrTouches(editToAdd.range) {
-          let intersectionLength =
-            existingEdit.replacementRange.intersected(editToAdd.range).length
+        if existingEdit.range.intersectsOrTouches(editToAdd.range),
+          let intersectionLength = existingEdit.range.intersecting(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(
+            existingEdit.replacementBytes.prefix(max(0, editToAdd.offset - existingEdit.replacementRange.offset))
+            + editToAdd.replacementBytes
+            + existingEdit.replacementBytes.suffix(
+              max(0, existingEdit.replacementRange.endOffset - editToAdd.endOffset)
+            )
+          editToAdd = SourceEdit(
             offset: Swift.min(existingEdit.offset, editToAdd.offset),
-            length: existingEdit.length + editToAdd.length - intersectionLength,
+            length: existingEdit.length + editToAdd.length - intersectionLength.utf8Length,
             replacement: replacement
           )
           editIndicesMergedWithNewEdit.append(index)
-        } else if existingEdit.offset < editToAdd.endOffset {
-          editToAdd = IncrementalEdit(
+        } else if existingEdit.range.lowerBound.utf8Offset < editToAdd.range.upperBound.utf8Offset {
+          editToAdd = SourceEdit(
             offset: editToAdd.offset - existingEdit.replacementLength + existingEdit.length,
             length: editToAdd.length,
             replacement: editToAdd.replacement
@@ -380,15 +382,15 @@ public struct ConcurrentEdits: Sendable {
       }
       let insertPos =
         concurrentEdits.firstIndex(where: { edit in
-          editToAdd.endOffset <= edit.offset
+          editToAdd.range.upperBound.utf8Offset <= edit.range.lowerBound.utf8Offset
         }) ?? concurrentEdits.count
       concurrentEdits.insert(editToAdd, at: insertPos)
       precondition(ConcurrentEdits.isValidConcurrentEditArray(concurrentEdits))
     }
     return concurrentEdits
   }
 
-  private static func isValidConcurrentEditArray(_ edits: [IncrementalEdit]) -> Bool {
+  private static func isValidConcurrentEditArray(_ edits: [SourceEdit]) -> Bool {
     // Not quite sure if we should disallow creating an `IncrementalParseTransition`
     // object without edits but there doesn't seem to be much benefit if we do,
     // and there are 'lit' tests that want to test incremental re-parsing without edits.
@@ -397,7 +399,7 @@ public struct ConcurrentEdits: Sendable {
     for i in 1..<edits.count {
       let prevEdit = edits[i - 1]
       let curEdit = edits[i]
-      if curEdit.range.offset < prevEdit.range.endOffset {
+      if curEdit.range.lowerBound.utf8Offset < prevEdit.range.upperBound.utf8Offset {
         return false
       }
       if curEdit.intersectsRange(prevEdit.range) {
@@ -408,7 +410,7 @@ public struct ConcurrentEdits: Sendable {
   }
 
   /// **Public for testing purposes only**
-  public static func _isValidConcurrentEditArray(_ edits: [IncrementalEdit]) -> Bool {
+  public static func _isValidConcurrentEditArray(_ edits: [SourceEdit]) -> Bool {
     return isValidConcurrentEditArray(edits)
   }
 }

Sources/SwiftSyntax/SourceEdit.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2024 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
@@ -13,22 +13,74 @@
 /// A textual edit to the original source represented by a range and a
 /// replacement.
 public struct SourceEdit: Equatable, Sendable {
-  /// The half-open range that this edit applies to.
+  /// The byte range of the original source buffer that the edit applies to.
   public let range: Range<AbsolutePosition>
-  /// The text to replace the original range with. Empty for a deletion.
-  public let replacement: String
 
-  /// Length of the original source range that this edit applies to. Zero if
-  /// this is an addition.
-  public var length: SourceLength {
-    return SourceLength(utf8Length: range.upperBound.utf8Offset - range.lowerBound.utf8Offset)
+  /// The UTF-8 bytes that should be inserted as part of the edit
+  public let replacementBytes: [UInt8]
+
+  /// A string representation of the replacement
+  public var replacement: String { return String(decoding: replacementBytes, as: UTF8.self) }
+
+  /// The length of the edit replacement in UTF8 bytes.
+  public var replacementLength: Int { replacement.utf8.count }
+
+  @available(*, deprecated, message: "Use range instead")
+  public var offset: Int { return range.lowerBound.utf8Offset }
+
+  @available(*, deprecated, message: "Use replacementLength instead")
+  public var length: Int { return range.upperBound.utf8Offset - range.lowerBound.utf8Offset }
+
+  @available(*, deprecated, message: "Use range instead")
+  public var endOffset: Int { return range.upperBound.utf8Offset }
+
+  /// After the edit has been applied the range of the replacement text.
+  @available(*, deprecated, message: "Use range instead")
+  public var replacementRange: ByteSourceRange {
+    return ByteSourceRange(
+      offset: range.lowerBound.utf8Offset,
+      length: range.upperBound.utf8Offset - range.lowerBound.utf8Offset
+    )
+  }
+
+  @available(*, deprecated, message: "Use SourceEdit(range:replacement:) instead")
+  public init(range: ByteSourceRange, replacementLength: Int) {
+    self.range = AbsolutePosition(utf8Offset: range.offset)..<AbsolutePosition(utf8Offset: range.endOffset)
+    self.replacementBytes = Array(repeating: UInt8(ascii: " "), count: replacementLength)
+  }
+
+  @available(*, deprecated, message: "Use SourceEdit(range:replacement:) instead")
+  public init(offset: Int, length: Int, replacementLength: Int) {
+    self.range = AbsolutePosition(utf8Offset: offset)..<AbsolutePosition(utf8Offset: offset + length)
+    self.replacementBytes = Array(repeating: UInt8(ascii: " "), count: replacementLength)
   }
 
   /// Create an edit to replace `range` in the original source with
   /// `replacement`.
   public init(range: Range<AbsolutePosition>, replacement: String) {
     self.range = range
-    self.replacement = replacement
+    self.replacementBytes = Array(replacement.utf8)
+  }
+
+  @available(*, deprecated, message: "Use SourceEdit(range:replacement:) instead")
+  public init(offset: Int, length: Int, replacement: [UInt8]) {
+    self.range = AbsolutePosition(utf8Offset: offset)..<AbsolutePosition(utf8Offset: offset + length)
+    self.replacementBytes = replacement
+  }
+
+  @available(*, deprecated, message: "Use SourceEdit(range:replacement:) instead")
+  public init(offset: Int, length: Int, replacement: String) {
+    self.init(offset: offset, length: length, replacement: Array(replacement.utf8))
+  }
+
+  public func intersectsOrTouchesRange(_ other: Range<AbsolutePosition>) -> Bool {
+    return self.range.upperBound.utf8Offset >= other.lowerBound.utf8Offset
+      && self.range.lowerBound.utf8Offset <= other.upperBound.utf8Offset
+  }
+
+  public func intersectsRange(_ other: Range<AbsolutePosition>) -> Bool {
+    return self.range.upperBound.utf8Offset > other.lowerBound.utf8Offset
+      && self.range.lowerBound.utf8Offset < other.upperBound.utf8Offset
   }
 
   /// Convenience function to create a textual addition after the given node

Sources/SwiftSyntax/Utils.swift

@@ -47,57 +47,42 @@ 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
+extension Range<AbsolutePosition> {
+  /// The number of bytes between the range's lower bound and its upper bound
+  public var length: SourceLength { return SourceLength(utf8Length: upperBound.utf8Offset - lowerBound.utf8Offset) }
 
-  /// 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 var replacementLength: Int { replacement.count }
-
-  public var offset: Int { return range.offset }
-
-  public var length: Int { return range.length }
-
-  public var endOffset: Int { return range.endOffset }
-
-  /// After the edit has been applied the range of the replacement text.
-  public var replacementRange: ByteSourceRange {
-    return ByteSourceRange(offset: offset, length: replacementLength)
-  }
-
-  @available(*, deprecated, message: "Use IncrementalEdit(range:replacement:) instead")
-  public init(range: ByteSourceRange, replacementLength: Int) {
-    self.range = range
-    self.replacement = Array(repeating: UInt8(ascii: " "), count: replacementLength)
+  public init(position: AbsolutePosition, length: SourceLength) {
+    self = position..<(position + length)
   }
 
-  @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.replacement = Array(repeating: UInt8(ascii: " "), count: replacementLength)
+  /// Returns `true` if the intersection between this range and `other` is non-empty or if the two ranges are directly
+  /// adjacent to each other.
+  public func intersectsOrTouches(_ other: Range<AbsolutePosition>) -> Bool {
+    return self.upperBound >= other.lowerBound && self.lowerBound <= other.upperBound
   }
 
-  public init(offset: Int, length: Int, replacement: [UInt8]) {
-    self.range = ByteSourceRange(offset: offset, length: length)
-    self.replacement = replacement
+  /// Returns `true` if the intersection between this range and `other` is non-empty.
+  public func intersects(_ other: Range<AbsolutePosition>) -> Bool {
+    return self.upperBound > other.lowerBound && self.lowerBound < other.upperBound
   }
 
-  public init(offset: Int, length: Int, replacement: String) {
-    self.init(offset: offset, length: length, replacement: Array(replacement.utf8))
-  }
-
-  public func intersectsOrTouchesRange(_ other: ByteSourceRange) -> Bool {
-    return self.range.intersectsOrTouches(other)
-  }
-
-  public func intersectsRange(_ other: ByteSourceRange) -> Bool {
-    return self.range.intersects(other)
+  /// Returns the range for the overlapping region between two ranges.
+  ///
+  /// If the intersection is empty, this returns `nil`.
+  public func intersecting(_ other: Range<AbsolutePosition>) -> Range<AbsolutePosition>? {
+    let lowerBound = Swift.max(self.lowerBound, other.lowerBound)
+    let upperBound = Swift.min(self.upperBound, other.upperBound)
+    if lowerBound > upperBound {
+      return nil
+    } else {
+      return lowerBound..<upperBound
+    }
   }
 }
 
+@available(*, deprecated, renamed: "SourceEdit")
+public typealias IncrementalEdit = SourceEdit
+
 extension RawUnexpectedNodesSyntax {
   /// Construct a ``RawUnexpectedNodesSyntax``with the given `elements`.
   ///

Sources/_SwiftSyntaxTestSupport/IncrementalParseTestUtils.swift

@@ -176,7 +176,7 @@ public func extractEditsAndSources(
 ) -> (edits: ConcurrentEdits, originalSource: Substring, editedSource: Substring) {
   var editedSource = Substring()
   var originalSource = Substring()
-  var concurrentEdits: [IncrementalEdit] = []
+  var concurrentEdits: [SourceEdit] = []
 
   var lastStartIndex = source.startIndex
   while let startIndex = source[lastStartIndex...].firstIndex(where: { $0 == "⏩️" }),
@@ -185,7 +185,7 @@ public func extractEditsAndSources(
   {
 
     originalSource += source[lastStartIndex..<startIndex]
-    let edit = IncrementalEdit(
+    let edit = SourceEdit(
       offset: originalSource.utf8.count,
       length: source.utf8.distance(
         from: source.index(after: startIndex),
@@ -219,7 +219,7 @@ public func extractEditsAndSources(
 /// `concurrent` specifies whether the edits should be interpreted as being
 /// applied sequentially or concurrently.
 public func applyEdits(
-  _ edits: [IncrementalEdit],
+  _ edits: [SourceEdit],
   concurrent: Bool,
   to testString: String
 ) -> String {
@@ -236,7 +236,7 @@ public func applyEdits(
   for edit in edits {
     assert(edit.endOffset <= bytes.count)
     bytes.removeSubrange(edit.offset..<edit.endOffset)
-    bytes.insert(contentsOf: edit.replacement, at: edit.offset)
+    bytes.insert(contentsOf: edit.replacementBytes, at: edit.offset)
   }
   return String(bytes: bytes, encoding: .utf8)!
 }