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
|
// RUN: %target-swift-emit-sil \
// RUN: %s \
// RUN: -enable-builtin-module \
// RUN: -sil-verify-all \
// RUN: -verify
// Check that a simple version of the noncopyable linked list works through the
// SIL pipeline.
struct List<Element>: ~Copyable {
struct Node: ~Copyable {
var element: Element
var next: Link
}
enum Link: ~Copyable {
case empty
case more(Box<Node>)
}
var head: Link = .empty
deinit {
dumpList(self)
var head = self.head // self is immutable so a local variable must be introduced
while case .more(let box) = consume head {
head = box.move().next
}
}
}
func dumpList<Element>(_ l: borrowing List<Element>) {}
struct Box<Wrapped: ~Copyable>: ~Copyable {
private let _pointer: MyLittlePointer<Wrapped>
init(_ element: consuming Wrapped) {
_pointer = .allocate(capacity: 1)
_pointer.initialize(to: element)
}
deinit {
_pointer.deinitialize(count: 1)
_pointer.deallocate()
}
consuming func move() -> Wrapped {
let wrapped = _pointer.move()
_pointer.deallocate()
discard self
return wrapped
}
}
// Standalone version of MemoryLayout + UnsafeMutablePointer with noncopyable T.
import Builtin
@frozen
public enum MyLittleLayout<T : ~Copyable> {
@_transparent
public static var size: Int {
return Int(Builtin.sizeof(T.self))
}
@_transparent
public static var stride: Int {
return Int(Builtin.strideof(T.self))
}
}
struct MyLittlePointer<Pointee : ~Copyable> : Copyable {
public let _rawValue: Builtin.RawPointer
@_transparent
public init(_ _rawValue: Builtin.RawPointer) {
self._rawValue = _rawValue
}
@inlinable
public static func allocate(capacity count: Int)
-> MyLittlePointer<Pointee> {
let size = MyLittleLayout<Pointee>.stride * count
let align = (0)._builtinWordValue
let rawPtr = Builtin.allocRaw(size._builtinWordValue, align)
Builtin.bindMemory(rawPtr, count._builtinWordValue, Pointee.self)
return MyLittlePointer(rawPtr)
}
@inlinable
public func deallocate() {
Builtin.deallocRaw(_rawValue, (-1)._builtinWordValue, (0)._builtinWordValue)
}
@inlinable
public func initialize(to value: consuming Pointee) {
Builtin.initialize(value, self._rawValue)
}
@inlinable
public func deinitialize(count: Int) {
Builtin.destroyArray(Pointee.self, _rawValue, count._builtinWordValue)
}
@inlinable
public func move() -> Pointee {
return Builtin.take(_rawValue)
}
}
|
