Add Sendable conformances to the SwiftSyntax module

Author: ahoppen

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/KeywordFile.swift

@@ -24,7 +24,7 @@ let lookupTable = ArrayExprSyntax(leftSquare: .leftSquareToken(trailingTrivia: .
 let keywordFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! EnumDeclSyntax(
     """
-    public enum Keyword: UInt8, Hashable
+    public enum Keyword: UInt8, Hashable, Sendable
     """
   ) {
     for keyword in Keyword.allCases {

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift

@@ -19,7 +19,7 @@ let syntaxEnumFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! EnumDeclSyntax(
     """
     /// Enum to exhaustively switch over all different syntax nodes.
-    public enum SyntaxEnum
+    public enum SyntaxEnum: Sendable
     """
   ) {
     DeclSyntax("case token(TokenSyntax)")

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxKindFile.swift

@@ -19,7 +19,7 @@ let syntaxKindFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! EnumDeclSyntax(
     """
     /// Enumerates the known kinds of Syntax represented in the Syntax tree.
-    public enum SyntaxKind
+    public enum SyntaxKind: Sendable
     """
   ) {
     DeclSyntax("case token")

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/TokenKindFile.swift

@@ -19,7 +19,7 @@ let tokenKindFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! EnumDeclSyntax(
     """
     /// Enumerates the kinds of tokens in the Swift language.
-    public enum TokenKind: Hashable
+    public enum TokenKind: Hashable, Sendable
     """
   ) {
     for tokenSpec in Token.allCases.map(\.spec) {

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/TriviaPiecesFile.swift

@@ -26,7 +26,7 @@ let triviaPiecesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     ///
     /// In general, you should deal with the actual Trivia collection instead
     /// of individual pieces whenever possible.
-    public enum TriviaPiece
+    public enum TriviaPiece: Sendable
     """
   ) {
     for trivia in TRIVIAS {
@@ -176,7 +176,7 @@ let triviaPiecesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     /// In contrast to ``TriviaPiece``, a ``RawTriviaPiece`` does not own the source
     /// text of the trivia.
     @_spi(RawSyntax)
-    public enum RawTriviaPiece: Equatable
+    public enum RawTriviaPiece: Equatable, Sendable
     """
   ) {
     for trivia in TRIVIAS {

Sources/SwiftParser/CollectionNodes+Parsable.swift

@@ -45,7 +45,7 @@ fileprivate extension SyntaxCollection {
     } else {
       // First unwrap: We know that children.last exists because children is not empty
       // Second unwrap: This is a collection and collections never have optional children. Thus the last child can’t be nil.
-      let lastWithRemainder = parser.parseRemainder(into: layoutView.children.last!!)
+      let lastWithRemainder = parser.parseRemainder(into: layoutView.children[layoutView.children.count - 1]!)
       let raw = layoutView.replacingChild(at: layoutView.children.count - 1, with: lastWithRemainder, arena: parser.arena)
       return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
     }

Sources/SwiftSyntax/AbsolutePosition.swift

@@ -12,7 +12,7 @@
 
 /// An absolute position in a source file as text - the absolute utf8Offset from
 /// the start of the file.
-public struct AbsolutePosition: Comparable, Hashable {
+public struct AbsolutePosition: Comparable, Hashable, Sendable {
   public let utf8Offset: Int
 
   static let startOfFile = AbsolutePosition(utf8Offset: 0)

Sources/SwiftSyntax/AbsoluteRawSyntax.swift

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-struct AbsoluteRawSyntax {
+struct AbsoluteRawSyntax: Sendable {
   let raw: RawSyntax
   let info: AbsoluteSyntaxInfo
 

Sources/SwiftSyntax/AbsoluteSyntaxInfo.swift

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-struct AbsoluteSyntaxPosition {
+struct AbsoluteSyntaxPosition: Sendable {
   /// The UTF-8 offset of the syntax node in the source file
   let offset: UInt32
   let indexInParent: UInt32
@@ -32,7 +32,7 @@ struct AbsoluteSyntaxPosition {
 
 /// `AbsoluteSyntaxInfo` represents the information that relates a `RawSyntax`
 /// to a source file tree, like its absolute source offset.
-struct AbsoluteSyntaxInfo {
+struct AbsoluteSyntaxInfo: Sendable {
   let position: AbsoluteSyntaxPosition
   let nodeId: SyntaxIdentifier
 

Sources/SwiftSyntax/CMakeLists.txt

@@ -23,6 +23,7 @@ add_swift_syntax_library(SwiftSyntax
   SwiftSyntaxCompatibility.swift
   Syntax.swift
   SyntaxArena.swift
+  SyntaxArenaAllocatedBuffer.swift
   SyntaxChildren.swift
   SyntaxCollection.swift
   SyntaxHashable.swift

Sources/SwiftSyntax/MemoryLayout.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 // See `MemoryLayoutTest.swift`.
-@_spi(Testing) public enum SyntaxMemoryLayout {
+@_spi(Testing) public enum SyntaxMemoryLayout: Sendable {
   public struct Value: Equatable, Sendable {
     var size: Int
     var stride: Int

Sources/SwiftSyntax/Raw/RawSyntax.swift

@@ -10,8 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-@_spi(RawSyntax) public typealias RawSyntaxBuffer = UnsafeBufferPointer<RawSyntax?>
-typealias RawTriviaPieceBuffer = UnsafeBufferPointer<RawTriviaPiece>
+@_spi(RawSyntax) public typealias RawSyntaxBuffer = SyntaxArenaAllocatedBufferPointer<RawSyntax?>
+
+typealias RawTriviaPieceBuffer = SyntaxArenaAllocatedBufferPointer<RawTriviaPiece>
 
 fileprivate extension SyntaxKind {
   /// Whether this node kind should be considered as `hasError` for purposes of `RecursiveRawSyntaxFlags`.
@@ -20,7 +21,7 @@ fileprivate extension SyntaxKind {
   }
 }
 
-struct RecursiveRawSyntaxFlags: OptionSet {
+struct RecursiveRawSyntaxFlags: OptionSet, Sendable {
   let rawValue: UInt8
 
   /// Whether the tree contained by this layout has any
@@ -36,8 +37,8 @@ struct RecursiveRawSyntaxFlags: OptionSet {
 }
 
 /// Node data for RawSyntax tree. Tagged union plus common data.
-internal struct RawSyntaxData {
-  internal enum Payload {
+internal struct RawSyntaxData: Sendable {
+  internal enum Payload: Sendable {
     case parsedToken(ParsedToken)
     case materializedToken(MaterializedToken)
     case layout(Layout)
@@ -47,7 +48,7 @@ internal struct RawSyntaxData {
   ///
   /// The RawSyntax's `arena` must have a valid trivia parsing function to
   /// lazily materialize the leading/trailing trivia pieces.
-  struct ParsedToken {
+  struct ParsedToken: Sendable {
     var tokenKind: RawTokenKind
 
     /// Whole text of this token including leading/trailing trivia.
@@ -97,7 +98,7 @@ internal struct RawSyntaxData {
   }
 
   /// Token typically created with `TokenSyntax.<someToken>`.
-  struct MaterializedToken {
+  struct MaterializedToken: Sendable {
     var tokenKind: RawTokenKind
     var tokenText: SyntaxText
     var triviaPieces: RawTriviaPieceBuffer
@@ -150,7 +151,7 @@ internal struct RawSyntaxData {
   }
 
   /// Layout node including collections.
-  struct Layout {
+  struct Layout: Sendable {
     var kind: SyntaxKind
     var layout: RawSyntaxBuffer
     var byteLength: Int
@@ -177,32 +178,36 @@ extension RawSyntaxData.ParsedToken {
 
 extension RawSyntaxData.MaterializedToken {
   var leadingTrivia: RawTriviaPieceBuffer {
-    RawTriviaPieceBuffer(rebasing: triviaPieces[..<Int(numLeadingTrivia)])
+    triviaPieces[..<Int(numLeadingTrivia)]
   }
   var trailingTrivia: RawTriviaPieceBuffer {
-    RawTriviaPieceBuffer(rebasing: triviaPieces[Int(numLeadingTrivia)...])
+    triviaPieces[Int(numLeadingTrivia)...]
   }
 }
 
 /// Represents the raw tree structure underlying the syntax tree. These nodes
 /// have no notion of identity and only provide structure to the tree. They
 /// are immutable and can be freely shared between syntax nodes.
 @_spi(RawSyntax)
-public struct RawSyntax {
+public struct RawSyntax: Sendable {
 
   /// Pointer to the actual data which resides in a SyntaxArena.
-  var pointer: UnsafePointer<RawSyntaxData>
-  init(pointer: UnsafePointer<RawSyntaxData>) {
+  var pointer: SyntaxArenaAllocatedPointer<RawSyntaxData>
+  init(pointer: SyntaxArenaAllocatedPointer<RawSyntaxData>) {
     self.pointer = pointer
   }
 
   init(arena: __shared SyntaxArena, payload: RawSyntaxData.Payload) {
     let arenaRef = SyntaxArenaRef(arena)
-    self.init(pointer: arena.intern(RawSyntaxData(payload: payload, arenaReference: arenaRef)))
+    let data = RawSyntaxData(
+      payload: payload,
+      arenaReference: arenaRef
+    )
+    self.init(pointer: SyntaxArenaAllocatedPointer(arena.intern(data)))
   }
 
   var rawData: RawSyntaxData {
-    unsafeAddress { pointer }
+    pointer.pointee
   }
 
   internal var arenaReference: SyntaxArenaRef {
@@ -352,18 +357,6 @@ extension RawSyntax {
   }
 }
 
-extension RawSyntax {
-  @_spi(RawSyntax)
-  public func toOpaque() -> UnsafeRawPointer {
-    UnsafeRawPointer(pointer)
-  }
-
-  @_spi(RawSyntax)
-  public static func fromOpaque(_ pointer: UnsafeRawPointer) -> RawSyntax {
-    Self(pointer: pointer.assumingMemoryBound(to: RawSyntaxData.self))
-  }
-}
-
 extension RawTriviaPiece {
   func withSyntaxText(body: (SyntaxText) throws -> Void) rethrows {
     if let syntaxText = storedText {
@@ -651,7 +644,7 @@ extension RawSyntax {
     return .materializedToken(
       kind: kind,
       text: text,
-      triviaPieces: RawTriviaPieceBuffer(triviaBuffer),
+      triviaPieces: RawTriviaPieceBuffer(UnsafeBufferPointer(triviaBuffer)),
       numLeadingTrivia: numericCast(leadingTriviaPieceCount),
       byteLength: numericCast(byteLength),
       presence: presence,
@@ -713,7 +706,7 @@ extension RawSyntax {
     return .materializedToken(
       kind: rawKind,
       text: rawKind.defaultText ?? "",
-      triviaPieces: .init(start: nil, count: 0),
+      triviaPieces: RawTriviaPieceBuffer(),
       numLeadingTrivia: 0,
       byteLength: 0,
       presence: .missing,
@@ -794,7 +787,7 @@ extension RawSyntax {
     }
     return .layout(
       kind: kind,
-      layout: RawSyntaxBuffer(layoutBuffer),
+      layout: RawSyntaxBuffer(UnsafeBufferPointer(layoutBuffer)),
       byteLength: byteLength,
       descendantCount: descendantCount,
       recursiveFlags: recursiveFlags,
@@ -812,7 +805,7 @@ extension RawSyntax {
     }
     return .layout(
       kind: kind,
-      layout: .init(start: nil, count: 0),
+      layout: RawSyntaxBuffer(),
       byteLength: 0,
       descendantCount: 0,
       recursiveFlags: recursiveFlags,
@@ -933,11 +926,11 @@ extension RawSyntax {
 }
 
 extension RawSyntax: Identifiable {
-  public struct ID: Hashable {
+  public struct ID: Hashable, @unchecked Sendable {
     /// The pointer to the start of the `RawSyntax` node.
     private var pointer: UnsafeRawPointer
     fileprivate init(_ raw: RawSyntax) {
-      self.pointer = UnsafeRawPointer(raw.pointer)
+      self.pointer = raw.pointer.unsafeRawPointer
     }
   }
 

Sources/SwiftSyntax/Raw/RawSyntaxNodeProtocol.swift

@@ -13,7 +13,7 @@
 /// All typed raw syntax nodes conform to this protocol.
 /// `RawXXXSyntax` is a typed wrappeer of ``RawSyntax``.
 @_spi(RawSyntax)
-public protocol RawSyntaxNodeProtocol: CustomStringConvertible, TextOutputStreamable {
+public protocol RawSyntaxNodeProtocol: CustomStringConvertible, TextOutputStreamable, Sendable {
   /// Returns `true` if `raw` can be cast to this concrete raw syntax type.
   static func isKindOf(_ raw: RawSyntax) -> Bool
 

Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift

@@ -26,7 +26,7 @@ extension RawSyntax {
 
 /// A view into ``RawSyntax`` that exposes functionality that only applies to tokens.
 @_spi(RawSyntax)
-public struct RawSyntaxTokenView {
+public struct RawSyntaxTokenView: Sendable {
   let raw: RawSyntax
 
   fileprivate init(raw: RawSyntax) {

Sources/SwiftSyntax/SourceEdit.swift

@@ -12,7 +12,7 @@
 
 /// A textual edit to the original source represented by a range and a
 /// replacement.
-public struct SourceEdit: Equatable {
+public struct SourceEdit: Equatable, Sendable {
   /// The half-open range that this edit applies to.
   public let range: Range<AbsolutePosition>
   /// The text to replace the original range with. Empty for a deletion.

Sources/SwiftSyntax/SourceLength.swift

@@ -12,7 +12,7 @@
 
 /// The length a syntax node spans in the source code. From any AbsolutePosition
 /// you reach a node's end location by adding its UTF-8 length.
-public struct SourceLength: Comparable {
+public struct SourceLength: Comparable, Sendable {
   /// The length in bytes when the text is represented as UTF-8.
   public let utf8Length: Int
 

Sources/SwiftSyntax/SourceLocation.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 /// Represents a source location in a Swift file.
-public struct SourceLocation: Hashable, Codable {
+public struct SourceLocation: Hashable, Codable, Sendable {
 
   /// The line in the file where this location resides. 1-based.
   ///
@@ -82,7 +82,7 @@ public struct SourceLocation: Hashable, Codable {
 }
 
 /// Represents a half-open range in a Swift file.
-public struct SourceRange: Hashable, Codable {
+public struct SourceRange: Hashable, Codable, Sendable {
 
   /// The beginning location of the source range.
   ///
@@ -235,7 +235,11 @@ public final class SourceLocationConverter {
     self.fileName = file
     self.source = Array(source.utf8)
     (self.lines, endOfFile) = self.source.withUnsafeBufferPointer { buf in
-      return computeLines(SyntaxText(buffer: buf))
+      // Technically, `buf` is not allocated in a `SyntaxArena` but it satisfies
+      // all the required properties: `buf` will always outlive any references
+      // to it.
+      let syntaxArenaBuf = SyntaxArenaAllocatedBufferPointer(buf)
+      return computeLines(SyntaxText(buffer: syntaxArenaBuf))
     }
     precondition(source.utf8.count == endOfFile.utf8Offset)
   }

Sources/SwiftSyntax/SourcePresence.swift

@@ -14,7 +14,7 @@
 ///
 /// A `missing` node does not mean, necessarily, that the source item is
 /// considered "implicit", but rather that it was not found in the source.
-public enum SourcePresence {
+public enum SourcePresence: Sendable {
   /// The syntax was authored by a human and found, or was generated.
   case present
 

Sources/SwiftSyntax/Syntax.swift

@@ -14,17 +14,23 @@
 /// Each node has accessors for its known children, and allows efficient
 /// iteration over the children through its `children` property.
 public struct Syntax: SyntaxProtocol, SyntaxHashable {
-  fileprivate enum Info {
+  fileprivate enum Info: Sendable {
     case root(Root)
     indirect case nonRoot(NonRoot)
 
     // For root node.
-    struct Root {
-      var arena: SyntaxArena
+    struct Root: @unchecked Sendable {
+      // Unchecked conformance to sendable is fine because `arena` is not
+      // accessible. It is just used to keep the arena alive.
+      private var arena: SyntaxArena
+
+      init(arena: SyntaxArena) {
+        self.arena = arena
+      }
     }
 
     // For non-root nodes.
-    struct NonRoot {
+    struct NonRoot: Sendable {
       var parent: Syntax
       var absoluteInfo: AbsoluteSyntaxInfo
     }