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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-feature -Xfrontend MoveOnlyEnumDeinits -Xfrontend -sil-verify-all) | %FileCheck %s --implicit-check-not closing
// RUN: %target-run-simple-swift(-O -Xfrontend -enable-experimental-feature -Xfrontend MoveOnlyEnumDeinits -Xfrontend -sil-verify-all) | %FileCheck %s --implicit-check-not closing
// REQUIRES: executable_test
// NOTE: it's important that this test has the `--implicit-check-not closing` flag to catch double deinits!!
// you also want to make sure all messages start with "closing"
func posix_close(_ x: Int) { print("closing file descriptor: \(x)") }
func print_closing_MFD() { print("closing MaybeFileDescriptor") }
enum E: Error { case err }
struct FileDescriptor: ~Copyable {
var fd: Int
static var nextFD: Int = 0
consuming func discard() { discard self }
init() {
self.fd = FileDescriptor.nextFD
FileDescriptor.nextFD += 1
}
init(doDiscard: Bool) throws {
self.init()
if doDiscard {
discard()
throw E.err
}
}
__consuming func close() {
posix_close(fd)
discard self
}
__consuming func justDiscard() {
discard self
}
__consuming func empty() {}
var takeFileDescriptorWrong : Int {
__consuming get {
return fd
}
}
var takeFileDescriptorRight : Int {
__consuming get {
let x = fd
discard self
return x
}
}
deinit {
posix_close(fd)
}
}
enum MaybeFileDescriptor: ~Copyable {
case some(FileDescriptor)
case nothing
consuming func discard() { discard self }
init(reinit: Bool) {
self = .some(FileDescriptor())
if reinit {
discard()
self = .some(FileDescriptor())
}
}
__consuming func skipDeinit() {
discard self
}
deinit {
// we can't do a borrowed switch yet so this is just printing some message
print_closing_MFD()
}
}
struct SillyEmptyGeneric<T>: ~Copyable {
consuming func identity(_ t: T) -> T {
discard self
return t
}
deinit { fatalError("ran unexpectedly!") }
}
struct SingleMutableField: ~Copyable {
var value = 0
consuming func justDiscard() {
discard self
}
deinit {
print("SingleMutableField.deinit")
}
}
// rdar://110232973 ([move-only] Checker should distinguish in between
// field of single field struct vs parent field itself (was: mutation
// of field in noncopyable struct should not trigger deinit))
//
// This test must not be in a closure.
@inline(never)
func testSingleMutableFieldNoMemberReinit() {
var x = SingleMutableField()
x.value = 20 // should not trigger deinit.
// CHECK-NOT: SingleMutableField.deinit
x.justDiscard()
}
func main() {
testSingleMutableFieldNoMemberReinit()
let _ = {
let x = FileDescriptor() // 0
x.close()
// CHECK: closing file descriptor: 0
}()
let _ = {
let _ = FileDescriptor() // 1
// CHECK: closing file descriptor: 1
}()
let _ = {
let x = FileDescriptor() // 2
x.justDiscard()
}()
let _ = {
let x = FileDescriptor() // 3
x.empty()
// CHECK: closing file descriptor: 3
}()
let _ = {
let x = FileDescriptor() // 4
_ = x.takeFileDescriptorWrong
// CHECK: closing file descriptor: 4
}()
let _ = {
let x = FileDescriptor() // 5
_ = x.takeFileDescriptorRight
}()
let _ = {
do {
// should throw before getting to close()
let x = try FileDescriptor(doDiscard: true) // 6
x.close()
} catch {}
}()
let _ = {
do {
let x = try FileDescriptor(doDiscard: false) // 7
x.close()
} catch {}
// CHECK: closing file descriptor: 7
}()
let _ = {
let _ = MaybeFileDescriptor(reinit: true) // 8 & 9
// CHECK: closing file descriptor: 8
// CHECK: closing MaybeFileDescriptor
// CHECK: closing file descriptor: 9
}()
let _ = {
let x = MaybeFileDescriptor(reinit: true) // 10 & 11
x.skipDeinit() // this skips the enum's deinit, not the file descriptor's!
// CHECK: closing file descriptor: 10
// CHECK: closing file descriptor: 11
}()
let _ = {
var maybe = MaybeFileDescriptor.nothing
maybe = .some(FileDescriptor()) // 12
// CHECK: closing MaybeFileDescriptor
// CHECK: closing MaybeFileDescriptor
// CHECK: closing file descriptor: 12
}()
let _ = {
let x = MaybeFileDescriptor(reinit: false) // 13
x.skipDeinit() // this skips the enum's deinit, not the file descriptor's!
// CHECK: closing file descriptor: 13
}()
let _ = {
let x = SillyEmptyGeneric<[Int]>()
let z = [1, 2]
let ans = x.identity(z)
assert(z == ans)
}()
}
main()
|
