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.

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/lit-test-helper/main.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
 }

Tests/SwiftParserTest/IncrementalParsingTests.swift

@@ -22,7 +22,7 @@ public class IncrementalParsingTests: XCTestCase {
       ("struct AA { func f() {", (8, 0, "A"))
 
     var tree = Parser.parse(source: original)
-    let sourceEdit = SourceEdit(range: ByteSourceRange(offset: step.1.0, length: step.1.1), replacementLength: step.1.2.utf8.count)
+    let sourceEdit = IncrementalEdit(range: ByteSourceRange(offset: step.1.0, length: step.1.1), replacementLength: step.1.2.utf8.count)
     let lookup = IncrementalParseTransition(previousTree: tree, edits: ConcurrentEdits(sourceEdit))
     tree = Parser.parse(source: step.0, parseTransition: lookup)
     XCTAssertEqual("\(tree)", step.0)
@@ -36,7 +36,7 @@ public class IncrementalParsingTests: XCTestCase {
       ("struct AA {}\nstruct B {}\n", (8, 0, "A"))
 
     let origTree = Parser.parse(source: original)
-    let sourceEdit = SourceEdit(range: ByteSourceRange(offset: step.1.0, length: step.1.1), replacementLength: step.1.2.utf8.count)
+    let sourceEdit = IncrementalEdit(range: ByteSourceRange(offset: step.1.0, length: step.1.1), replacementLength: step.1.2.utf8.count)
     let reusedNodeCollector = IncrementalParseReusedNodeCollector()
     let transition = IncrementalParseTransition(previousTree: origTree, edits: ConcurrentEdits(sourceEdit), reusedNodeDelegate: reusedNodeCollector)
     let newTree = Parser.parse(source: step.0, parseTransition: transition)