Move IncrementalParseTransition.swift to SwiftParser

Also move `SequentialToConcurrentEditTranslationTests.swift` to `SwiftParserTest`

Author: StevenWong12

Sources/SwiftParser/CMakeLists.txt

@@ -13,6 +13,7 @@ add_swift_host_library(SwiftParser
  Declarations.swift
  Directives.swift
  Expressions.swift
+ IncrementalParseTransition.swift
  Lookahead.swift
  LoopProgressCondition.swift
  Modifiers.swift

Sources/SwiftSyntax/IncrementalParseTransition.swift renamed to Sources/SwiftParser/IncrementalParseTransition.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+@_spi(RawSyntax) import SwiftSyntax
 /// Accepts the re-used ``Syntax`` nodes that `IncrementalParseTransition`
 /// determined they should be re-used for a parse invocation.
 ///
@@ -66,140 +67,6 @@ public final class IncrementalParseTransition {
  }
 }
 
-fileprivate extension Sequence where Element: Comparable {
- var isSorted: Bool {
- return zip(self, self.dropFirst()).allSatisfy({ $0.0 < $0.1 })
- }
-}
-
-/// Edits that are applied **simultaneously**. That is, the offsets of all edits
-/// refer to the original string and are not shifted by previous edits. For
-/// example applying
-/// - insert 'x' at offset 0
-/// - insert 'y' at offset 1
-/// - insert 'z' at offset 2
-/// to '012345' results in 'x0y1z2345'.
-///
-/// The raw `edits` of this struct are guaranteed to
-/// 1. not be overlapping.
-/// 2. be in increasing source offset order.
-public struct ConcurrentEdits {
- enum ConcurrentEditsError: Error, CustomStringConvertible {
- case editsNotConcurrent
-
- var description: String {
- switch self {
- case .editsNotConcurrent:
- return "Edits passed to ConcurrentEdits(concurrent:) does not satisfy the requirements posed by ConcurrentEdits"
- }
- }
- }
-
- /// The raw concurrent edits. Are guaranteed to satisfy the requirements
- /// stated above.
- 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: [IncrementalEdit]) throws {
- if !Self.isValidConcurrentEditArray(concurrent) {
- throw ConcurrentEditsError.editsNotConcurrent
- }
- self.edits = concurrent
- }
-
- /// Create concurrent from a set of sequential edits. Sequential edits are
- /// applied one after the other. Applying the first edit results in an
- /// intermediate string to which the second edit is applied etc. For example
- /// applying
- /// - insert 'x' at offset 0
- /// - insert 'y' at offset 1
- /// - insert 'z' at offset 2
- /// to '012345' results in 'xyz012345'.
-
- public init(fromSequential sequentialEdits: [IncrementalEdit]) {
- do {
- try self.init(concurrent: Self.translateSequentialEditsToConcurrentEdits(sequentialEdits))
- } catch {
- fatalError("ConcurrentEdits created by translateSequentialEditsToConcurrentEdits do not satisfy ConcurrentEdits requirements")
- }
- }
-
- /// 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: IncrementalEdit) {
- do {
- try self.init(concurrent: [single])
- } catch {
- fatalError("A single edit doesn't satisfy the ConcurrentEdits requirements?")
- }
- }
-
- private static func translateSequentialEditsToConcurrentEdits(
- _ 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 = 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 = IncrementalEdit(
- offset: editToAdd.offset - existingEdit.replacementLength + existingEdit.length,
- length: editToAdd.length,
- replacementLength: editToAdd.replacementLength
- )
- }
- }
- precondition(editIndiciesMergedWithNewEdit.isSorted)
- for indexToRemove in editIndiciesMergedWithNewEdit.reversed() {
- concurrentEdits.remove(at: indexToRemove)
- }
- let insertPos =
- concurrentEdits.firstIndex(where: { edit in
- editToAdd.endOffset <= edit.offset
- }) ?? concurrentEdits.count
- concurrentEdits.insert(editToAdd, at: insertPos)
- precondition(ConcurrentEdits.isValidConcurrentEditArray(concurrentEdits))
- }
- return concurrentEdits
- }
-
- 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.
- guard !edits.isEmpty else { return true }
-
- for i in 1..<edits.count {
- let prevEdit = edits[i - 1]
- let curEdit = edits[i]
- if curEdit.range.offset < prevEdit.range.endOffset {
- return false
- }
- if curEdit.intersectsRange(prevEdit.range) {
- return false
- }
- }
- return true
- }
-
- /// **Public for testing purposes only**
- public static func _isValidConcurrentEditArray(_ edits: [IncrementalEdit]) -> Bool {
- return isValidConcurrentEditArray(edits)
- }
-}
-
 /// Provides a mechanism for the parser to skip regions of an incrementally
 /// updated source that was already parsed during a previous parse invocation.
 public struct IncrementalParseLookup {
@@ -210,7 +77,7 @@ public struct IncrementalParseLookup {
  /// given ``IncrementalParseTransition``.
  public init(transition: IncrementalParseTransition) {
  self.transition = transition
- self.cursor = .init(root: transition.previousTree.data)
+ self.cursor = .init(root: Syntax(transition.previousTree))
  }
 
  fileprivate var edits: ConcurrentEdits {
@@ -292,13 +159,13 @@ public struct IncrementalParseLookup {
  if !edits.edits.isEmpty && edits.edits.first!.range.offset > nextSibling.endPosition.utf8Offset {
  return true
  }
- if let nextToken = nextSibling.raw.firstToken(viewMode: .sourceAccurate) {
- nextLeafNodeLength = nextToken.raw.totalLength - nextToken.trailingTriviaLength
+ if let nextToken = nextSibling.firstToken(viewMode: .sourceAccurate) {
+ nextLeafNodeLength = nextToken.leadingTriviaLength + nextToken.contentLength
  }
  }
  let nodeAffectRange = ByteSourceRange(
  offset: node.position.utf8Offset,
- length: (node.raw.totalLength + nextLeafNodeLength).utf8Length
+ length: (node.totalLength + nextLeafNodeLength).utf8Length
  )
 
  for edit in edits.edits {
@@ -337,11 +204,11 @@ public struct IncrementalParseLookup {
 /// Functions as an iterator that walks the tree looking for nodes with a
 /// certain position.
 fileprivate struct SyntaxCursor {
- var node: SyntaxData
+ var node: Syntax
  var finished: Bool
  let viewMode = SyntaxTreeViewMode.sourceAccurate
 
- init(root: SyntaxData) {
+ init(root: Syntax) {
  self.node = root
  self.finished = false
  }
@@ -353,11 +220,12 @@ fileprivate struct SyntaxCursor {
  /// Returns the next sibling node or the parent's sibling node if this is
  /// the last child. The cursor state is unmodified.
  /// - Returns: `nil` if it run out of nodes to walk to.
- var nextSibling: SyntaxData? {
+ var nextSibling: Syntax? {
  var node = self.node
  while let parent = node.parent {
- if let sibling = node.absoluteRaw.nextSibling(parent: parent.absoluteRaw, viewMode: viewMode) {
- return SyntaxData(sibling, parent: Syntax(parent))
+ let children = parent.children(viewMode: viewMode)
+ if children.index(after: node.index) != children.endIndex {
+ return children[children.index(after: node.index)]
  }
  node = parent
  }
@@ -367,8 +235,8 @@ fileprivate struct SyntaxCursor {
  /// Moves to the first child of the current node.
  /// - Returns: False if the node has no children.
  mutating func advanceToFirstChild() -> Bool {
- guard let child = node.absoluteRaw.firstChild(viewMode: viewMode) else { return false }
- node = SyntaxData(child, parent: Syntax(node))
+ guard let child = node.children(viewMode: viewMode).first else { return false }
+ node = child
  return true
  }
 
@@ -402,3 +270,137 @@ fileprivate struct SyntaxCursor {
  return node.position == position
  }
 }
+
+/// Edits that are applied **simultaneously**. That is, the offsets of all edits
+/// refer to the original string and are not shifted by previous edits. For
+/// example applying
+/// - insert 'x' at offset 0
+/// - insert 'y' at offset 1
+/// - insert 'z' at offset 2
+/// to '012345' results in 'x0y1z2345'.
+///
+/// The raw `edits` of this struct are guaranteed to
+/// 1. not be overlapping.
+/// 2. be in increasing source offset order.
+public struct ConcurrentEdits {
+ enum ConcurrentEditsError: Error, CustomStringConvertible {
+ case editsNotConcurrent
+
+ var description: String {
+ switch self {
+ case .editsNotConcurrent:
+ return "Edits passed to ConcurrentEdits(concurrent:) does not satisfy the requirements posed by ConcurrentEdits"
+ }
+ }
+ }
+
+ /// The raw concurrent edits. Are guaranteed to satisfy the requirements
+ /// stated above.
+ 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: [IncrementalEdit]) throws {
+ if !Self.isValidConcurrentEditArray(concurrent) {
+ throw ConcurrentEditsError.editsNotConcurrent
+ }
+ self.edits = concurrent
+ }
+
+ /// Create concurrent from a set of sequential edits. Sequential edits are
+ /// applied one after the other. Applying the first edit results in an
+ /// intermediate string to which the second edit is applied etc. For example
+ /// applying
+ /// - insert 'x' at offset 0
+ /// - insert 'y' at offset 1
+ /// - insert 'z' at offset 2
+ /// to '012345' results in 'xyz012345'.
+
+ public init(fromSequential sequentialEdits: [IncrementalEdit]) {
+ do {
+ try self.init(concurrent: Self.translateSequentialEditsToConcurrentEdits(sequentialEdits))
+ } catch {
+ fatalError("ConcurrentEdits created by translateSequentialEditsToConcurrentEdits do not satisfy ConcurrentEdits requirements")
+ }
+ }
+
+ /// 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: IncrementalEdit) {
+ do {
+ try self.init(concurrent: [single])
+ } catch {
+ fatalError("A single edit doesn't satisfy the ConcurrentEdits requirements?")
+ }
+ }
+
+ private static func translateSequentialEditsToConcurrentEdits(
+ _ 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 = 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 = IncrementalEdit(
+ offset: editToAdd.offset - existingEdit.replacementLength + existingEdit.length,
+ length: editToAdd.length,
+ replacementLength: editToAdd.replacementLength
+ )
+ }
+ }
+ precondition(editIndiciesMergedWithNewEdit.isSorted)
+ for indexToRemove in editIndiciesMergedWithNewEdit.reversed() {
+ concurrentEdits.remove(at: indexToRemove)
+ }
+ let insertPos =
+ concurrentEdits.firstIndex(where: { edit in
+ editToAdd.endOffset <= edit.offset
+ }) ?? concurrentEdits.count
+ concurrentEdits.insert(editToAdd, at: insertPos)
+ precondition(ConcurrentEdits.isValidConcurrentEditArray(concurrentEdits))
+ }
+ return concurrentEdits
+ }
+
+ 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.
+ guard !edits.isEmpty else { return true }
+
+ for i in 1..<edits.count {
+ let prevEdit = edits[i - 1]
+ let curEdit = edits[i]
+ if curEdit.range.offset < prevEdit.range.endOffset {
+ return false
+ }
+ if curEdit.intersectsRange(prevEdit.range) {
+ return false
+ }
+ }
+ return true
+ }
+
+ /// **Public for testing purposes only**
+ public static func _isValidConcurrentEditArray(_ edits: [IncrementalEdit]) -> Bool {
+ return isValidConcurrentEditArray(edits)
+ }
+}
+
+fileprivate extension Sequence where Element: Comparable {
+ var isSorted: Bool {
+ return zip(self, self.dropFirst()).allSatisfy({ $0.0 < $0.1 })
+ }
+}

Sources/SwiftSyntax/CMakeLists.txt

@@ -11,7 +11,6 @@ add_swift_host_library(SwiftSyntax
  Assert.swift
  BumpPtrAllocator.swift
  CommonAncestor.swift
- IncrementalParseTransition.swift
  MemoryLayout.swift
  MissingNodeInitializers.swift
  Trivia.swift

Tests/SwiftSyntaxTest/SequentialToConcurrentEditTranslationTests.swift renamed to Tests/SwiftParserTest/SequentialToConcurrentEditTranslationTests.swift

@@ -12,6 +12,7 @@
 
 import XCTest
 import SwiftSyntax
+import SwiftParser
 import _SwiftSyntaxTestSupport
 
 let longString = """