Reduce usage of RawSyntax.arena

ahoppen · ahoppen · commit f78d8723ad0c · 2024-01-26T16:36:54.000-08:00
diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftparser/LayoutNodesParsableFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftparser/LayoutNodesParsableFile.swift
@@ -41,7 +41,7 @@ let layoutNodesParsableFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
             defer { withExtendedLifetime(parser) {} }
             let node = parser.\(parserFunction)()
             let raw = RawSyntax(parser.parseRemainder(into: node))
-            return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+            return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
           }
         }
         """
diff --git a/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift b/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift
@@ -32,7 +32,7 @@ extension AccessorBlockSyntax: SyntaxParseable {
     }
     let node = parser.parseAccessorBlock()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -50,7 +50,7 @@ extension AccessorDeclSyntax: SyntaxParseable {
     }
     let node = parser.parseAccessorDecl()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -68,7 +68,7 @@ extension AttributeSyntax: SyntaxParseable {
     }
     let node = parser.parseAttribute()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -86,7 +86,7 @@ extension CatchClauseSyntax: SyntaxParseable {
     }
     let node = parser.parseCatchClause()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -104,7 +104,7 @@ extension ClosureParameterSyntax: SyntaxParseable {
     }
     let node = parser.parseClosureParameter()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -122,7 +122,7 @@ extension CodeBlockItemSyntax: SyntaxParseable {
     }
     let node = parser.parseNonOptionalCodeBlockItem()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -140,7 +140,7 @@ extension CodeBlockSyntax: SyntaxParseable {
     }
     let node = parser.parseCodeBlock()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -158,7 +158,7 @@ extension DeclSyntax: SyntaxParseable {
     }
     let node = parser.parseDeclaration()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -176,7 +176,7 @@ extension EnumCaseParameterSyntax: SyntaxParseable {
     }
     let node = parser.parseEnumCaseParameter()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -194,7 +194,7 @@ extension ExprSyntax: SyntaxParseable {
     }
     let node = parser.parseExpression()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -212,7 +212,7 @@ extension FunctionParameterSyntax: SyntaxParseable {
     }
     let node = parser.parseFunctionParameter()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -230,7 +230,7 @@ extension GenericParameterClauseSyntax: SyntaxParseable {
     }
     let node = parser.parseGenericParameters()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -248,7 +248,7 @@ extension MemberBlockSyntax: SyntaxParseable {
     }
     let node = parser.parseMemberBlock()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -266,7 +266,7 @@ extension PatternSyntax: SyntaxParseable {
     }
     let node = parser.parsePattern()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -284,7 +284,7 @@ extension SourceFileSyntax: SyntaxParseable {
     }
     let node = parser.parseSourceFile()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -302,7 +302,7 @@ extension StmtSyntax: SyntaxParseable {
     }
     let node = parser.parseStatement()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -320,7 +320,7 @@ extension SwitchCaseSyntax: SyntaxParseable {
     }
     let node = parser.parseSwitchCase()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
@@ -338,7 +338,7 @@ extension TypeSyntax: SyntaxParseable {
     }
     let node = parser.parseType()
     let raw = RawSyntax(parser.parseRemainder(into: node))
-    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
   }
 }
 
diff --git a/Sources/SwiftSyntax/Raw/RawSyntax.swift b/Sources/SwiftSyntax/Raw/RawSyntax.swift
@@ -39,6 +39,8 @@ struct RecursiveRawSyntaxFlags: OptionSet, Sendable {
 /// Node data for RawSyntax tree. Tagged union plus common data.
 internal struct RawSyntaxData: Sendable {
   internal enum Payload: Sendable {
+    /// - Important: A raw syntax node for a parsed token must always be allocated in a `ParsingSyntaxArena` so we can
+    ///   parse the trivia in the token.
     case parsedToken(ParsedToken)
     case materializedToken(MaterializedToken)
     case layout(Layout)
diff --git a/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift b/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift
@@ -95,8 +95,7 @@ public struct RawSyntaxTokenView: Sendable {
   public var leadingRawTriviaPieces: [RawTriviaPiece] {
     switch raw.rawData.payload {
     case .parsedToken(let dat):
-      let arena = raw.arena as! ParsingSyntaxArena
-      return arena.parseTrivia(source: dat.leadingTriviaText, position: .leading)
+      return raw.arenaReference.parseTrivia(source: dat.leadingTriviaText, position: .leading)
     case .materializedToken(let dat):
       return Array(dat.leadingTrivia)
     case .layout(_):
@@ -108,8 +107,7 @@ public struct RawSyntaxTokenView: Sendable {
   public var trailingRawTriviaPieces: [RawTriviaPiece] {
     switch raw.rawData.payload {
     case .parsedToken(let dat):
-      let arena = raw.arena as! ParsingSyntaxArena
-      return arena.parseTrivia(source: dat.trailingTriviaText, position: .trailing)
+      return raw.arenaReference.parseTrivia(source: dat.trailingTriviaText, position: .trailing)
     case .materializedToken(let dat):
       return Array(dat.trailingTrivia)
     case .layout(_):
@@ -204,7 +202,7 @@ public struct RawSyntaxTokenView: Sendable {
     arena.addChild(self.raw.arenaReference)
     switch raw.rawData.payload {
     case .parsedToken(var payload):
-      if arena === self.raw.arena {
+      if arena == self.raw.arenaReference {
         payload.presence = newValue
         return RawSyntax(arena: arena, payload: .parsedToken(payload))
       }
@@ -287,7 +285,7 @@ public struct RawSyntaxTokenView: Sendable {
     arena.addChild(self.raw.arenaReference)
     switch raw.rawData.payload {
     case .parsedToken(var dat):
-      if arena === self.raw.arena {
+      if arena == self.raw.arenaReference {
         dat.tokenDiagnostic = tokenDiagnostic
         return RawSyntax(arena: arena, payload: .parsedToken(dat))
       }
diff --git a/Sources/SwiftSyntax/Syntax.swift b/Sources/SwiftSyntax/Syntax.swift
@@ -126,7 +126,7 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
   ///     make sure the arena doesn’t get de-allocated before the ``Syntax``
   ///     has a chance to retain it.
   static func forRoot(_ raw: RawSyntax, rawNodeArena: SyntaxArena) -> Syntax {
-    precondition(rawNodeArena === raw.arena)
+    precondition(rawNodeArena == raw.arenaReference)
     return Syntax(raw, info: .root(.init(arena: rawNodeArena)))
   }
 
@@ -158,7 +158,7 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
   /// - Returns: A syntax tree with all parents where this node has been
   ///            replaced by `newRaw`
   func replacingSelf(_ newRaw: RawSyntax, rawNodeArena: SyntaxArena, allocationArena: SyntaxArena) -> Syntax {
-    precondition(newRaw.arena === rawNodeArena)
+    precondition(newRaw.arenaReference == rawNodeArena)
     // If we have a parent already, then ask our current parent to copy itself
     // recursively up to the root.
     if let parent {
@@ -183,7 +183,7 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
   ///            syntax data.
   /// - SeeAlso: replacingSelf(_:)
   func replacingChild(at index: Int, with newChild: RawSyntax?, rawNodeArena: SyntaxArena?, allocationArena: SyntaxArena) -> Syntax {
-    precondition(newChild?.arena === rawNodeArena || newChild == nil)
+    precondition(newChild == nil || (rawNodeArena != nil && newChild!.arenaReference == rawNodeArena!))
     // After newRaw has been allocated in `allocationArena`, `rawNodeArena` will
     // be a child arena of `allocationArena` and thus, `allocationArena` will
     // keep `newChild` alive.
diff --git a/Sources/SwiftSyntax/SyntaxArena.swift b/Sources/SwiftSyntax/SyntaxArena.swift
@@ -178,7 +178,9 @@ public class ParsingSyntaxArena: SyntaxArena {
   private var sourceBuffer: UnsafeBufferPointer<UInt8>
 
   /// Function to parse trivia.
-  private var parseTriviaFunction: ParseTriviaFunction
+  ///
+  /// - Important: Must never be changed to a mutable value. See `SyntaxArenaRef.parseTrivia`.
+  private let parseTriviaFunction: ParseTriviaFunction
 
   @_spi(RawSyntax)
   public init(parseTriviaFunction: @escaping ParseTriviaFunction) {
@@ -227,6 +229,7 @@ public class ParsingSyntaxArena: SyntaxArena {
   /// Parse `source` into a list of ``RawTriviaPiece`` using `parseTriviaFunction`.
   @_spi(RawSyntax)
   public func parseTrivia(source: SyntaxText, position: TriviaPosition) -> [RawTriviaPiece] {
+    // Must never access mutable state. See `SyntaxArenaRef.parseTrivia`.
     return self.parseTriviaFunction(source, position)
   }
 }
@@ -249,6 +252,13 @@ struct SyntaxArenaRef: Hashable, @unchecked Sendable {
     get { self._value.takeUnretainedValue() }
   }
 
+  /// Assuming that this references a `ParsingSyntaxArena`,
+  func parseTrivia(source: SyntaxText, position: TriviaPosition) -> [RawTriviaPiece] {
+    // It is safe to access `_value` here because `parseTrivia` only accesses
+    // `parseTriviaFunction`, which is a constant.
+    (_value.takeUnretainedValue() as! ParsingSyntaxArena).parseTrivia(source: source, position: position)
+  }
+
   func retain() {
     _ = self._value.retain()
   }
@@ -264,4 +274,12 @@ struct SyntaxArenaRef: Hashable, @unchecked Sendable {
   static func == (lhs: SyntaxArenaRef, rhs: SyntaxArenaRef) -> Bool {
     return lhs._value.toOpaque() == rhs._value.toOpaque()
   }
+
+  static func == (lhs: SyntaxArenaRef, rhs: __shared SyntaxArena) -> Bool {
+    return lhs == SyntaxArenaRef(rhs)
+  }
+
+  static func == (lhs: __shared SyntaxArena, rhs: SyntaxArenaRef) -> Bool {
+    return rhs == lhs
+  }
 }

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ let layoutNodesParsableFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {`
`41`	`41`	`defer { withExtendedLifetime(parser) {} }`
`42`	`42`	`let node = parser.\(parserFunction)()`
`43`	`43`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`44`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`44`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`	`"""`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ extension AccessorBlockSyntax: SyntaxParseable {`
`32`	`32`	`}`
`33`	`33`	`let node = parser.parseAccessorBlock()`
`34`	`34`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`35`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`35`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`@@ -50,7 +50,7 @@ extension AccessorDeclSyntax: SyntaxParseable {`
`50`	`50`	`}`
`51`	`51`	`let node = parser.parseAccessorDecl()`
`52`	`52`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`53`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`53`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`@@ -68,7 +68,7 @@ extension AttributeSyntax: SyntaxParseable {`
`68`	`68`	`}`
`69`	`69`	`let node = parser.parseAttribute()`
`70`	`70`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`71`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`71`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`@@ -86,7 +86,7 @@ extension CatchClauseSyntax: SyntaxParseable {`
`86`	`86`	`}`
`87`	`87`	`let node = parser.parseCatchClause()`
`88`	`88`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`89`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`89`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`@@ -104,7 +104,7 @@ extension ClosureParameterSyntax: SyntaxParseable {`
`104`	`104`	`}`
`105`	`105`	`let node = parser.parseClosureParameter()`
`106`	`106`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`107`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`107`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`@@ -122,7 +122,7 @@ extension CodeBlockItemSyntax: SyntaxParseable {`
`122`	`122`	`}`
`123`	`123`	`let node = parser.parseNonOptionalCodeBlockItem()`
`124`	`124`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`125`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`125`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`@@ -140,7 +140,7 @@ extension CodeBlockSyntax: SyntaxParseable {`
`140`	`140`	`}`
`141`	`141`	`let node = parser.parseCodeBlock()`
`142`	`142`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`143`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`143`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`@@ -158,7 +158,7 @@ extension DeclSyntax: SyntaxParseable {`
`158`	`158`	`}`
`159`	`159`	`let node = parser.parseDeclaration()`
`160`	`160`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`161`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`161`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`
`@@ -176,7 +176,7 @@ extension EnumCaseParameterSyntax: SyntaxParseable {`
`176`	`176`	`}`
`177`	`177`	`let node = parser.parseEnumCaseParameter()`
`178`	`178`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`179`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`179`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`@@ -194,7 +194,7 @@ extension ExprSyntax: SyntaxParseable {`
`194`	`194`	`}`
`195`	`195`	`let node = parser.parseExpression()`
`196`	`196`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`197`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`197`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`198`	`198`	`}`
`199`	`199`	`}`
`200`	`200`
`@@ -212,7 +212,7 @@ extension FunctionParameterSyntax: SyntaxParseable {`
`212`	`212`	`}`
`213`	`213`	`let node = parser.parseFunctionParameter()`
`214`	`214`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`215`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`215`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`
`@@ -230,7 +230,7 @@ extension GenericParameterClauseSyntax: SyntaxParseable {`
`230`	`230`	`}`
`231`	`231`	`let node = parser.parseGenericParameters()`
`232`	`232`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`233`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`233`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`234`	`234`	`}`
`235`	`235`	`}`
`236`	`236`
`@@ -248,7 +248,7 @@ extension MemberBlockSyntax: SyntaxParseable {`
`248`	`248`	`}`
`249`	`249`	`let node = parser.parseMemberBlock()`
`250`	`250`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`251`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`251`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`252`	`252`	`}`
`253`	`253`	`}`
`254`	`254`
`@@ -266,7 +266,7 @@ extension PatternSyntax: SyntaxParseable {`
`266`	`266`	`}`
`267`	`267`	`let node = parser.parsePattern()`
`268`	`268`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`269`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`269`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`270`	`270`	`}`
`271`	`271`	`}`
`272`	`272`
`@@ -284,7 +284,7 @@ extension SourceFileSyntax: SyntaxParseable {`
`284`	`284`	`}`
`285`	`285`	`let node = parser.parseSourceFile()`
`286`	`286`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`287`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`287`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`288`	`288`	`}`
`289`	`289`	`}`
`290`	`290`
`@@ -302,7 +302,7 @@ extension StmtSyntax: SyntaxParseable {`
`302`	`302`	`}`
`303`	`303`	`let node = parser.parseStatement()`
`304`	`304`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`305`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`305`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`306`	`306`	`}`
`307`	`307`	`}`
`308`	`308`
`@@ -320,7 +320,7 @@ extension SwitchCaseSyntax: SyntaxParseable {`
`320`	`320`	`}`
`321`	`321`	`let node = parser.parseSwitchCase()`
`322`	`322`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`323`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`323`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`324`	`324`	`}`
`325`	`325`	`}`
`326`	`326`
`@@ -338,7 +338,7 @@ extension TypeSyntax: SyntaxParseable {`
`338`	`338`	`}`
`339`	`339`	`let node = parser.parseType()`
`340`	`340`	`let raw = RawSyntax(parser.parseRemainder(into: node))`
`341`		`- return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)`
	`341`	`+ return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)`
`342`	`342`	`}`
`343`	`343`	`}`
`344`	`344`