1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
/// An `UnsafePointer` pointing into memory that was allocated by a
/// ``RawSyntaxArena`` or ``SyntaxDataArena``.
///
/// Because the arena will always outlive any syntax nodes that reference its
/// contents, we know that the pointees won't get deallocated while being
/// accessed and thus we can add an unchecked `Sendable` conformance.
@_spi(RawSyntax)
public struct ArenaAllocatedPointer<Element: Sendable>: @unchecked Sendable {
let pointer: UnsafePointer<Element>
/// Create a pointer from an `UnsafePointer` that was allocated inside a
/// ``RawSyntaxArena`` or ``SyntaxDataArena``.
///
/// - Important: The client needs to ensure sure that the buffer is indeed
/// allocated by an arena and that the arena will outlive any users of this
/// ``ArenaAllocatedPointer``.
init(_ pointer: UnsafePointer<Element>) {
self.pointer = pointer
}
var pointee: Element {
@_transparent unsafeAddress { pointer }
}
func advanced(by n: Int) -> Self {
Self(pointer.advanced(by: n))
}
var unsafeRawPointer: UnsafeRawPointer {
return UnsafeRawPointer(pointer)
}
}
/// An `UnsafeBufferPointer` pointing into memory that was allocated by a
/// ``RawSyntaxArena`` or ``SyntaxDataArena``.
///
/// Because the arena will always outlive any syntax nodes that reference its
/// contents, we know that the buffer's contents won't get deallocated while
/// being accessed and thus we can add an unchecked `Sendable` conformance.
@_spi(RawSyntax)
public struct ArenaAllocatedBufferPointer<Element: Sendable>: RandomAccessCollection, @unchecked Sendable {
private let buffer: UnsafeBufferPointer<Element>
/// Create an empty buffer with no elements.
init() {
self.buffer = UnsafeBufferPointer(start: nil, count: 0)
}
/// Create a buffer pointer from an `UnsafeBufferPointer` that was allocated
/// inside a ``RawSyntaxArena`` or ``SyntaxDataArena``.
///
/// - Important: The client needs to ensure sure that the buffer is indeed
/// allocated by an arena and that the arena will outlive any users of this
/// ``ArenaAllocatedBufferPointer``.
public init(_ buffer: UnsafeBufferPointer<Element>) {
self.buffer = buffer
}
/// Create a buffer over the same memory as the given buffer slice.
public init(rebasing slice: Self.SubSequence) {
self.buffer = UnsafeBufferPointer(
start: slice.base.baseAddress?.advanced(by: slice.startIndex),
count: slice.count
)
}
public subscript(_ index: Int) -> Element {
return self.buffer[index]
}
public func makeIterator() -> UnsafeBufferPointer<Element>.Iterator {
return buffer.makeIterator()
}
public var startIndex: Int { buffer.startIndex }
public var endIndex: Int { buffer.endIndex }
public func index(after i: Int) -> Int {
return buffer.index(after: i)
}
public func index(before i: Int) -> Int {
return buffer.index(before: i)
}
public var count: Int {
return buffer.count
}
public var isEmpty: Bool {
return buffer.isEmpty
}
var baseAddress: UnsafePointer<Element>? {
return buffer.baseAddress
}
var unsafeRawBufferPointer: UnsafeRawBufferPointer {
return UnsafeRawBufferPointer(buffer)
}
public func withContiguousStorageIfAvailable<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R? {
try body(buffer)
}
public func _copyContents(initializing ptr: UnsafeMutableBufferPointer<Element>) -> (Iterator, Int) {
buffer._copyContents(initializing: ptr)
}
}
|
