Merge pull request swiftlang#85 from akyrtzi/parse-transition-simplify

[IncrementalParseTransition] Simplify implementation of IncrementalParseTransition

Author: akyrtzi

Sources/SwiftSyntax/IncrementalParseTransition.swift

@@ -104,48 +104,35 @@ public final class IncrementalParseTransition {
     guard let prevOffset = translateToPreEditOffset(newOffset) else {
       return nil
     }
-    let (nodeOffset, node) = lookUpFrom(previousTree, nodeOffset: 0,
-                                        prevOffset: prevOffset, kind: kind)
+    let prevPosition = AbsolutePosition(utf8Offset: prevOffset)
+    let node = lookUpFrom(previousTree, prevPosition: prevPosition, kind: kind)
     if let delegate = reusedDelegate, let node = node {
       delegate.parserReusedNode(
-        range: ByteSourceRange(offset: nodeOffset, length: node.byteSize),
+        range: ByteSourceRange(offset: newOffset, length: node.byteSize),
         previousNode: node)
     }
     return node
   }
 
-  fileprivate func lookUpFrom(_ node: _SyntaxBase, nodeOffset: Int, prevOffset: Int,
-                              kind: SyntaxKind) -> (Int, _SyntaxBase?) {
-    if nodeCanBeReused(node, nodeOffset: nodeOffset, prevOffset: prevOffset,
-                       kind: kind) {
-      return (nodeOffset, node)
+  fileprivate func lookUpFrom(
+    _ node: _SyntaxBase, prevPosition: AbsolutePosition, kind: SyntaxKind
+  ) -> _SyntaxBase? {
+    if nodeCanBeReused(node, prevPosition: prevPosition, kind: kind) {
+      return node
     }
 
-    // Compute the child's position on the fly
-    var childOffset = nodeOffset
     for child in node.children {
-      if child.isMissing {
-        continue
+      if child.position <= prevPosition && prevPosition < child.endPosition {
+        return lookUpFrom(child, prevPosition: prevPosition, kind: kind)
       }
-      let childEnd = childOffset + child.byteSize
-      if childOffset <= prevOffset && prevOffset < childEnd {
-        return lookUpFrom(child, nodeOffset: childOffset,
-                          prevOffset: prevOffset, kind: kind)
-      }
-      // The next child starts where the previous child ended
-      childOffset = childEnd
     }
-    return (0, nil)
+    return nil
   }
 
-  fileprivate func nodeCanBeReused(_ node: _SyntaxBase, nodeOffset: Int,
-                                   prevOffset: Int, kind: SyntaxKind) -> Bool {
-    // Computing the value of NodeStart on the fly is faster than determining a
-    // node's absolute position, but make sure the values match in an assertion
-    // build
-    assert(nodeOffset == node.position.utf8Offset);
-
-    if nodeOffset != prevOffset {
+  fileprivate func nodeCanBeReused(
+    _ node: _SyntaxBase, prevPosition: AbsolutePosition, kind: SyntaxKind
+  ) -> Bool {
+    if node.position != prevPosition {
       return false
     }
     if node.raw.kind != kind {
@@ -158,17 +145,20 @@ public final class IncrementalParseTransition {
     // CodeBlockItems one for `private` and one for `struc Foo {}`
     var nextLeafNodeLength = 0
     if let nextToken = node.nextToken {
-      let nextRawNode = nextToken.raw
-      assert(nextRawNode.isPresent)
-      nextLeafNodeLength += nextRawNode.contentLength.utf8Length
-      nextLeafNodeLength += nextRawNode.leadingTriviaLength.utf8Length
+      assert(nextToken.isPresent)
+      nextLeafNodeLength = nextToken.byteSize - nextToken.trailingTriviaLength.utf8Length
     }
 
     for edit in edits {
       // Check if this node or the trivia of the next node has been edited. If
       // it has, we cannot reuse it.
-      if edit.intersectsOrTouchesRange(ByteSourceRange(offset: nodeOffset,
-                                  length: node.byteSize + nextLeafNodeLength)) {
+      let nodeAffectRange = ByteSourceRange(offset: node.position.utf8Offset,
+        length: node.byteSize + nextLeafNodeLength)
+      if edit.range.offset > nodeAffectRange.endOffset {
+        // Remaining edits don't affect the node. (Edits are sorted)
+        break
+      }
+      if edit.intersectsOrTouchesRange(nodeAffectRange) {
         return false
       }
     }

Sources/SwiftSyntax/Syntax.swift

@@ -185,6 +185,11 @@ extension _SyntaxBase {
     return totalLength.utf8Length
   }
 
+  /// The byte source range of this node including leading and trailing trivia.
+  var byteRange: ByteSourceRange {
+    return ByteSourceRange(offset: position.utf8Offset, length: byteSize)
+  }
+
   /// The length this node takes up spelled out in the source, excluding its
   /// leading or trailing trivia.
   var contentLength: SourceLength {
@@ -398,6 +403,11 @@ extension Syntax {
     return base.byteSize
   }
 
+  /// The byte source range of this node including leading and trailing trivia.
+  public var byteRange: ByteSourceRange {
+    return base.byteRange
+  }
+
   /// The length this node takes up spelled out in the source, excluding its
   /// leading or trailing trivia.
   public var contentLength: SourceLength {

Sources/SwiftSyntax/Utils.swift

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-public struct ByteSourceRange {
+public struct ByteSourceRange: Equatable {
   public let offset: Int
   public let length: Int
 

Tests/SwiftSyntaxTest/IncrementalParsingTests.swift

@@ -5,6 +5,7 @@ public class IncrementalParsingTestCase: XCTestCase {
 
   public static let allTests = [
     ("testIncrementalInvalid", testIncrementalInvalid),
+    ("testReusedNode", testReusedNode),
   ]
 
   public func testIncrementalInvalid() {
@@ -18,4 +19,31 @@ public class IncrementalParsingTestCase: XCTestCase {
     tree = try! SyntaxParser.parse(source: step.0, parseTransition: lookup)
     XCTAssertEqual("\(tree)", step.0)
   }
+
+  public func testReusedNode() {
+    let original = "struct A {}\nstruct B {}\n"
+    let step: (String, (Int, Int, String)) =
+      ("struct AA {}\nstruct B {}\n", (8, 0, "A"))
+
+    let origTree = try! SyntaxParser.parse(source: original)
+    let sourceEdit = SourceEdit(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: [sourceEdit], reusedNodeDelegate: reusedNodeCollector)
+    let newTree = try! SyntaxParser.parse(source: step.0, parseTransition: transition)
+    XCTAssertEqual("\(newTree)", step.0)
+
+    let origStructB = origTree.statements[1] as! CodeBlockItemSyntax
+    let newStructB = newTree.statements[1] as! CodeBlockItemSyntax
+    XCTAssertEqual("\(origStructB)", "\nstruct B {}")
+    XCTAssertEqual("\(newStructB)", "\nstruct B {}")
+    XCTAssertNotEqual(origStructB, newStructB)
+
+    XCTAssertEqual(reusedNodeCollector.rangeAndNodes.count, 1)
+    if reusedNodeCollector.rangeAndNodes.count != 1 { return }
+    let rangeAndNode = reusedNodeCollector.rangeAndNodes[0]
+    XCTAssertEqual("\(rangeAndNode.1)", "\nstruct B {}")
+
+    XCTAssertEqual(newStructB.byteRange, rangeAndNode.0)
+    XCTAssertEqual(origStructB, rangeAndNode.1 as! CodeBlockItemSyntax)
+  }
 }