Rename the incremental source edit to IncrementalEdit

This was called `SourceEdit`, which would be nice to reserve for
refactorings rather than incremental parsing. Ideally we'd also move all
the incremental parsing types into `SwiftParser` as well.

(cherry picked from commit 40f2954)

Author: bnbarham

Sources/SwiftSyntax/IncrementalParseTransition.swift

@@ -97,11 +97,11 @@ public struct ConcurrentEdits {
 
   /// The raw concurrent edits. Are guaranteed to satisfy the requirements
   /// stated above.
-  public let edits: [SourceEdit]
+  public let edits: [IncrementalEdit]
 
   /// Initialize this struct from edits that are already in a concurrent form
   /// and are guaranteed to satisfy the requirements posed above.
-  public init(concurrent: [SourceEdit]) throws {
+  public init(concurrent: [IncrementalEdit]) throws {
     if !Self.isValidConcurrentEditArray(concurrent) {
       throw ConcurrentEditsError.editsNotConcurrent
     }
@@ -117,7 +117,7 @@ public struct ConcurrentEdits {
   ///  - insert 'z' at offset 2
   ///  to '012345' results in 'xyz012345'.
 
-  public init(fromSequential sequentialEdits: [SourceEdit]) {
+  public init(fromSequential sequentialEdits: [IncrementalEdit]) {
     do {
       try self.init(concurrent: Self.translateSequentialEditsToConcurrentEdits(sequentialEdits))
     } catch {
@@ -128,7 +128,7 @@ public struct ConcurrentEdits {
   /// 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: SourceEdit) {
+  public init(_ single: IncrementalEdit) {
     do {
       try self.init(concurrent: [single])
     } catch {
@@ -137,24 +137,24 @@ public struct ConcurrentEdits {
   }
 
   private static func translateSequentialEditsToConcurrentEdits(
-    _ edits: [SourceEdit]
-  ) -> [SourceEdit] {
-    var concurrentEdits: [SourceEdit] = []
+    _ edits: [IncrementalEdit]
+  ) -> [IncrementalEdit] {
+    var concurrentEdits: [IncrementalEdit] = []
     for editToAdd in edits {
       var editToAdd = editToAdd
       var editIndiciesMergedWithNewEdit: [Int] = []
       for (index, existingEdit) in concurrentEdits.enumerated() {
         if existingEdit.replacementRange.intersectsOrTouches(editToAdd.range) {
           let intersectionLength =
             existingEdit.replacementRange.intersected(editToAdd.range).length
-          editToAdd = SourceEdit(
+          editToAdd = IncrementalEdit(
             offset: Swift.min(existingEdit.offset, editToAdd.offset),
             length: existingEdit.length + editToAdd.length - intersectionLength,
             replacementLength: existingEdit.replacementLength + editToAdd.replacementLength - intersectionLength
           )
           editIndiciesMergedWithNewEdit.append(index)
         } else if existingEdit.offset < editToAdd.endOffset {
-          editToAdd = SourceEdit(
+          editToAdd = IncrementalEdit(
             offset: editToAdd.offset - existingEdit.replacementLength + existingEdit.length,
             length: editToAdd.length,
             replacementLength: editToAdd.replacementLength
@@ -175,7 +175,7 @@ public struct ConcurrentEdits {
     return concurrentEdits
   }
 
-  private static func isValidConcurrentEditArray(_ edits: [SourceEdit]) -> Bool {
+  private static func isValidConcurrentEditArray(_ edits: [IncrementalEdit]) -> 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.
@@ -195,7 +195,7 @@ public struct ConcurrentEdits {
   }
 
   /// **Public for testing purposes only**
-  public static func _isValidConcurrentEditArray(_ edits: [SourceEdit]) -> Bool {
+  public static func _isValidConcurrentEditArray(_ edits: [IncrementalEdit]) -> Bool {
     return isValidConcurrentEditArray(edits)
   }
 }

Sources/SwiftSyntax/Utils.swift

@@ -47,7 +47,7 @@ public struct ByteSourceRange: Equatable {
   }
 }
 
-public struct SourceEdit: Equatable {
+public struct IncrementalEdit: Equatable {
   /// The byte range of the original source buffer that the edit applies to.
   public let range: ByteSourceRange
   /// The length of the edit replacement in UTF8 bytes.

Sources/_SwiftSyntaxTestSupport/IncrementalParseTestUtils.swift

@@ -135,3 +135,83 @@ public struct ReusedNodeSpec {
     self.line = line
   }
 }
+
+/// Get `ConcurrentEdits` in source whose edited zones are marked with markers
+/// Also extract the markers from source to get original source and edited source
+///
+/// `⏩️` is  *start marker*, `⏸️` is *separate marker*, `⏪️` is *end marker*
+/// Contents between `⏩️` and `⏸️` are source text that before modification, contents
+/// betwwen `⏸️` and `⏪️` are source text that after modification
+/// i.e. `⏩️foo⏸️bar⏪️`, the original source is `foo` and the edited source is `bar`
+public func getEditsAndSources(_ source: String) -> (edits: ConcurrentEdits, orignialSource: Substring, editedSource: Substring) {
+  var editedSource = Substring()
+  var originalSource = Substring()
+  var concurrentEdits: [IncrementalEdit] = []
+
+  var lastStartIndex = source.startIndex
+  while let startIndex = source[lastStartIndex...].firstIndex(where: { $0 == "⏩️" }),
+    let separateIndex = source[startIndex...].firstIndex(where: { $0 == "⏸️" }),
+    let endIndex = source[separateIndex...].firstIndex(where: { $0 == "⏪️" })
+  {
+
+    originalSource += source[lastStartIndex..<startIndex]
+    let edit = IncrementalEdit(
+      offset: originalSource.utf8.count,
+      length: source.utf8.distance(
+        from: source.index(after: startIndex),
+        to: separateIndex
+      ),
+      replacementLength: source.utf8.distance(
+        from: source.index(after: separateIndex),
+        to: endIndex
+      )
+    )
+    originalSource += source[source.index(after: startIndex)..<separateIndex]
+
+    editedSource += source[lastStartIndex..<startIndex] + source[source.index(after: separateIndex)..<endIndex]
+
+    concurrentEdits.append(edit)
+
+    lastStartIndex = source.index(after: endIndex)
+  }
+
+  editedSource += source[lastStartIndex...]
+  originalSource += source[lastStartIndex...]
+
+  do {
+    let edits = try ConcurrentEdits(concurrent: concurrentEdits)
+    return (edits, originalSource, editedSource)
+  } catch {
+    fatalError("ConcurrentEdits created by the test case do not satisfy ConcurrentEdits requirements, please check the test setup")
+  }
+}
+
+/// Apply the given edits to `testString` and return the resulting string.
+/// `concurrent` specifies whether the edits should be interpreted as being
+/// applied sequentially or concurrently.
+public func applyEdits(
+  _ edits: [IncrementalEdit],
+  concurrent: Bool,
+  to testString: String,
+  replacementChar: Character = "?"
+) -> String {
+  guard let replacementAscii = replacementChar.asciiValue else {
+    fatalError("replacementChar must be an ASCII character")
+  }
+  var edits = edits
+  if concurrent {
+    XCTAssert(ConcurrentEdits._isValidConcurrentEditArray(edits))
+
+    // If the edits are concurrent, sorted and not overlapping (as guaranteed by
+    // the check above, we can apply them sequentially to the string in reverse
+    // order because later edits don't affect earlier edits.
+    edits = edits.reversed()
+  }
+  var bytes = Array(testString.utf8)
+  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)
+  }
+  return String(bytes: bytes, encoding: .utf8)!
+}

Sources/_SwiftSyntaxTestSupport/SourceEditsTestUtils.swift

@@ -89,11 +89,11 @@ func printHelp() {
 }
 
 extension CommandLineArguments {
-  func getIncrementalEdits() throws -> [IncrementalEdit] {
+  func getIncrementalEdits() throws -> [IncrementalEditSpec] {
     let regex = try NSRegularExpression(
       pattern: "([0-9]+):([0-9]+)-([0-9]+):([0-9]+)=(.*)"
     )
-    var parsedEdits = [IncrementalEdit]()
+    var parsedEdits = [IncrementalEditSpec]()
     let editArgs = try self.getValues("-incremental-edit")
     for edit in editArgs {
       guard
@@ -111,7 +111,7 @@ extension CommandLineArguments {
       let region = getSourceRegion(match, text: edit)
       let replacement = match.match(at: 5, text: edit)
       parsedEdits.append(
-        IncrementalEdit(
+        IncrementalEditSpec(
           region: region,
           replacement: replacement
         )
@@ -232,7 +232,7 @@ struct SourceRegion {
   let endColumn: Int
 }
 
-struct IncrementalEdit {
+struct IncrementalEditSpec {
   let region: SourceRegion
   let replacement: String
 }
@@ -312,8 +312,8 @@ func getByteRange(
 
 func parseIncrementalEditArguments(
   args: CommandLineArguments
-) throws -> [SourceEdit] {
-  var edits = [SourceEdit]()
+) throws -> [IncrementalEdit] {
+  var edits = [IncrementalEdit]()
   let argEdits = try args.getIncrementalEdits()
   let preEditURL =
     URL(fileURLWithPath: try args.getRequired("-old-source-file"))
@@ -326,7 +326,7 @@ func parseIncrementalEditArguments(
       argName: "-incremental-edit"
     )
     let replacementLength = argEdit.replacement.utf8.count
-    edits.append(SourceEdit(range: range, replacementLength: replacementLength))
+    edits.append(IncrementalEdit(range: range, replacementLength: replacementLength))
   }
   return edits
 }