Add helper function for getting the ConcurrentEdits of two strings

Get rid of utils/incrparse

Author: StevenWong12

Tests/SwiftParserTest/IncrementalParsingTests.swift

@@ -14,33 +14,108 @@ import XCTest
 import SwiftSyntax
 import SwiftParser
 
+/// Returns the `ConcurrentEdits`s to transition from `base` to `new`.
+func getConcurrentEdits(from base: String, to new: String) -> ConcurrentEdits {
+  let diffCollection = new.difference(from: base)
+
+  let diffArray: [(offset: Int, isInsert: Bool)] =
+    diffCollection
+    .map { diff in
+      switch diff {
+      case .remove(offset: let offset, element: _, associatedWith: _):
+        return (offset, false)
+      case .insert(offset: let offset, element: _, associatedWith: _):
+        return (offset, true)
+      }
+    }
+    .sorted {
+      // Change.remove should prior to Change.insert
+      if $0.0 < $1.0 {
+        return true
+      } else if $0.0 == $1.0 {
+        return !$0.1
+      } else {
+        return false
+      }
+    }
+
+  let sourceEdits = diffArray.map({
+    return $0.1 ? SourceEdit(offset: $0.0, length: 0, replacementLength: 1) : SourceEdit(offset: $0.0, length: 1, replacementLength: 0)
+  })
+
+  return ConcurrentEdits(fromSequential: sourceEdits)
+}
+
 public class IncrementalParsingTests: XCTestCase {
 
+  public func testDiffOfTwoStringsSimple() throws {
+    let s1 = "struct A { func f() {"
+    let s2 = "struct AA { func f() {"
+
+    let diffs = getConcurrentEdits(from: s1, to: s2)
+    XCTAssertEqual(diffs.edits.count, 1)
+
+    let firstDiff = try XCTUnwrap(diffs.edits.first)
+    XCTAssertEqual(firstDiff, SourceEdit(offset: 8, length: 0, replacementLength: 1))
+  }
+
+  public func testDiffOfTwoSameStrings() {
+    let s1 = "0123456"
+    let s2 = "0123456"
+
+    let diffs = getConcurrentEdits(from: s1, to: s2)
+    XCTAssert(diffs.edits.isEmpty)
+  }
+
+  public func testDiffOfTwoStrings() {
+    let s1 = "0123456"
+    let s2 = "x12456yz"
+
+    let diffs = getConcurrentEdits(from: s1, to: s2)
+
+    let expectedDiffs: [SourceEdit] = [
+      SourceEdit(offset: 0, length: 1, replacementLength: 1),
+      SourceEdit(offset: 3, length: 1, replacementLength: 0),
+      SourceEdit(offset: 7, length: 0, replacementLength: 2),
+    ]
+
+    XCTAssertEqual(diffs.edits, expectedDiffs)
+  }
+
   public func testIncrementalInvalid() {
     let original = "struct A { func f() {"
-    let step: (String, (Int, Int, String)) =
-      ("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 lookup = IncrementalParseTransition(previousTree: tree, edits: ConcurrentEdits(sourceEdit))
-    tree = Parser.parse(source: step.0, parseTransition: lookup)
-    XCTAssertEqual("\(tree)", step.0)
+    let newSource = "struct AA { func f() {"
+
+    let concurrentEdits = getConcurrentEdits(from: original, to: newSource)
+
+    let oldTree = Parser.parse(source: original)
+    let lookup = IncrementalParseTransition(previousTree: oldTree, edits: concurrentEdits)
+    let newTree = Parser.parse(source: newSource, parseTransition: lookup)
+
+    XCTAssertEqual("\(newTree)", "\(newSource)")
   }
 
   public func testReusedNode() throws {
     try XCTSkipIf(true, "Swift parser does not handle node reuse yet")
 
-    let original = "struct A {}\nstruct B {}\n"
-    let step: (String, (Int, Int, String)) =
-      ("struct AA {}\nstruct B {}\n", (8, 0, "A"))
+    let original =
+      """
+      struct A {}
+      struct B {}
+      """
+
+    let newSource =
+      """
+      struct A {}
+      struct B {}
+      """
 
     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 concurrentEdits = getConcurrentEdits(from: original, to: newSource)
     let reusedNodeCollector = IncrementalParseReusedNodeCollector()
-    let transition = IncrementalParseTransition(previousTree: origTree, edits: ConcurrentEdits(sourceEdit), reusedNodeDelegate: reusedNodeCollector)
-    let newTree = Parser.parse(source: step.0, parseTransition: transition)
-    XCTAssertEqual("\(newTree)", step.0)
+    let transition = IncrementalParseTransition(previousTree: origTree, edits: concurrentEdits, reusedNodeDelegate: reusedNodeCollector)
+    let newTree = Parser.parse(source: newSource, parseTransition: transition)
+    XCTAssertEqual("\(newTree)", "\(newSource)")
 
     let origStructB = origTree.statements[1]
     let newStructB = newTree.statements[1]