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
|
// RUN: %target-swift-emit-sil -sil-verify-all -verify -enable-experimental-feature NoImplicitCopy %s
// This testStruct specifically testStructs how DI and the move checkers interact with each other
func testStructSimpleNoInit() {
struct M: ~Copyable {
private let i: Int // expected-note {{'self.i' not initialized}}
// No initialization. Should get DI error and no crash.
init() {
} // expected-error {{return from initializer without initializing all stored properties}}
}
}
func testStructSimplePartialInit() {
struct M: ~Copyable {
private let i: Int
private let i2: Int // expected-note {{'self.i2' not initialized}}
init() {
i = 5
} // expected-error {{return from initializer without initializing all stored properties}}
}
}
func testStructSimplePartialInit2() {
struct M: ~Copyable {
private let i: Int = 5
private let i2: Int // expected-note {{'self.i2' not initialized}}
init() {
} // expected-error {{return from initializer without initializing all stored properties}}
}
}
func testStructGenericNoInit() {
struct M<T>: ~Copyable {
private let i: T // expected-note {{'self.i' not initialized}}
init() {
} // expected-error {{return from initializer without initializing all stored properties}}
}
}
func testStructGenericPartialInit() {
struct M<T>: ~Copyable {
private let i: T
private let i2: T // expected-note {{'self.i2' not initialized}}
init(_ t: T) {
self.i = t
} // expected-error {{return from initializer without initializing all stored properties}}
}
}
func testEnumNoInit() {
enum E : ~Copyable {
case first
case second
init() {
} // expected-error {{'self.init' isn't called on all paths before returning from initializer}}
}
}
func testEnumNoInitWithPayload() {
@_moveOnly struct Empty {}
enum E : ~Copyable {
case first(Empty)
case second
init() {
} // expected-error {{'self.init' isn't called on all paths before returning from initializer}}
}
}
func testEnumNoInitWithGenericPayload() {
@_moveOnly struct Empty {}
enum E<T> : ~Copyable {
case first(Empty)
case second(T)
init() {
} // expected-error {{'self.init' isn't called on all paths before returning from initializer}}
}
}
// This test doesn't actually test anything today... but once the memory
// lifetime verifier runs on ref_element_addr, this would assert in _Box<T>.init
// since we were not setting the mark_unresolved_non_copyable_value to initable_but_not_assignable.
fileprivate final class _Box<T> {
var value: _Node<T>
init(_ value: consuming _Node<T>) { self.value = value }
}
struct _Node<T> : ~Copyable {
var value: T
var _next: ListEntry<T> = ListEntry<T>()
init(_ newValue: T) {
value = newValue
}
}
/// A noncopyable box that contains the memory for a linked list node. Can be
/// embedded within other noncopyable data structures to point at a Node data
/// structure.
///
/// Internally uses a class as the actual box.
struct ListEntry<T> : ~Copyable {
private var innerBox: _Box<T>?
init() { innerBox = nil }
}
|
