Add utils for incremental parse test

Author: StevenWong12

Sources/_SwiftSyntaxTestSupport/IncrementalParseTestUtils.swift

@@ -0,0 +1,110 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+import SwiftParser
+import XCTest
+
+/// This function is used to verify the correctness of incremental parsing
+/// containing three parts:
+/// 1. Round-trip on the incrementally parsed syntax tree.
+/// 2. verify that incrementally parsing the edited source base on the original source produces the same syntax tree as reparsing the post-edit file from scratch.
+/// 3. verify the reused nodes fall into expectations.
+public func assertIncrementalParse(
+  _ source: String,
+  reusedNodes expectedReusedNodes: [ReusedNodeSpec] = [],
+  file: StaticString = #file,
+  line: UInt = #line
+) {
+  let (concurrentEdits, originalSource, editedSource) = getEditsAndSources(source)
+  
+  let originalString = String(originalSource)
+  let editedString = String(editedSource)
+  
+  let originalTree = Parser.parse(source: originalString)
+
+  let reusedNodesCollector = IncrementalParseReusedNodeCollector()
+  let transition = IncrementalParseTransition(previousTree: originalTree, edits: concurrentEdits, reusedNodeDelegate: reusedNodesCollector)
+
+  let newTree = Parser.parse(source: String(editedSource))
+  let incrementallyParsedNewTree = Parser.parse(source: editedString, parseTransition: transition)
+
+  // Round-trip
+  assertStringsEqualWithDiff(
+    editedString,
+    "\(incrementallyParsedNewTree)",
+    additionalInfo: """
+      Source failed to round-trip when parsing incrementally
+      
+      Actual syntax tree:
+      \(incrementallyParsedNewTree.debugDescription)
+      """,
+    file: file,
+    line: line
+  )
+
+  // Substructure
+  let subtreeMatcher = SubtreeMatcher(Syntax(incrementallyParsedNewTree), markers: [:])
+  do {
+    try subtreeMatcher.assertSameStructure(Syntax(newTree), includeTrivia: true)
+  } catch {
+    XCTFail("Matching for a subtree failed with error: \(error)")
+  }
+
+  // Re-used nodes
+  // The range of node should ignore Trivia
+  XCTAssertEqual(reusedNodesCollector.rangeAndNodes.count, expectedReusedNodes.count)
+  
+  for targetNode in expectedReusedNodes {
+    guard let range = getByteSourceRange(for: targetNode.sourceString, in: originalString) else {
+      XCTFail("Fail to find \(targetNode.sourceString) in \(originalString), please check test setting.")
+      return
+    }
+    
+    guard let reusedNode = reusedNodesCollector.rangeAndNodes.first(where: { $0.0 == range })?.1 else {
+      XCTFail(
+        """
+        Fail to find \(targetNode.sourceString) in:
+        \(reusedNodesCollector.rangeAndNodes.map({"\($0.0): \($0.1.description)"}).joined(separator: "\n"))
+        """
+      )
+      return
+    }
+    
+    XCTAssertEqual(targetNode.kind, reusedNode.kind)
+  }
+}
+
+private func getByteSourceRange(for subString: String, in sourceString: String) -> ByteSourceRange? {
+  
+  if let range = sourceString.range(of: subString) {
+    
+    return ByteSourceRange(
+      offset: sourceString.utf8.distance(from: sourceString.startIndex, to: range.lowerBound),
+      length: sourceString.utf8.distance(from: range.lowerBound, to: range.upperBound))
+  }
+  return nil
+}
+
+public struct ReusedNodeSpec {
+  public let sourceString: String
+  
+  public let kind: SyntaxKind
+  
+  public init(
+    sourceString: String,
+    kind: SyntaxKind
+  ) {
+    self.sourceString = sourceString
+    self.kind = kind
+  }
+}

Tests/SwiftParserTest/IncrementalParsingTests.swift

@@ -19,16 +19,8 @@ public class IncrementalParsingTests: XCTestCase {
 
   public func testIncrementalInvalid() {
     let source = "struct A⏩️⏸️A⏪️ { func f() {"
-    let (concurrentEdits, originalSubString, editedSubString) = getEditsAndSources(source)
-
-    let originalSource = String(originalSubString)
-    let editedSource = String(editedSubString)
-
-    var tree = Parser.parse(source: originalSource)
-
-    let lookup = IncrementalParseTransition(previousTree: tree, edits: concurrentEdits)
-    tree = Parser.parse(source: editedSource, parseTransition: lookup)
-    XCTAssertEqual("\(tree)", editedSource)
+    
+    assertIncrementalParse(source)
   }
 
   public func testReusedNode() throws {
@@ -40,33 +32,8 @@ public class IncrementalParsingTests: XCTestCase {
       struct B {}
       """
 
-    let (concurrentEdits, originalSubString, editedSubString) = getEditsAndSources(source)
-
-    let originalSource = String(originalSubString)
-    let editedSource = String(editedSubString)
-
-    let origTree = Parser.parse(source: originalSource)
-    let reusedNodeCollector = IncrementalParseReusedNodeCollector()
-    let transition = IncrementalParseTransition(previousTree: origTree, edits: concurrentEdits, reusedNodeDelegate: reusedNodeCollector)
-    let newTree = Parser.parse(source: editedSource, parseTransition: transition)
-    XCTAssertEqual("\(newTree)", editedSource)
-
-    let origStructB = origTree.statements[1]
-    let newStructB = newTree.statements[1]
-    XCTAssertEqual("\(origStructB)", "\nstruct B {}")
-    XCTAssertEqual("\(newStructB)", "\nstruct B {}")
-    XCTAssertNotEqual(origStructB, newStructB)
-
-    XCTAssertEqual(reusedNodeCollector.rangeAndNodes.count, 1)
-    if reusedNodeCollector.rangeAndNodes.count != 1 { return }
-    let (reusedRange, reusedNode) = reusedNodeCollector.rangeAndNodes[0]
-    XCTAssertEqual("\(reusedNode)", "\nstruct B {}")
-
-    XCTAssertEqual(newStructB.byteRange, reusedRange)
-    XCTAssertEqual(origStructB.id, reusedNode.id)
-    XCTAssertEqual(origStructB, reusedNode.as(CodeBlockItemSyntax.self))
-    XCTAssertTrue(reusedNode.is(CodeBlockItemSyntax.self))
-    XCTAssertEqual(origStructB, reusedNode.as(CodeBlockItemSyntax.self)!)
-    XCTAssertEqual(origStructB.parent!.id, reusedNode.parent!.id)
+    assertIncrementalParse(source, reusedNodes: [
+        ReusedNodeSpec(sourceString: "struct B {}", kind: .codeBlockItem)
+    ])
   }
 }