WIP: code refactor

Author: StevenWong12

Sources/SwiftParser/IncrementalParseTransition.swift

@@ -50,10 +50,9 @@ public final class IncrementalParseTransition {
   fileprivate var edits: ConcurrentEdits?
   fileprivate var reusedDelegate: IncrementalParseReusedNodeDelegate?
 
-  fileprivate var previousLookaheadRange: [Int: Int] = [:]
-  /// Keep track of how far we would look when calling ``Lookahead``
-  /// Key is offset to buffer start and value is the length of we lookahead
-  fileprivate var cursorLookaheadRange: [Int: Int] = [:]
+  public var furthestOffset: Int?
+  
+  fileprivate var lookaheadBytes: [UnsafeRawPointer: Int] = [:]
 
   /// - Parameters:
   ///   - previousTree: The previous tree to do lookups on.
@@ -75,12 +74,15 @@ public final class IncrementalParseTransition {
     self.previousTree = tree
     self.edits = edits
     self.reusedDelegate = delegate
-    self.previousLookaheadRange = cursorLookaheadRange
-    self.cursorLookaheadRange = [:]
   }
-
-  public func registerAffectRange(at offset: Int, length: Int) {
-    self.cursorLookaheadRange[offset] = length
+  
+  @_spi(RawSyntax)
+  public func registerNodeForIncrementalParse(offset: Int,  node: RawSyntax) {
+    
+    guard let furthestOffset,
+          furthestOffset > offset else { return }
+    
+    self.lookaheadBytes[node.id] = furthestOffset - offset
   }
 
   public func isValidTransition() -> Bool {
@@ -106,6 +108,10 @@ public struct IncrementalParseLookup {
   fileprivate var reusedDelegate: IncrementalParseReusedNodeDelegate? {
     return transition.reusedDelegate
   }
+  
+  fileprivate var lookaheadBytes: [UnsafeRawPointer: Int] {
+    return transition.lookaheadBytes
+  }
 
   /// Does a lookup to see if the current source `offset` should be associated
   /// with a known ``Syntax`` node and its region skipped during parsing.
@@ -175,35 +181,14 @@ public struct IncrementalParseLookup {
       return true
     }
 
-    // Node can also not be reused if an edit has been made in the next token's
-    // text, e.g. because `private struct Foo {}` parses as a CodeBlockItem with
-    // a StructDecl inside and `private struc Foo {}` parses as two
-    // CodeBlockItems one for `private` and one for `struc Foo {}`
-    var nextLeafNodeLength: SourceLength = .zero
-    if let nextSibling = cursor.nextSibling {
-      // Fast path check: if next sibling is before all the edits then we can
-      // re-use the node.
-      if !edits.edits.isEmpty && edits.edits.first!.range.offset > nextSibling.endPosition.utf8Offset {
-        return true
-      }
-      if let nextToken = nextSibling.firstToken(viewMode: .sourceAccurate) {
-        nextLeafNodeLength = nextToken.leadingTriviaLength + nextToken.contentLength
-      }
-    }
-
-    var underlyingRaw = node.raw
-    if let codeBlockItem = underlyingRaw.as(RawCodeBlockItemSyntax.self) {
-      underlyingRaw = codeBlockItem.item
+    
+    guard let lookaheadRange = self.lookaheadBytes[node.raw.id] else {
+      return false
     }
 
-    let nodeAffectLength =
-      underlyingRaw.isSelfCompleted
-      ? (node.totalLength + nextLeafNodeLength).utf8Length
-      : max(mergeLookaheadRange(at: node.position.utf8Offset, length: node.totalLength.utf8Length), (node.totalLength + nextLeafNodeLength).utf8Length)
-
     let nodeAffectRange = ByteSourceRange(
       offset: node.position.utf8Offset,
-      length: nodeAffectLength
+      length: max(lookaheadRange, node.byteSize)
     )
 
     for edit in edits.edits {
@@ -239,21 +224,6 @@ public struct IncrementalParseLookup {
     }
     return offset
   }
-
-  fileprivate func mergeLookaheadRange(at start: Int, length: Int) -> Int {
-    var totalLength = start + length
-
-    let targetRanges = transition.previousLookaheadRange.filter { $0.key >= totalLength }.sorted(by: { $0.key < $1.key })
-
-    for targetRange in targetRanges {
-      if targetRange.key != totalLength {
-        break
-      }
-      totalLength += targetRange.value
-    }
-
-    return totalLength
-  }
 }
 
 /// Functions as an iterator that walks the tree looking for nodes with a

Sources/SwiftParser/Lookahead.swift

@@ -40,6 +40,7 @@ extension Parser {
       self.currentToken = currentToken
       self.parseTransition = parseTransition
       self.currentOffset = lexemes.getOffsetToStart(self.currentToken)
+      self.parseTransition?.furtheestOffset = lexemes.getOffsetToStart(lexemes.peek()) + lexemes.peek().byteLength
     }
 
     fileprivate init(cloning other: Parser) {
@@ -96,8 +97,8 @@ extension Parser.Lookahead {
 
   mutating func consumeAnyToken() {
     tokensConsumed += 1
-    registerAffectRange()
     self.currentToken = self.lexemes.advance()
+    self.parseTransition?.furtheestOffset = lexemes.getOffsetToStart(lexemes.peek()) + lexemes.peek().byteLength
   }
 
   mutating func consumeAnyToken(remapping: RawTokenKind) {
@@ -407,10 +408,4 @@ extension Parser.Lookahead {
       }
     }
   }
-
-  fileprivate mutating func registerAffectRange() {
-    self.parseTransition?.registerAffectRange(at: self.currentOffset, length: self.currentToken.byteLength)
-    currentOffset += self.currentToken.byteLength
-    self.parseTransition?.registerAffectRange(at: self.currentOffset, length: self.lexemes.peek().byteLength)
-  }
 }

Sources/SwiftParser/TopLevel.swift

@@ -151,7 +151,9 @@ extension Parser {
   ///     statement → compiler-control-statement
   ///     statements → statement statements?
   mutating func parseCodeBlockItem(isAtTopLevel: Bool, allowInitDecl: Bool) -> RawCodeBlockItemSyntax? {
+    let startToken = self.currentToken
     if let syntax = self.loadCurrentSyntaxNodeFromCache(for: .codeBlockItem) {
+      parseTransition?.registerNodeForIncrementalParse(offset: self.lexemes.getOffsetToStart(startToken), node: syntax.raw)
       return RawCodeBlockItemSyntax(syntax.raw)
     }
 
@@ -187,12 +189,17 @@ extension Parser {
     if item.raw.isEmpty && semi == nil && trailingSemis.isEmpty {
       return nil
     }
-    return RawCodeBlockItemSyntax(
+    
+    let result = RawCodeBlockItemSyntax(
       item: item,
       semicolon: semi,
       RawUnexpectedNodesSyntax(trailingSemis, arena: self.arena),
       arena: self.arena
     )
+
+    parseTransition?.registerNodeForIncrementalParse(offset: self.lexemes.getOffsetToStart(startToken), node: result.raw)
+    
+    return result
   }
 
   private mutating func parseStatementItem() -> RawCodeBlockItemSyntax.Item {

Sources/SwiftSyntax/Raw/RawSyntax.swift

@@ -917,21 +917,10 @@ extension RawSyntax {
   }
 }
 
-extension RawSyntax {
-  public var isSelfCompleted: Bool {
-    if let children = self.layoutView?.children,
-      let lastNonNilChildIdx = children.lastIndex(where: {
-        $0 != nil
-      }),
-      lastNonNilChildIdx != children.endIndex
-    {
-
-      let nextPotentialChildIndex = children.index(after: lastNonNilChildIdx)
-      return nextPotentialChildIndex == children.index(before: children.endIndex)
-        || children.index(after: nextPotentialChildIndex) == children.index(before: children.endIndex)
-    }
 
-    return true
+extension RawSyntax: Identifiable {
+  public var id: UnsafeRawPointer {
+      return UnsafeRawPointer(pointer)
   }
 }