Refactor incremental parse API

Make `nodeAffectRangeCollector` a non-optional member of `parser` and make it a return value when we want to do incremental parse

Author: StevenWong12

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/ParserEntryFile.swift

@@ -24,8 +24,7 @@ let parserEntryFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       /// Parse the source code in the given string as Swift source file. See
       /// `Parser.init` for more details.
       public static func parse(
-        source: String,
-        parseTransition: IncrementalParseTransition? = nil
+        source: String
       ) -> SourceFileSyntax {
         var parser = Parser(source)
         return SourceFileSyntax.parse(from: &parser)
@@ -39,14 +38,40 @@ let parserEntryFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       /// `Parser.init` for more details.
       public static func parse(
         source: UnsafeBufferPointer<UInt8>,
-        maximumNestingLevel: Int? = nil,
-        parseTransition: IncrementalParseTransition? = nil
+        maximumNestingLevel: Int? = nil
       ) -> SourceFileSyntax {
         var parser = Parser(source, maximumNestingLevel: maximumNestingLevel)
         return SourceFileSyntax.parse(from: &parser)
       }
       """
     )
+
+    DeclSyntax(
+      """
+      /// Parse the source code in the given string as Swift source file while return `nodeAffectRangeCollector` to enable incremental parse.
+      public static func parse(
+        source: String,
+        parseTransition: IncrementalParseTransition? = nil
+      ) -> (tree: SourceFileSyntax, nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector) {
+        var parser = Parser(source, parseTransition: parseTransition)
+        return (SourceFileSyntax.parse(from: &parser), parser.parseNodeAffectRange)
+      }
+      """
+    )
+
+    DeclSyntax(
+      """
+      /// parse the source code in the given buffer as Swift source file while return `nodeAffectRangeCollector` to enable incremental parse.
+      public static func parse(
+        source: UnsafeBufferPointer<UInt8>,
+        maximumNestingLevel: Int? = nil,
+        parseTransition: IncrementalParseTransition? = nil
+      ) -> (tree: SourceFileSyntax, nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector) {
+        var parser = Parser(source, maximumNestingLevel: maximumNestingLevel, parseTransition: parseTransition)
+        return (SourceFileSyntax.parse(from: &parser), parser.parseNodeAffectRange)
+      }
+      """
+    )
   }
 
   DeclSyntax(

Sources/SwiftParser/IncrementalParseTransition.swift

@@ -45,15 +45,15 @@ public final class IncrementalParseReusedNodeCollector:
 /// Record the affect range for potential re-used nodes. When edits intersect the affect range, the node is not able to be re-used.
 ///
 /// This is also a trigger to enable parser to parse incrementally.
-public final class IncrementalParseNodeAffectRangeCollector {
+public struct IncrementalParseNodeAffectRangeCollector {
   /// A dict to record the utf8 length in source that might affect the parse of a node.
   /// This information is used to determine whether a node can be reused
   fileprivate var nodeAffectRange: [RawSyntax.ID: Int] = [:]
 
   public init() {}
 
   @_spi(RawSyntax)
-  public func registerNodeForIncrementalParse(node: RawSyntax, length: Int) {
+  public mutating func registerNodeForIncrementalParse(node: RawSyntax, length: Int) {
     self.nodeAffectRange[node.id] = length
   }
 }
@@ -63,6 +63,7 @@ public final class IncrementalParseNodeAffectRangeCollector {
 public final class IncrementalParseTransition {
   fileprivate let previousTree: SourceFileSyntax
   fileprivate let edits: ConcurrentEdits
+  fileprivate let nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector
   fileprivate let reusedDelegate: IncrementalParseReusedNodeDelegate?
 
   /// - Parameters:
@@ -74,10 +75,12 @@ public final class IncrementalParseTransition {
   public init(
     previousTree: SourceFileSyntax,
     edits: ConcurrentEdits,
+    nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector,
     reusedNodeDelegate: IncrementalParseReusedNodeDelegate? = nil
   ) {
     self.previousTree = previousTree
     self.edits = edits
+    self.nodeAffectRangeCollector = nodeAffectRangeCollector
     self.reusedDelegate = reusedNodeDelegate
   }
 }
@@ -89,14 +92,15 @@ public struct IncrementalParseLookup {
 
   fileprivate var cursor: SyntaxCursor
 
-  fileprivate let nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector
+  fileprivate var nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector {
+    return transition.nodeAffectRangeCollector
+  }
 
   /// Create a new ``IncrementalParseLookup`` that can look nodes up based on the
   /// given ``IncrementalParseTransition``.
-  public init(transition: IncrementalParseTransition, nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector) {
+  public init(transition: IncrementalParseTransition) {
     self.transition = transition
     self.cursor = .init(root: Syntax(transition.previousTree))
-    self.nodeAffectRangeCollector = nodeAffectRangeCollector
   }
 
   fileprivate var edits: ConcurrentEdits {

Sources/SwiftParser/Parser.swift

@@ -103,7 +103,7 @@ public struct Parser {
 
   let parseLookup: IncrementalParseLookup?
 
-  let parseNodeAffectRange: IncrementalParseNodeAffectRangeCollector?
+  let parseNodeAffectRange = IncrementalParseNodeAffectRangeCollector()
 
   /// A default maximum nesting level that is used if the client didn't
   /// explicitly specify one. Debug builds of the parser comume a lot more stack
@@ -118,7 +118,6 @@ public struct Parser {
   public init(
     _ input: String,
     maximumNestingLevel: Int? = nil,
-    parseNodeAffectRange: IncrementalParseNodeAffectRangeCollector? = nil,
     parseTransition: IncrementalParseTransition? = nil
   ) {
     self.maximumNestingLevel = maximumNestingLevel ?? Self.defaultMaximumNestingLevel
@@ -135,11 +134,8 @@ public struct Parser {
 
     self.lexemes = Lexer.tokenize(interned)
     self.currentToken = self.lexemes.advance()
-    self.parseNodeAffectRange = parseNodeAffectRange
-    if let parseTransition,
-      let parseNodeAffectRange
-    {
-      self.parseLookup = IncrementalParseLookup(transition: parseTransition, nodeAffectRangeCollector: parseNodeAffectRange)
+    if let parseTransition {
+      self.parseLookup = IncrementalParseLookup(transition: parseTransition)
     } else {
       self.parseLookup = nil
     }
@@ -162,7 +158,6 @@ public struct Parser {
   public init(
     _ input: UnsafeBufferPointer<UInt8>,
     maximumNestingLevel: Int? = nil,
-    parseNodeAffectRange: IncrementalParseNodeAffectRangeCollector? = nil,
     parseTransition: IncrementalParseTransition? = nil,
     arena: ParsingSyntaxArena? = nil
   ) {
@@ -182,11 +177,8 @@ public struct Parser {
 
     self.lexemes = Lexer.tokenize(sourceBuffer)
     self.currentToken = self.lexemes.advance()
-    self.parseNodeAffectRange = parseNodeAffectRange
-    if let parseTransition,
-      let parseNodeAffectRange
-    {
-      self.parseLookup = IncrementalParseLookup(transition: parseTransition, nodeAffectRangeCollector: parseNodeAffectRange)
+    if let parseTransition {
+      self.parseLookup = IncrementalParseLookup(transition: parseTransition)
     } else {
       self.parseLookup = nil
     }
@@ -679,9 +671,6 @@ extension Parser {
   }
 
   mutating func registerNodeForIncrementalParse(node: RawSyntax, startToken: Lexer.Lexeme) {
-    guard let parseNodeAffectRange else {
-      return
-    }
     parseNodeAffectRange.registerNodeForIncrementalParse(
       node: node,
       length: max(lookaheadFurthestOffset - self.lexemes.getOffsetToStart(startToken), node.byteLength + currentToken.byteLength)

Sources/SwiftParser/generated/Parser+Entry.swift

@@ -18,25 +18,40 @@ extension Parser {
   /// Parse the source code in the given string as Swift source file. See
   /// `Parser.init` for more details.
   public static func parse(
-    source: String,
-    parseNodeAffectRange: IncrementalParseNodeAffectRangeCollector? = nil,
-    parseTransition: IncrementalParseTransition? = nil
+    source: String
   ) -> SourceFileSyntax {
-    var parser = Parser(source, parseNodeAffectRange: parseNodeAffectRange, parseTransition: parseTransition)
+    var parser = Parser(source)
     return SourceFileSyntax.parse(from: &parser)
   }
 
   /// Parse the source code in the given string as Swift source file. See
   /// `Parser.init` for more details.
   public static func parse(
     source: UnsafeBufferPointer<UInt8>,
-    maximumNestingLevel: Int? = nil,
-    parseNodeAffectRange: IncrementalParseNodeAffectRangeCollector? = nil,
-    parseTransition: IncrementalParseTransition? = nil
+    maximumNestingLevel: Int? = nil
   ) -> SourceFileSyntax {
-    var parser = Parser(source, maximumNestingLevel: maximumNestingLevel, parseNodeAffectRange: parseNodeAffectRange, parseTransition: parseTransition)
+    var parser = Parser(source, maximumNestingLevel: maximumNestingLevel)
     return SourceFileSyntax.parse(from: &parser)
   }
+  
+  /// Parse the source code in the given string as Swift source file while return `nodeAffectRangeCollector` to enable incremental parse.
+  public static func parse(
+    source: String,
+    parseTransition: IncrementalParseTransition? = nil
+  ) -> (tree: SourceFileSyntax, nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector) {
+    var parser = Parser(source, parseTransition: parseTransition)
+    return (SourceFileSyntax.parse(from: &parser), parser.parseNodeAffectRange)
+  }
+  
+  /// parse the source code in the given buffer as Swift source file while return `nodeAffectRangeCollector` to enable incremental parse.
+  public static func parse(
+    source: UnsafeBufferPointer<UInt8>,
+    maximumNestingLevel: Int? = nil,
+    parseTransition: IncrementalParseTransition? = nil
+  ) -> (tree: SourceFileSyntax, nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector) {
+    var parser = Parser(source, maximumNestingLevel: maximumNestingLevel, parseTransition: parseTransition)
+    return (SourceFileSyntax.parse(from: &parser), parser.parseNodeAffectRange)
+  }
 }
 
 public protocol SyntaxParseable: SyntaxProtocol {

Sources/_SwiftSyntaxTestSupport/IncrementalParseTestUtils.swift

@@ -30,14 +30,18 @@ public func assertIncrementalParse(
   let originalString = String(originalSource)
   let editedString = String(editedSource)
 
-  let nodeAffectRangeCollector = IncrementalParseNodeAffectRangeCollector()
-  let originalTree = Parser.parse(source: originalString, parseNodeAffectRange: nodeAffectRangeCollector)
+  let (originalTree, nodeAffectRangeCollector) = Parser.parse(source: originalString, parseTransition: nil)
 
   let reusedNodesCollector = IncrementalParseReusedNodeCollector()
-  let transition = IncrementalParseTransition(previousTree: originalTree, edits: concurrentEdits, reusedNodeDelegate: reusedNodesCollector)
+  let transition = IncrementalParseTransition(
+    previousTree: originalTree,
+    edits: concurrentEdits,
+    nodeAffectRangeCollector: nodeAffectRangeCollector,
+    reusedNodeDelegate: reusedNodesCollector
+  )
 
   let newTree = Parser.parse(source: editedString)
-  let incrementallyParsedNewTree = Parser.parse(source: editedString, parseNodeAffectRange: nodeAffectRangeCollector, parseTransition: transition)
+  let (incrementallyParsedNewTree, _) = Parser.parse(source: editedString, parseTransition: transition)
 
   // Round-trip
   assertStringsEqualWithDiff(

Sources/swift-parser-cli/Commands/PerformanceTest.swift

@@ -41,20 +41,21 @@ struct PerformanceTest: ParsableCommand {
       .filter { $0.pathExtension == "swift" }
       .map { try Data(contentsOf: $0) }
 
-    var fileTransition: [Data: (parseTransition: IncrementalParseTransition, nodeAffectRangeCollector: IncrementalParseNodeAffectRangeCollector)] = [:]
+    var fileTransition: [Data: IncrementalParseTransition] = [:]
 
     if self.incrementalParse {
       /// The initial parse for incremental parse
       for file in files {
-        let incrementalParseAffectRangeCollector = IncrementalParseNodeAffectRangeCollector()
         file.withUnsafeBytes { buf in
-          let tree = Parser.parse(
+          let (tree, nodeAffectRangeCollector) = Parser.parse(
             source: buf.bindMemory(to: UInt8.self),
-            parseNodeAffectRange: incrementalParseAffectRangeCollector
+            parseTransition: nil
           )
 
-          fileTransition[file] = (
-            IncrementalParseTransition(previousTree: tree, edits: ConcurrentEdits(fromSequential: [])), incrementalParseAffectRangeCollector
+          fileTransition[file] = IncrementalParseTransition(
+            previousTree: tree,
+            edits: ConcurrentEdits(fromSequential: []),
+            nodeAffectRangeCollector: nodeAffectRangeCollector
           )
         }
       }
@@ -67,8 +68,7 @@ struct PerformanceTest: ParsableCommand {
         file.withUnsafeBytes { buf in
           _ = Parser.parse(
             source: buf.bindMemory(to: UInt8.self),
-            parseNodeAffectRange: fileTransition[file]?.nodeAffectRangeCollector,
-            parseTransition: fileTransition[file]?.parseTransition
+            parseTransition: fileTransition[file]
           )
         }
       }