[SwiftParser] Intern the whole source buffer for a full parse

748dde4 ([SwiftParser] Intern source text per parsed token) changed
parsing to intern each token's text individually instead of copying the
whole source buffer once, so a parsed tree no longer retains the source
buffer. That is important for incremental reparsing memory, but it
regressed full-parse performance: a full parse now copies the source in
as many pieces as there are tokens, each with its own bump-allocation
and memcpy, rather than in a single bulk copy.

For a full (non-incremental) parse, copy the whole source into the arena
once and lex over that copy. Parsed tokens then point directly into
arena-owned memory, so `internParsedTokenText` returns their text
unchanged instead of copying it, and the tree stays self-contained. An
incremental reparse keeps interning each re-lexed token individually, so
its new tree still references only the re-lexed spans and not the whole
buffer.

`ParsingRawSyntaxArena.internSourceBuffer` copies the buffer, records
its bounds, and returns the copy for `Parser` to lex over on a full
parse; `internParsedTokenText` returns text that lies within the copy
unchanged and copies anything else (e.g. synthesized tokens). Because
the copy is owned by the arena, a full parse needs no parser-owned
source copy, and nothing points into the caller's buffer once parsing
returns.

Author: rintaro

Sources/SwiftParser/Parser.swift

@@ -239,20 +239,23 @@ public struct Parser {
     self.arena = arena ?? ParsingRawSyntaxArena(parseTriviaFunction: TriviaParser.parseTrivia)
 
     var input = input
-    if copySource {
-      // Copy the source into a parser-owned buffer so the caller may free their
-      // buffer once this initializer returns. The buffer is freed when this
-      // `Parser` is destroyed (i.e. when the parse call returns); each token's
-      // text is interned into the arena at node-creation time, so the resulting
-      // tree does not reference this buffer.
+    if parseTransition == nil {
+      // Full parse: copy the whole source into the arena and lex over that copy,
+      // so parsed tokens point into arena-owned memory and need no per-token
+      // interning.
+      input = self.arena.internSourceBuffer(input)
+      self.sourceBufferOwner = nil
+    } else if copySource {
+      // Incremental reparse over a buffer that will not outlive this
+      // initializer: keep a parser-owned copy, freed when this `Parser` is
+      // destroyed. Each re-lexed token's text is interned into the arena.
       let owner = ParserSourceBufferOwner(copying: input)
       self.sourceBufferOwner = owner
       input = owner.buffer
     } else {
-      // No-copy: lex directly over the caller-provided buffer. The caller
-      // guarantees it stays valid for the entire parse (see `withParser`). Each
-      // token's text is interned into the arena, so the tree is self-contained
-      // and does not reference the buffer after parsing.
+      // Incremental reparse over the caller-provided buffer, which the caller
+      // guarantees stays valid for the parse (see `withParser`). Each re-lexed
+      // token's text is interned into the arena.
       self.sourceBufferOwner = nil
     }
 

Sources/SwiftSyntax/Raw/RawSyntaxArena.swift

@@ -202,18 +202,57 @@ public class ParsingRawSyntaxArena: RawSyntaxArena {
   /// - Important: Must never be changed to a mutable value. See `RawSyntaxArenaRef.parseTrivia`.
   private let parseTriviaFunction: ParseTriviaFunction
 
+  /// The arena's own copy of the whole source buffer, made by
+  /// `internSourceBuffer` for a full parse. `nil` for an incremental reparse,
+  /// which does not copy the whole buffer. When set, the lexer runs over this
+  /// copy, so a parsed token whose text lies within it is already arena-owned
+  /// and `internParsedTokenText` returns it unchanged.
+  private struct SourceCopy {
+    let start: UnsafePointer<UInt8>
+    let end: UnsafePointer<UInt8>
+  }
+  private var sourceCopy: SourceCopy?
+
   public init(parseTriviaFunction: @escaping ParseTriviaFunction) {
     self.parseTriviaFunction = parseTriviaFunction
     super.init(slabSize: 4096)
   }
 
+  /// Copy the whole source buffer into this arena and return the copy, so the
+  /// caller can lex over arena-owned memory. Parsed tokens then point directly
+  /// into the copy and need no per-token interning, and the resulting tree is
+  /// self-contained without referencing the caller's buffer.
+  ///
+  /// This suits a full parse, where every token's text is needed and the tree
+  /// legitimately retains text the size of the source. It must not be used for
+  /// an incremental reparse, where copying the whole buffer would defeat the
+  /// point of reusing nodes; there, `internParsedTokenText` copies each
+  /// re-lexed token individually instead.
+  @_spi(RawSyntax) public func internSourceBuffer(_ buffer: UnsafeBufferPointer<UInt8>) -> UnsafeBufferPointer<UInt8> {
+    guard buffer.count > 0 else {
+      self.sourceCopy = nil
+      return buffer
+    }
+    let dest = allocateTextBuffer(count: buffer.count)
+    _ = dest.initialize(from: buffer)
+    let copyBase = UnsafePointer(dest.baseAddress!)
+    self.sourceCopy = SourceCopy(start: copyBase, end: copyBase + buffer.count)
+    return UnsafeBufferPointer(start: copyBase, count: buffer.count)
+  }
+
   /// Intern a parsed token's whole text into the arena's node allocator so the
   /// resulting node does not depend on the source buffer.
   ///
   /// Unlike `intern(_:)`, this skips the `contains` check: lexer-produced text
-  /// is never already managed by the arena, so a copy is always needed.
+  /// is never already managed by the arena, so a copy is normally needed. When
+  /// the source was copied into the arena up front (`internSourceBuffer`, i.e. a
+  /// full parse), a token that lies within that copy is already arena-owned and
+  /// is returned unchanged.
   func internParsedTokenText(_ text: SyntaxText) -> SyntaxText {
-    if text.isEmpty {
+    guard let base = text.baseAddress, !text.isEmpty else {
+      return text
+    }
+    if let sourceCopy, base >= sourceCopy.start, base + text.count <= sourceCopy.end {
       return text
     }
     let allocated = allocateTextBuffer(count: text.count)