Clang Project

clang_source_code/test/SemaCXX/uninitialized.cpp
1// RUN: %clang_cc1 -fsyntax-only -Wall -Wuninitialized -Wno-unused-value -Wno-unused-lambda-capture -std=c++1z -verify %s
2
3// definitions for std::move
4namespace std {
5inline namespace foo {
6template <class T> struct remove_reference { typedef T type; };
7template <class T> struct remove_reference<T&> { typedef T type; };
8template <class T> struct remove_reference<T&&> { typedef T type; };
9
10template <class T> typename remove_reference<T>::type&& move(T&& t);
11}
12}
13
14int foo(int x);
15int bar(int* x);
16int boo(int& x);
17int far(const int& x);
18int moved(int&& x);
19int &ref(int x);
20
21// Test self-references within initializers which are guaranteed to be
22// uninitialized.
23int a = a; // no-warning: used to signal intended lack of initialization.
24int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
25int c = (c + c); // expected-warning 2 {{variable 'c' is uninitialized when used within its own initialization}}
26int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
27int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
28
29// These don't warn as they don't require the value.
30int g = sizeof(g);
31void* ptr = &ptr;
32int h = bar(&h);
33int i = boo(i);
34int j = far(j);
35int k = __alignof__(k);
36
37int l = k ? l : l;  // expected-warning 2{{variable 'l' is uninitialized when used within its own initialization}}
38int m = 1 + (k ? m : m);  // expected-warning 2{{variable 'm' is uninitialized when used within its own initialization}}
39int n = -n;  // expected-warning {{variable 'n' is uninitialized when used within its own initialization}}
40int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}}
41const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}}
42int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}}
43int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}}
44int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}}
45int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}}
46int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}}
47int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}}
48int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}}
49int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
50int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}}
51int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}}
52int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}}
53int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}}
54
55void test_stuff () {
56  int a = a; // no-warning: used to signal intended lack of initialization.
57  int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
58  int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
59  int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}}
60  int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
61  int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
62
63  // These don't warn as they don't require the value.
64  int g = sizeof(g);
65  void* ptr = &ptr;
66  int h = bar(&h);
67  int i = boo(i);
68  int j = far(j);
69  int k = __alignof__(k);
70
71  int l = k ? l : l;  // expected-warning {{variable 'l' is uninitialized when used within its own initialization}}
72  int m = 1 + (k ? m : m);  // expected-warning {{'m' is uninitialized when used within its own initialization}}
73  int n = -n;  // expected-warning {{variable 'n' is uninitialized when used within its own initialization}}
74  int o = std::move(o);  // expected-warning {{variable 'o' is uninitialized when used within its own initialization}}
75  const int p = std::move(p);  // expected-warning {{variable 'p' is uninitialized when used within its own initialization}}
76  int q = moved(std::move(q));  // expected-warning {{variable 'q' is uninitialized when used within its own initialization}}
77  int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}}
78  int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}}
79  int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}}
80  int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}}
81  int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}}
82  int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}}
83  int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
84  int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}}
85  int z = ++ref(z);                              // expected-warning {{variable 'z' is uninitialized when used within its own initialization}}
86  int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}}
87  int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}}
88
89  for (;;) {
90    int a = a; // no-warning: used to signal intended lack of initialization.
91    int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
92    int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
93    int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}}
94    int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
95    int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
96
97    // These don't warn as they don't require the value.
98    int g = sizeof(g);
99    void* ptr = &ptr;
100    int h = bar(&h);
101    int i = boo(i);
102    int j = far(j);
103    int k = __alignof__(k);
104
105    int l = k ? l : l;  // expected-warning {{variable 'l' is uninitialized when used within its own initialization}}
106    int m = 1 + (k ? m : m);  // expected-warning {{'m' is uninitialized when used within its own initialization}}
107    int n = -n;  // expected-warning {{variable 'n' is uninitialized when used within its own initialization}}
108    int o = std::move(o);  // expected-warning {{variable 'o' is uninitialized when used within its own initialization}}
109    const int p = std::move(p);  // expected-warning {{variable 'p' is uninitialized when used within its own initialization}}
110    int q = moved(std::move(q));  // expected-warning {{variable 'q' is uninitialized when used within its own initialization}}
111    int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}}
112    int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}}
113    int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}}
114    int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}}
115    int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}}
116    int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}}
117    int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
118    int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}}
119    int z = ++ref(z);                              // expected-warning {{variable 'z' is uninitialized when used within its own initialization}}
120    int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}}
121    int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}}
122
123  }
124}
125
126void test_comma() {
127  int a;  // expected-note {{initialize the variable 'a' to silence this warning}}
128  int b = (a, a ?: 2);  // expected-warning {{variable 'a' is uninitialized when used here}}
129  int c = (a, a, b, c);  // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
130  int d;  // expected-note {{initialize the variable 'd' to silence this warning}}
131  int e = (foo(d), e, b); // expected-warning {{variable 'd' is uninitialized when used here}}
132  int f;  // expected-note {{initialize the variable 'f' to silence this warning}}
133  f = f + 1, 2;  // expected-warning {{variable 'f' is uninitialized when used here}}
134  int h;
135  int g = (h, g, 2);  // no-warning: h, g are evaluated but not used.
136}
137
138namespace member_ptr {
139struct A {
140  int x;
141  int y;
142  A(int x) : x{x} {}
143};
144
145void test_member_ptr() {
146  int A::* px = &A::x;
147  A a{a.*px}; // expected-warning {{variable 'a' is uninitialized when used within its own initialization}}
148  A b = b; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
149}
150}
151
152namespace const_ptr {
153void foo(int *a);
154void bar(const int *a);
155void foobar(const int **a);
156
157void test_const_ptr() {
158  int a;
159  int b;  // expected-note {{initialize the variable 'b' to silence this warning}}
160  foo(&a);
161  bar(&b);
162  b = a + b; // expected-warning {{variable 'b' is uninitialized when used here}}
163  int *ptr;  //expected-note {{initialize the variable 'ptr' to silence this warning}}
164  const int *ptr2;
165  foo(ptr); // expected-warning {{variable 'ptr' is uninitialized when used here}}
166  foobar(&ptr2);
167}
168}
169
170// Also test similar constructs in a field's initializer.
171struct S {
172  int x;
173  int y;
174  const int z = 5;
175  void *ptr;
176
177  S(bool (*)[1]) : x(x) {} // expected-warning {{field 'x' is uninitialized when used here}}
178  S(bool (*)[2]) : x(x + 1) {} // expected-warning {{field 'x' is uninitialized when used here}}
179  S(bool (*)[3]) : x(x + x) {} // expected-warning 2{{field 'x' is uninitialized when used here}}
180  S(bool (*)[4]) : x(static_cast<long>(x) + 1) {} // expected-warning {{field 'x' is uninitialized when used here}}
181  S(bool (*)[5]) : x(foo(x)) {} // expected-warning {{field 'x' is uninitialized when used here}}
182
183  // These don't actually require the value of x and so shouldn't warn.
184  S(char (*)[1]) : x(sizeof(x)) {} // rdar://8610363
185  S(char (*)[2]) : ptr(&ptr) {}
186  S(char (*)[3]) : x(bar(&x)) {}
187  S(char (*)[4]) : x(boo(x)) {}
188  S(char (*)[5]) : x(far(x)) {}
189  S(char (*)[6]) : x(__alignof__(x)) {}
190
191  S(int (*)[1]) : x(0), y(x ? y : y) {} // expected-warning 2{{field 'y' is uninitialized when used here}}
192  S(int (*)[2]) : x(0), y(1 + (x ? y : y)) {} // expected-warning 2{{field 'y' is uninitialized when used here}}
193  S(int (*)[3]) : x(-x) {} // expected-warning {{field 'x' is uninitialized when used here}}
194  S(int (*)[4]) : x(std::move(x)) {} // expected-warning {{field 'x' is uninitialized when used here}}
195  S(int (*)[5]) : z(std::move(z)) {} // expected-warning {{field 'z' is uninitialized when used here}}
196  S(int (*)[6]) : x(moved(std::move(x))) {} // expected-warning {{field 'x' is uninitialized when used here}}
197  S(int (*)[7]) : x(0), y(std::move((x ? x : (18, y)))) {} // expected-warning {{field 'y' is uninitialized when used here}}
198  S(int (*)[8]) : x(0), y(x ?: y) {} // expected-warning {{field 'y' is uninitialized when used here}}
199  S(int (*)[9]) : x(0), y(y ?: x) {} // expected-warning {{field 'y' is uninitialized when used here}}
200  S(int (*)[10]) : x(0), y((foo(y), x)) {} // expected-warning {{field 'y' is uninitialized when used here}}
201  S(int (*)[11]) : x(0), y(x += y) {} // expected-warning {{field 'y' is uninitialized when used here}}
202  S(int (*)[12]) : x(x += 10) {} // expected-warning {{field 'x' is uninitialized when used here}}
203  S(int (*)[13]) : x(x++) {} // expected-warning {{field 'x' is uninitialized when used here}}
204  S(int (*)[14]) : x(0), y(((x ? (y, x) : (77, y))++, sizeof(y))) {} // expected-warning {{field 'y' is uninitialized when used here}}
205  S(int (*)[15]) : x(++ref(x)) {} // expected-warning {{field 'x' is uninitialized when used here}}
206  S(int (*)[16]) : x((ref(x) += 10)) {} // expected-warning {{field 'x' is uninitialized when used here}}
207  S(int (*)[17]) : x(0), y(y ? x : x) {} // expected-warning {{field 'y' is uninitialized when used here}}
208};
209
210// Test self-references with record types.
211class A {
212  // Non-POD class.
213  public:
214    enum count { ONE, TWO, THREE };
215    int num;
216    static int count;
217    int get() const { return num; }
218    int get2() { return num; }
219    int set(int x) { num = x; return num; }
220    static int zero() { return 0; }
221
222    A() {}
223    A(A const &a) {}
224    A(int x) {}
225    A(int *x) {}
226    A(A *a) {}
227    A(A &&a) {}
228    ~A();
229    bool operator!();
230    bool operator!=(const A&);
231};
232
233bool operator!=(int, const A&);
234
235A getA() { return A(); }
236A getA(int x) { return A(); }
237A getA(A* a) { return A(); }
238A getA(A a) { return A(); }
239A moveA(A&& a) { return A(); }
240A const_refA(const A& a) { return A(); }
241
242void setupA(bool x) {
243  A a1;
244  a1.set(a1.get());
245  A a2(a1.get());
246  A a3(a1);
247  A a4(&a4);
248  A a5(a5.zero());
249  A a6(a6.ONE);
250  A a7 = getA();
251  A a8 = getA(a8.TWO);
252  A a9 = getA(&a9);
253  A a10(a10.count);
254
255  A a11(a11);  // expected-warning {{variable 'a11' is uninitialized when used within its own initialization}}
256  A a12(a12.get());  // expected-warning {{variable 'a12' is uninitialized when used within its own initialization}}
257  A a13(a13.num);  // expected-warning {{variable 'a13' is uninitialized when used within its own initialization}}
258  A a14 = A(a14);  // expected-warning {{variable 'a14' is uninitialized when used within its own initialization}}
259  A a15 = getA(a15.num);  // expected-warning {{variable 'a15' is uninitialized when used within its own initialization}}
260  A a16(&a16.num);  // expected-warning {{variable 'a16' is uninitialized when used within its own initialization}}
261  A a17(a17.get2());  // expected-warning {{variable 'a17' is uninitialized when used within its own initialization}}
262  A a18 = x ? a18 : a17;  // expected-warning {{variable 'a18' is uninitialized when used within its own initialization}}
263  A a19 = getA(x ? a19 : a17);  // expected-warning {{variable 'a19' is uninitialized when used within its own initialization}}
264  A a20{a20};  // expected-warning {{variable 'a20' is uninitialized when used within its own initialization}}
265  A a21 = {a21};  // expected-warning {{variable 'a21' is uninitialized when used within its own initialization}}
266
267  // FIXME: Make the local uninitialized warning consistent with the global
268  // uninitialized checking.
269  A *a22 = new A(a22->count);  // expected-warning {{variable 'a22' is uninitialized when used within its own initialization}}
270  A *a23 = new A(a23->ONE);  // expected-warning {{variable 'a23' is uninitialized when used within its own initialization}}
271  A *a24 = new A(a24->TWO);  // expected-warning {{variable 'a24' is uninitialized when used within its own initialization}}
272  A *a25 = new A(a25->zero());  // expected-warning {{variable 'a25' is uninitialized when used within its own initialization}}
273
274  A *a26 = new A(a26->get());    // expected-warning {{variable 'a26' is uninitialized when used within its own initialization}}
275  A *a27 = new A(a27->get2());  // expected-warning {{variable 'a27' is uninitialized when used within its own initialization}}
276  A *a28 = new A(a28->num);  // expected-warning {{variable 'a28' is uninitialized when used within its own initialization}}
277
278  const A a29(a29);  // expected-warning {{variable 'a29' is uninitialized when used within its own initialization}}
279  const A a30 = a30;  // expected-warning {{variable 'a30' is uninitialized when used within its own initialization}}
280
281  A a31 = std::move(a31);  // expected-warning {{variable 'a31' is uninitialized when used within its own initialization}}
282  A a32 = moveA(std::move(a32));  // expected-warning {{variable 'a32' is uninitialized when used within its own initialization}}
283  A a33 = A(std::move(a33));   // expected-warning {{variable 'a33' is uninitialized when used within its own initialization}}
284  A a34(std::move(a34));   // expected-warning {{variable 'a34' is uninitialized when used within its own initialization}}
285  A a35 = std::move(x ? a34 : (37, a35));  // expected-warning {{variable 'a35' is uninitialized when used within its own initialization}}
286
287  A a36 = const_refA(a36);
288  A a37(const_refA(a37));
289
290  A a38({a38});  // expected-warning {{variable 'a38' is uninitialized when used within its own initialization}}
291  A a39 = {a39};  // expected-warning {{variable 'a39' is uninitialized when used within its own initialization}}
292  A a40 = A({a40});  // expected-warning {{variable 'a40' is uninitialized when used within its own initialization}}
293
294  A a41 = !a41;  // expected-warning {{variable 'a41' is uninitialized when used within its own initialization}}
295  A a42 = !(a42);  // expected-warning {{variable 'a42' is uninitialized when used within its own initialization}}
296  A a43 = a43 != a42;  // expected-warning {{variable 'a43' is uninitialized when used within its own initialization}}
297  A a44 = a43 != a44;  // expected-warning {{variable 'a44' is uninitialized when used within its own initialization}}
298  A a45 = a45 != a45;  // expected-warning 2{{variable 'a45' is uninitialized when used within its own initialization}}
299  A a46 = 0 != a46;  // expected-warning {{variable 'a46' is uninitialized when used within its own initialization}}
300
301  A a47(a47.set(a47.num));  // expected-warning 2{{variable 'a47' is uninitialized when used within its own initialization}}
302  A a48(a47.set(a48.num));  // expected-warning {{variable 'a48' is uninitialized when used within its own initialization}}
303  A a49(a47.set(a48.num));
304}
305
306bool cond;
307
308A a1;
309A a2(a1.get());
310A a3(a1);
311A a4(&a4);
312A a5(a5.zero());
313A a6(a6.ONE);
314A a7 = getA();
315A a8 = getA(a8.TWO);
316A a9 = getA(&a9);
317A a10(a10.count);
318
319A a11(a11);  // expected-warning {{variable 'a11' is uninitialized when used within its own initialization}}
320A a12(a12.get());  // expected-warning {{variable 'a12' is uninitialized when used within its own initialization}}
321A a13(a13.num);  // expected-warning {{variable 'a13' is uninitialized when used within its own initialization}}
322A a14 = A(a14);  // expected-warning {{variable 'a14' is uninitialized when used within its own initialization}}
323A a15 = getA(a15.num);  // expected-warning {{variable 'a15' is uninitialized when used within its own initialization}}
324A a16(&a16.num);  // expected-warning {{variable 'a16' is uninitialized when used within its own initialization}}
325A a17(a17.get2());  // expected-warning {{variable 'a17' is uninitialized when used within its own initialization}}
326A a18 = cond ? a18 : a17;  // expected-warning {{variable 'a18' is uninitialized when used within its own initialization}}
327A a19 = getA(cond ? a19 : a17);  // expected-warning {{variable 'a19' is uninitialized when used within its own initialization}}
328A a20{a20};  // expected-warning {{variable 'a20' is uninitialized when used within its own initialization}}
329A a21 = {a21};  // expected-warning {{variable 'a21' is uninitialized when used within its own initialization}}
330
331A *a22 = new A(a22->count);
332A *a23 = new A(a23->ONE);
333A *a24 = new A(a24->TWO);
334A *a25 = new A(a25->zero());
335
336A *a26 = new A(a26->get());    // expected-warning {{variable 'a26' is uninitialized when used within its own initialization}}
337A *a27 = new A(a27->get2());  // expected-warning {{variable 'a27' is uninitialized when used within its own initialization}}
338A *a28 = new A(a28->num);  // expected-warning {{variable 'a28' is uninitialized when used within its own initialization}}
339
340const A a29(a29);  // expected-warning {{variable 'a29' is uninitialized when used within its own initialization}}
341const A a30 = a30;  // expected-warning {{variable 'a30' is uninitialized when used within its own initialization}}
342
343A a31 = std::move(a31);  // expected-warning {{variable 'a31' is uninitialized when used within its own initialization}}
344A a32 = moveA(std::move(a32));  // expected-warning {{variable 'a32' is uninitialized when used within its own initialization}}
345A a33 = A(std::move(a33));   // expected-warning {{variable 'a33' is uninitialized when used within its own initialization}}
346A a34(std::move(a34));   // expected-warning {{variable 'a34' is uninitialized when used within its own initialization}}
347A a35 = std::move(x ? a34 : (37, a35));  // expected-warning {{variable 'a35' is uninitialized when used within its own initialization}}
348
349A a36 = const_refA(a36);
350A a37(const_refA(a37));
351
352A a38({a38});  // expected-warning {{variable 'a38' is uninitialized when used within its own initialization}}
353A a39 = {a39};  // expected-warning {{variable 'a39' is uninitialized when used within its own initialization}}
354A a40 = A({a40});  // expected-warning {{variable 'a40' is uninitialized when used within its own initialization}}
355
356A a41 = !a41;  // expected-warning {{variable 'a41' is uninitialized when used within its own initialization}}
357A a42 = !(a42);  // expected-warning {{variable 'a42' is uninitialized when used within its own initialization}}
358A a43 = a43 != a42;  // expected-warning {{variable 'a43' is uninitialized when used within its own initialization}}
359A a44 = a43 != a44;  // expected-warning {{variable 'a44' is uninitialized when used within its own initialization}}
360A a45 = a45 != a45;  // expected-warning 2{{variable 'a45' is uninitialized when used within its own initialization}}
361
362A a46 = 0 != a46;  // expected-warning {{variable 'a46' is uninitialized when used within its own initialization}}
363
364A a47(a47.set(a47.num));  // expected-warning 2{{variable 'a47' is uninitialized when used within its own initialization}}
365A a48(a47.set(a48.num));  // expected-warning {{variable 'a48' is uninitialized when used within its own initialization}}
366A a49(a47.set(a48.num));
367
368class T {
369  A a, a2;
370  const A c_a;
371  A* ptr_a;
372
373  T() {}
374  T(bool (*)[1]) : a() {}
375  T(bool (*)[2]) : a2(a.get()) {}
376  T(bool (*)[3]) : a2(a) {}
377  T(bool (*)[4]) : a(&a) {}
378  T(bool (*)[5]) : a(a.zero()) {}
379  T(bool (*)[6]) : a(a.ONE) {}
380  T(bool (*)[7]) : a(getA()) {}
381  T(bool (*)[8]) : a2(getA(a.TWO)) {}
382  T(bool (*)[9]) : a(getA(&a)) {}
383  T(bool (*)[10]) : a(a.count) {}
384
385  T(bool (*)[11]) : a(a) {}  // expected-warning {{field 'a' is uninitialized when used here}}
386  T(bool (*)[12]) : a(a.get()) {}  // expected-warning {{field 'a' is uninitialized when used here}}
387  T(bool (*)[13]) : a(a.num) {}  // expected-warning {{field 'a' is uninitialized when used here}}
388  T(bool (*)[14]) : a(A(a)) {}  // expected-warning {{field 'a' is uninitialized when used here}}
389  T(bool (*)[15]) : a(getA(a.num)) {}  // expected-warning {{field 'a' is uninitialized when used here}}
390  T(bool (*)[16]) : a(&a.num) {}  // expected-warning {{field 'a' is uninitialized when used here}}
391  T(bool (*)[17]) : a(a.get2()) {}  // expected-warning {{field 'a' is uninitialized when used here}}
392  T(bool (*)[18]) : a2(cond ? a2 : a) {}  // expected-warning {{field 'a2' is uninitialized when used here}}
393  T(bool (*)[19]) : a2(cond ? a2 : a) {}  // expected-warning {{field 'a2' is uninitialized when used here}}
394  T(bool (*)[20]) : a{a} {}  // expected-warning {{field 'a' is uninitialized when used here}}
395  T(bool (*)[21]) : a({a}) {}  // expected-warning {{field 'a' is uninitialized when used here}}
396
397  T(bool (*)[22]) : ptr_a(new A(ptr_a->count)) {}
398  T(bool (*)[23]) : ptr_a(new A(ptr_a->ONE)) {}
399  T(bool (*)[24]) : ptr_a(new A(ptr_a->TWO)) {}
400  T(bool (*)[25]) : ptr_a(new A(ptr_a->zero())) {}
401
402  T(bool (*)[26]) : ptr_a(new A(ptr_a->get())) {}  // expected-warning {{field 'ptr_a' is uninitialized when used here}}
403  T(bool (*)[27]) : ptr_a(new A(ptr_a->get2())) {}  // expected-warning {{field 'ptr_a' is uninitialized when used here}}
404  T(bool (*)[28]) : ptr_a(new A(ptr_a->num)) {}  // expected-warning {{field 'ptr_a' is uninitialized when used here}}
405
406  T(bool (*)[29]) : c_a(c_a) {}  // expected-warning {{field 'c_a' is uninitialized when used here}}
407  T(bool (*)[30]) : c_a(A(c_a)) {}  // expected-warning {{field 'c_a' is uninitialized when used here}}
408
409  T(bool (*)[31]) : a(std::move(a)) {}  // expected-warning {{field 'a' is uninitialized when used here}}
410  T(bool (*)[32]) : a(moveA(std::move(a))) {}  // expected-warning {{field 'a' is uninitialized when used here}}
411  T(bool (*)[33]) : a(A(std::move(a))) {}  // expected-warning {{field 'a' is uninitialized when used here}}
412  T(bool (*)[34]) : a(A(std::move(a))) {}  // expected-warning {{field 'a' is uninitialized when used here}}
413  T(bool (*)[35]) : a2(std::move(x ? a : (37, a2))) {}  // expected-warning {{field 'a2' is uninitialized when used here}}
414
415  T(bool (*)[36]) : a(const_refA(a)) {}
416  T(bool (*)[37]) : a(A(const_refA(a))) {}
417
418  T(bool (*)[38]) : a({a}) {}  // expected-warning {{field 'a' is uninitialized when used here}}
419  T(bool (*)[39]) : a{a} {}  // expected-warning {{field 'a' is uninitialized when used here}}
420  T(bool (*)[40]) : a({a}) {}  // expected-warning {{field 'a' is uninitialized when used here}}
421
422  T(bool (*)[41]) : a(!a) {}  // expected-warning {{field 'a' is uninitialized when used here}}
423  T(bool (*)[42]) : a(!(a)) {}  // expected-warning {{field 'a' is uninitialized when used here}}
424  T(bool (*)[43]) : a(), a2(a2 != a) {}  // expected-warning {{field 'a2' is uninitialized when used here}}
425  T(bool (*)[44]) : a(), a2(a != a2) {}  // expected-warning {{field 'a2' is uninitialized when used here}}
426  T(bool (*)[45]) : a(a != a) {}  // expected-warning 2{{field 'a' is uninitialized when used here}}
427  T(bool (*)[46]) : a(0 != a) {}  // expected-warning {{field 'a' is uninitialized when used here}}
428
429  T(bool (*)[47]) : a2(a2.set(a2.num)) {}  // expected-warning 2{{field 'a2' is uninitialized when used here}}
430  T(bool (*)[48]) : a2(a.set(a2.num)) {}  // expected-warning {{field 'a2' is uninitialized when used here}}
431  T(bool (*)[49]) : a2(a.set(a.num)) {}
432
433};
434
435struct B {
436  // POD struct.
437  int x;
438  int *y;
439};
440
441B getB() { return B(); };
442B getB(int x) { return B(); };
443B getB(int *x) { return B(); };
444B getB(B *b) { return B(); };
445B moveB(B &&b) { return B(); };
446
447B* getPtrB() { return 0; };
448B* getPtrB(int x) { return 0; };
449B* getPtrB(int *x) { return 0; };
450B* getPtrB(B **b) { return 0; };
451
452void setupB(bool x) {
453  B b1;
454  B b2(b1);
455  B b3 = { 5, &b3.x };
456  B b4 = getB();
457  B b5 = getB(&b5);
458  B b6 = getB(&b6.x);
459
460  // Silence unused warning
461  (void) b2;
462  (void) b4;
463
464  B b7(b7);  // expected-warning {{variable 'b7' is uninitialized when used within its own initialization}}
465  B b8 = getB(b8.x);  // expected-warning {{variable 'b8' is uninitialized when used within its own initialization}}
466  B b9 = getB(b9.y);  // expected-warning {{variable 'b9' is uninitialized when used within its own initialization}}
467  B b10 = getB(-b10.x);  // expected-warning {{variable 'b10' is uninitialized when used within its own initialization}}
468
469  B* b11 = 0;
470  B* b12(b11);
471  B* b13 = getPtrB();
472  B* b14 = getPtrB(&b14);
473
474  (void) b12;
475  (void) b13;
476
477  B* b15 = getPtrB(b15->x);  // expected-warning {{variable 'b15' is uninitialized when used within its own initialization}}
478  B* b16 = getPtrB(b16->y);  // expected-warning {{variable 'b16' is uninitialized when used within its own initialization}}
479
480  B b17 = { b17.x = 5, b17.y = 0 };
481  B b18 = { b18.x + 1, b18.y };  // expected-warning 2{{variable 'b18' is uninitialized when used within its own initialization}}
482
483  const B b19 = b19;  // expected-warning {{variable 'b19' is uninitialized when used within its own initialization}}
484  const B b20(b20);  // expected-warning {{variable 'b20' is uninitialized when used within its own initialization}}
485
486  B b21 = std::move(b21);  // expected-warning {{variable 'b21' is uninitialized when used within its own initialization}}
487  B b22 = moveB(std::move(b22));  // expected-warning {{variable 'b22' is uninitialized when used within its own initialization}}
488  B b23 = B(std::move(b23));   // expected-warning {{variable 'b23' is uninitialized when used within its own initialization}}
489  B b24 = std::move(x ? b23 : (18, b24));  // expected-warning {{variable 'b24' is uninitialized when used within its own initialization}}
490}
491
492B b1;
493B b2(b1);
494B b3 = { 5, &b3.x };
495B b4 = getB();
496B b5 = getB(&b5);
497B b6 = getB(&b6.x);
498
499B b7(b7);  // expected-warning {{variable 'b7' is uninitialized when used within its own initialization}}
500B b8 = getB(b8.x);  // expected-warning {{variable 'b8' is uninitialized when used within its own initialization}}
501B b9 = getB(b9.y);  // expected-warning {{variable 'b9' is uninitialized when used within its own initialization}}
502B b10 = getB(-b10.x);  // expected-warning {{variable 'b10' is uninitialized when used within its own initialization}}
503
504B* b11 = 0;
505B* b12(b11);
506B* b13 = getPtrB();
507B* b14 = getPtrB(&b14);
508
509B* b15 = getPtrB(b15->x);  // expected-warning {{variable 'b15' is uninitialized when used within its own initialization}}
510B* b16 = getPtrB(b16->y);  // expected-warning {{variable 'b16' is uninitialized when used within its own initialization}}
511
512B b17 = { b17.x = 5, b17.y = 0 };
513B b18 = { b18.x + 1, b18.y };  // expected-warning 2{{variable 'b18' is uninitialized when used within its own initialization}}
514
515const B b19 = b19;  // expected-warning {{variable 'b19' is uninitialized when used within its own initialization}}
516const B b20(b20);  // expected-warning {{variable 'b20' is uninitialized when used within its own initialization}}
517
518B b21 = std::move(b21);  // expected-warning {{variable 'b21' is uninitialized when used within its own initialization}}
519B b22 = moveB(std::move(b22));  // expected-warning {{variable 'b22' is uninitialized when used within its own initialization}}
520B b23 = B(std::move(b23));   // expected-warning {{variable 'b23' is uninitialized when used within its own initialization}}
521B b24 = std::move(x ? b23 : (18, b24));  // expected-warning {{variable 'b24' is uninitialized when used within its own initialization}}
522
523class U {
524  B b1, b2;
525  B *ptr1, *ptr2;
526  const B constb = {};
527
528  U() {}
529  U(bool (*)[1]) : b1() {}
530  U(bool (*)[2]) : b2(b1) {}
531  U(bool (*)[3]) : b1{ 5, &b1.x } {}
532  U(bool (*)[4]) : b1(getB()) {}
533  U(bool (*)[5]) : b1(getB(&b1)) {}
534  U(bool (*)[6]) : b1(getB(&b1.x)) {}
535
536  U(bool (*)[7]) : b1(b1) {}  // expected-warning {{field 'b1' is uninitialized when used here}}
537  U(bool (*)[8]) : b1(getB(b1.x)) {}  // expected-warning {{field 'b1' is uninitialized when used here}}
538  U(bool (*)[9]) : b1(getB(b1.y)) {}  // expected-warning {{field 'b1' is uninitialized when used here}}
539  U(bool (*)[10]) : b1(getB(-b1.x)) {}  // expected-warning {{field 'b1' is uninitialized when used here}}
540
541  U(bool (*)[11]) : ptr1(0) {}
542  U(bool (*)[12]) : ptr1(0), ptr2(ptr1) {}
543  U(bool (*)[13]) : ptr1(getPtrB()) {}
544  U(bool (*)[14]) : ptr1(getPtrB(&ptr1)) {}
545
546  U(bool (*)[15]) : ptr1(getPtrB(ptr1->x)) {}  // expected-warning {{field 'ptr1' is uninitialized when used here}}
547  U(bool (*)[16]) : ptr2(getPtrB(ptr2->y)) {}  // expected-warning {{field 'ptr2' is uninitialized when used here}}
548
549  U(bool (*)[17]) : b1 { b1.x = 5, b1.y = 0 } {}
550  U(bool (*)[18]) : b1 { b1.x + 1, b1.y } {}  // expected-warning 2{{field 'b1' is uninitialized when used here}}
551
552  U(bool (*)[19]) : constb(constb) {}  // expected-warning {{field 'constb' is uninitialized when used here}}
553  U(bool (*)[20]) : constb(B(constb)) {}  // expected-warning {{field 'constb' is uninitialized when used here}}
554
555  U(bool (*)[21]) : b1(std::move(b1)) {}  // expected-warning {{field 'b1' is uninitialized when used here}}
556  U(bool (*)[22]) : b1(moveB(std::move(b1))) {}  // expected-warning {{field 'b1' is uninitialized when used here}}
557  U(bool (*)[23]) : b1(B(std::move(b1))) {}  // expected-warning {{field 'b1' is uninitialized when used here}}
558  U(bool (*)[24]) : b2(std::move(x ? b1 : (18, b2))) {}  // expected-warning {{field 'b2' is uninitialized when used here}}
559};
560
561struct C { char a[100], *e; } car = { .e = car.a };
562
563// <rdar://problem/10398199>
564namespace rdar10398199 {
565  class FooBase { protected: ~FooBase() {} };
566  class Foo : public FooBase {
567  public:
568    operator int&() const;
569  };
570  void stuff();
571  template <typename T> class FooImpl : public Foo {
572    T val;
573  public:
574    FooImpl(const T &x) : val(x) {}
575    ~FooImpl() { stuff(); }
576  };
577
578  template <typename T> FooImpl<T> makeFoo(const T& x) {
579    return FooImpl<T>(x);
580  }
581
582  void test() {
583    const Foo &x = makeFoo(42);
584    const int&y = makeFoo(42u);
585    (void)x;
586    (void)y;
587  };
588}
589
590// PR 12325 - this was a false uninitialized value warning due to
591// a broken CFG.
592int pr12325(int params) {
593  int x = ({
594    while (false)
595      ;
596    int _v = params;
597    if (false)
598      ;
599    _v; // no-warning
600  });
601  return x;
602}
603
604// Test lambda expressions with -Wuninitialized
605int test_lambda() {
606  auto f1 = [] (int x, int y) { int z; return x + y + z; }; // expected-warning{{variable 'z' is uninitialized when used here}} expected-note {{initialize the variable 'z' to silence this warning}}
607  return f1(1, 2);
608}
609
610namespace {
611  struct A {
612    enum { A1 };
613    static int A2() {return 5;}
614    int A3;
615    int A4() { return 5;}
616  };
617
618  struct B {
619    A a;
620  };
621
622  struct C {
623    C() {}
624    C(int x) {}
625    static A a;
626    B b;
627  };
628  A C::a = A();
629
630  // Accessing non-static members will give a warning.
631  struct D {
632    C c;
633    D(char (*)[1]) : c(c.b.a.A1) {}
634    D(char (*)[2]) : c(c.b.a.A2()) {}
635    D(char (*)[3]) : c(c.b.a.A3) {}    // expected-warning {{field 'c' is uninitialized when used here}}
636    D(char (*)[4]) : c(c.b.a.A4()) {}  // expected-warning {{field 'c' is uninitialized when used here}}
637
638    // c::a is static, so it is already initialized
639    D(char (*)[5]) : c(c.a.A1) {}
640    D(char (*)[6]) : c(c.a.A2()) {}
641    D(char (*)[7]) : c(c.a.A3) {}
642    D(char (*)[8]) : c(c.a.A4()) {}
643  };
644
645  struct E {
646    int b = 1;
647    int c = 1;
648    int a;  // This field needs to be last to prevent the cross field
649            // uninitialized warning.
650    E(char (*)[1]) : a(a ? b : c) {}  // expected-warning {{field 'a' is uninitialized when used here}}
651    E(char (*)[2]) : a(b ? a : a) {} // expected-warning 2{{field 'a' is uninitialized when used here}}
652    E(char (*)[3]) : a(b ? (a) : c) {} // expected-warning {{field 'a' is uninitialized when used here}}
653    E(char (*)[4]) : a(b ? c : (a+c)) {} // expected-warning {{field 'a' is uninitialized when used here}}
654    E(char (*)[5]) : a(b ? c : b) {}
655
656    E(char (*)[6]) : a(a ?: a) {} // expected-warning 2{{field 'a' is uninitialized when used here}}
657    E(char (*)[7]) : a(b ?: a) {} // expected-warning {{field 'a' is uninitialized when used here}}
658    E(char (*)[8]) : a(a ?: c) {} // expected-warning {{field 'a' is uninitialized when used here}}
659    E(char (*)[9]) : a(b ?: c) {}
660
661    E(char (*)[10]) : a((a, a, b)) {}
662    E(char (*)[11]) : a((c + a, a + 1, b)) {} // expected-warning 2{{field 'a' is uninitialized when used here}}
663    E(char (*)[12]) : a((b + c, c, a)) {} // expected-warning {{field 'a' is uninitialized when used here}}
664    E(char (*)[13]) : a((a, a, a, a)) {} // expected-warning {{field 'a' is uninitialized when used here}}
665    E(char (*)[14]) : a((b, c, c)) {}
666    E(char (*)[15]) : a(b ?: a) {} // expected-warning {{field 'a' is uninitialized when used here}}
667    E(char (*)[16]) : a(a ?: b) {} // expected-warning {{field 'a' is uninitialized when used here}}
668  };
669
670  struct F {
671    int a;
672    F* f;
673    F(int) {}
674    F() {}
675  };
676
677  int F::*ptr = &F::a;
678  F* F::*f_ptr = &F::f;
679  struct G {
680    F f1, f2;
681    F *f3, *f4;
682    G(char (*)[1]) : f1(f1) {} // expected-warning {{field 'f1' is uninitialized when used here}}
683    G(char (*)[2]) : f2(f1) {}
684    G(char (*)[3]) : f2(F()) {}
685
686    G(char (*)[4]) : f1(f1.*ptr) {} // expected-warning {{field 'f1' is uninitialized when used here}}
687    G(char (*)[5]) : f2(f1.*ptr) {}
688
689    G(char (*)[6]) : f3(f3) {}  // expected-warning {{field 'f3' is uninitialized when used here}}
690    G(char (*)[7]) : f3(f3->*f_ptr) {} // expected-warning {{field 'f3' is uninitialized when used here}}
691    G(char (*)[8]) : f3(new F(f3->*ptr)) {} // expected-warning {{field 'f3' is uninitialized when used here}}
692  };
693
694  struct H {
695    H() : a(a) {}  // expected-warning {{field 'a' is uninitialized when used here}}
696    const A a;
697  };
698}
699
700namespace statics {
701  static int a = a; // no-warning: used to signal intended lack of initialization.
702  static int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
703  static int c = (c + c); // expected-warning 2{{variable 'c' is uninitialized when used within its own initialization}}
704  static int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
705  static int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
706
707  // These don't warn as they don't require the value.
708  static int g = sizeof(g);
709  int gg = g;  // Silence unneeded warning
710  static void* ptr = &ptr;
711  static int h = bar(&h);
712  static int i = boo(i);
713  static int j = far(j);
714  static int k = __alignof__(k);
715
716  static int l = k ? l : l;  // expected-warning 2{{variable 'l' is uninitialized when used within its own initialization}}
717  static int m = 1 + (k ? m : m);  // expected-warning 2{{variable 'm' is uninitialized when used within its own initialization}}
718  static int n = -n;  // expected-warning {{variable 'n' is uninitialized when used within its own initialization}}
719  static int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}}
720  static const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}}
721  static int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}}
722  static int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}}
723  static int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}}
724  static int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}}
725  static int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}}
726  static int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}}
727  static int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}}
728  static int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
729  static int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}}
730  static int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}}
731  static int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}}
732  static int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}}
733
734
735  void test() {
736    static int a = a; // no-warning: used to signal intended lack of initialization.
737    static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}}
738    static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}}
739    static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}}
740    static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
741    static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
742
743    // These don't warn as they don't require the value.
744    static int g = sizeof(g);
745    static void* ptr = &ptr;
746    static int h = bar(&h);
747    static int i = boo(i);
748    static int j = far(j);
749    static int k = __alignof__(k);
750
751    static int l = k ? l : l;  // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}}
752    static int m = 1 + (k ? m : m);  // expected-warning 2{{static variable 'm' is suspiciously used within its own initialization}}
753    static int n = -n;  // expected-warning {{static variable 'n' is suspiciously used within its own initialization}}
754    static int o = std::move(o);  // expected-warning {{static variable 'o' is suspiciously used within its own initialization}}
755    static const int p = std::move(p);  // expected-warning {{static variable 'p' is suspiciously used within its own initialization}}
756    static int q = moved(std::move(q));  // expected-warning {{static variable 'q' is suspiciously used within its own initialization}}
757    static int r = std::move((p ? q : (18, r)));  // expected-warning {{static variable 'r' is suspiciously used within its own initialization}}
758    static int s = r ?: s;  // expected-warning {{static variable 's' is suspiciously used within its own initialization}}
759    static int t = t ?: s;  // expected-warning {{static variable 't' is suspiciously used within its own initialization}}
760    static int u = (foo(u), s);  // expected-warning {{static variable 'u' is suspiciously used within its own initialization}}
761    static int v = (u += v);  // expected-warning {{static variable 'v' is suspiciously used within its own initialization}}
762    static int w = (w += 10);  // expected-warning {{static variable 'w' is suspiciously used within its own initialization}}
763    static int x = x++;  // expected-warning {{static variable 'x' is suspiciously used within its own initialization}}
764    static int y = ((s ? (y, v) : (77, y))++, sizeof(y));  // expected-warning {{static variable 'y' is suspiciously used within its own initialization}}
765    static int z = ++ref(z); // expected-warning {{static variable 'z' is suspiciously used within its own initialization}}
766    static int aa = (ref(aa) += 10); // expected-warning {{static variable 'aa' is suspiciously used within its own initialization}}
767    static int bb = bb ? x : y; // expected-warning {{static variable 'bb' is suspiciously used within its own initialization}}
768
769    for (;;) {
770      static int a = a; // no-warning: used to signal intended lack of initialization.
771      static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}}
772      static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}}
773      static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}}
774      static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
775      static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
776
777      // These don't warn as they don't require the value.
778      static int g = sizeof(g);
779      static void* ptr = &ptr;
780      static int h = bar(&h);
781      static int i = boo(i);
782      static int j = far(j);
783      static int k = __alignof__(k);
784
785      static int l = k ? l : l;  // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}}
786      static int m = 1 + (k ? m : m); // expected-warning 2{{static variable 'm' is suspiciously used within its own initialization}}
787      static int n = -n;  // expected-warning {{static variable 'n' is suspiciously used within its own initialization}}
788      static int o = std::move(o);  // expected-warning {{static variable 'o' is suspiciously used within its own initialization}}
789      static const int p = std::move(p);  // expected-warning {{static variable 'p' is suspiciously used within its own initialization}}
790      static int q = moved(std::move(q));  // expected-warning {{static variable 'q' is suspiciously used within its own initialization}}
791      static int r = std::move((p ? q : (18, r)));  // expected-warning {{static variable 'r' is suspiciously used within its own initialization}}
792      static int s = r ?: s;  // expected-warning {{static variable 's' is suspiciously used within its own initialization}}
793      static int t = t ?: s;  // expected-warning {{static variable 't' is suspiciously used within its own initialization}}
794      static int u = (foo(u), s);  // expected-warning {{static variable 'u' is suspiciously used within its own initialization}}
795      static int v = (u += v);  // expected-warning {{static variable 'v' is suspiciously used within its own initialization}}
796      static int w = (w += 10);  // expected-warning {{static variable 'w' is suspiciously used within its own initialization}}
797      static int x = x++;  // expected-warning {{static variable 'x' is suspiciously used within its own initialization}}
798      static int y = ((s ? (y, v) : (77, y))++, sizeof(y));  // expected-warning {{static variable 'y' is suspiciously used within its own initialization}}
799      static int z = ++ref(z); // expected-warning {{static variable 'z' is suspiciously used within its own initialization}}
800      static int aa = (ref(aa) += 10); // expected-warning {{static variable 'aa' is suspiciously used within its own initialization}}
801      static int bb = bb ? x : y; // expected-warning {{static variable 'bb' is suspiciously used within its own initialization}}
802    }
803  }
804}
805
806namespace in_class_initializers {
807  struct S {
808    S() : a(a + 1) {} // expected-warning{{field 'a' is uninitialized when used here}}
809    int a = 42; // Note: because a is in a member initializer list, this initialization is ignored.
810  };
811
812  struct T {
813    T() : b(a + 1) {} // No-warning.
814    int a = 42;
815    int b;
816  };
817
818  struct U {
819    U() : a(b + 1), b(a + 1) {} // expected-warning{{field 'b' is uninitialized when used here}}
820    int a = 42; // Note: because a and b are in the member initializer list, these initializers are ignored.
821    int b = 1;
822  };
823}
824
825namespace references {
826  int &a = a; // expected-warning{{reference 'a' is not yet bound to a value when used within its own initialization}}
827  int &b(b); // expected-warning{{reference 'b' is not yet bound to a value when used within its own initialization}}
828  int &c = a ? b : c; // expected-warning{{reference 'c' is not yet bound to a value when used within its own initialization}}
829  int &d{d}; // expected-warning{{reference 'd' is not yet bound to a value when used within its own initialization}}
830  int &e = d ?: e; // expected-warning{{reference 'e' is not yet bound to a value when used within its own initialization}}
831  int &f = f ?: d; // expected-warning{{reference 'f' is not yet bound to a value when used within its own initialization}}
832
833  int &return_ref1(int);
834  int &return_ref2(int&);
835
836  int &g = return_ref1(g); // expected-warning{{reference 'g' is not yet bound to a value when used within its own initialization}}
837  int &h = return_ref2(h); // expected-warning{{reference 'h' is not yet bound to a value when used within its own initialization}}
838
839  struct S {
840    S() : a(a) {} // expected-warning{{reference 'a' is not yet bound to a value when used here}}
841    int &a;
842  };
843
844  void test() {
845    int &a = a; // expected-warning{{reference 'a' is not yet bound to a value when used within its own initialization}}
846    int &b(b); // expected-warning{{reference 'b' is not yet bound to a value when used within its own initialization}}
847    int &c = a ? b : c; // expected-warning{{reference 'c' is not yet bound to a value when used within its own initialization}}
848    int &d{d}; // expected-warning{{reference 'd' is not yet bound to a value when used within its own initialization}}
849  }
850
851  struct T {
852    T() // expected-note{{during field initialization in this constructor}}
853     : a(b), b(a) {} // expected-warning{{reference 'b' is not yet bound to a value when used here}}
854    int &a, &b;
855    int &c = c; // expected-warning{{reference 'c' is not yet bound to a value when used here}}
856  };
857
858  int x;
859  struct U {
860    U() : b(a) {} // No-warning.
861    int &a = x;
862    int &b;
863  };
864}
865
866namespace operators {
867  struct A {
868    A(bool);
869    bool operator==(A);
870  };
871
872  A makeA();
873
874  A a1 = a1 = makeA();  // expected-warning{{variable 'a1' is uninitialized when used within its own initialization}}
875  A a2 = a2 == a1;  // expected-warning{{variable 'a2' is uninitialized when used within its own initialization}}
876  A a3 = a2 == a3;  // expected-warning{{variable 'a3' is uninitialized when used within its own initialization}}
877
878  int x = x = 5;
879}
880
881namespace lambdas {
882  struct A {
883    template<typename T> A(T) {}
884    int x;
885  };
886  A a0([] { return a0.x; }); // ok
887  void f() {
888    A a1([=] { // expected-warning{{variable 'a1' is uninitialized when used within its own initialization}}
889      return a1.x;
890    });
891    A a2([&] { return a2.x; }); // ok
892  }
893}
894
895namespace record_fields {
896  bool x;
897  struct A {
898    A() {}
899    A get();
900    static A num();
901    static A copy(A);
902    static A something(A&);
903  };
904
905  A ref(A&);
906  A const_ref(const A&);
907  A pointer(A*);
908  A normal(A);
909  A rref(A&&);
910
911  struct B {
912    A a;
913    B(char (*)[1]) : a(a) {}  // expected-warning {{uninitialized}}
914    B(char (*)[2]) : a(a.get()) {}  // expected-warning {{uninitialized}}
915    B(char (*)[3]) : a(a.num()) {}
916    B(char (*)[4]) : a(a.copy(a)) {}  // expected-warning {{uninitialized}}
917    B(char (*)[5]) : a(a.something(a)) {}
918    B(char (*)[6]) : a(ref(a)) {}
919    B(char (*)[7]) : a(const_ref(a)) {}
920    B(char (*)[8]) : a(pointer(&a)) {}
921    B(char (*)[9]) : a(normal(a)) {}  // expected-warning {{uninitialized}}
922    B(char (*)[10]) : a(std::move(a)) {}  // expected-warning {{uninitialized}}
923    B(char (*)[11]) : a(A(std::move(a))) {}  // expected-warning {{uninitialized}}
924    B(char (*)[12]) : a(rref(std::move(a))) {}  // expected-warning {{uninitialized}}
925    B(char (*)[13]) : a(std::move(x ? a : (25, a))) {}  // expected-warning 2{{uninitialized}}
926  };
927  struct C {
928    C() {} // expected-note9{{in this constructor}}
929    A a1 = a1;  // expected-warning {{uninitialized}}
930    A a2 = a2.get();  // expected-warning {{uninitialized}}
931    A a3 = a3.num();
932    A a4 = a4.copy(a4);  // expected-warning {{uninitialized}}
933    A a5 = a5.something(a5);
934    A a6 = ref(a6);
935    A a7 = const_ref(a7);
936    A a8 = pointer(&a8);
937    A a9 = normal(a9);  // expected-warning {{uninitialized}}
938    const A a10 = a10;  // expected-warning {{uninitialized}}
939    A a11 = std::move(a11);  // expected-warning {{uninitialized}}
940    A a12 = A(std::move(a12));  // expected-warning {{uninitialized}}
941    A a13 = rref(std::move(a13));  // expected-warning {{uninitialized}}
942    A a14 = std::move(x ? a13 : (22, a14));  // expected-warning {{uninitialized}}
943  };
944  struct D {  // expected-note9{{in the implicit default constructor}}
945    A a1 = a1;  // expected-warning {{uninitialized}}
946    A a2 = a2.get();  // expected-warning {{uninitialized}}
947    A a3 = a3.num();
948    A a4 = a4.copy(a4);  // expected-warning {{uninitialized}}
949    A a5 = a5.something(a5);
950    A a6 = ref(a6);
951    A a7 = const_ref(a7);
952    A a8 = pointer(&a8);
953    A a9 = normal(a9);  // expected-warning {{uninitialized}}
954    const A a10 = a10;  // expected-warning {{uninitialized}}
955    A a11 = std::move(a11);  // expected-warning {{uninitialized}}
956    A a12 = A(std::move(a12));  // expected-warning {{uninitialized}}
957    A a13 = rref(std::move(a13));  // expected-warning {{uninitialized}}
958    A a14 = std::move(x ? a13 : (22, a14));  // expected-warning {{uninitialized}}
959  };
960  D d; // expected-note {{in implicit default constructor for 'record_fields::D' first required here}}
961  struct E {
962    A a1 = a1;
963    A a2 = a2.get();
964    A a3 = a3.num();
965    A a4 = a4.copy(a4);
966    A a5 = a5.something(a5);
967    A a6 = ref(a6);
968    A a7 = const_ref(a7);
969    A a8 = pointer(&a8);
970    A a9 = normal(a9);
971    const A a10 = a10;
972    A a11 = std::move(a11);
973    A a12 = A(std::move(a12));
974    A a13 = rref(std::move(a13));
975    A a14 = std::move(x ? a13 : (22, a14));
976  };
977}
978
979namespace cross_field_warnings {
980  struct A {
981    int a, b;
982    A() {}
983    A(char (*)[1]) : b(a) {}  // expected-warning{{field 'a' is uninitialized when used here}}
984    A(char (*)[2]) : a(b) {}  // expected-warning{{field 'b' is uninitialized when used here}}
985  };
986
987  struct B {
988    int a = b;  // expected-warning{{field 'b' is uninitialized when used here}}
989    int b;
990    B() {} // expected-note{{during field initialization in this constructor}}
991  };
992
993  struct C {
994    int a;
995    int b = a;  // expected-warning{{field 'a' is uninitialized when used here}}
996    C(char (*)[1]) : a(5) {}
997    C(char (*)[2]) {} // expected-note{{during field initialization in this constructor}}
998  };
999
1000  struct D {
1001    int a;
1002    int &b;
1003    int &c = a;
1004    int d = b;
1005    D() : b(a) {}
1006  };
1007
1008  struct E {
1009    int a;
1010    int get();
1011    static int num();
1012    E() {}
1013    E(int) {}
1014  };
1015
1016  struct F {
1017    int a;
1018    E e;
1019    int b;
1020    F(char (*)[1]) : a(e.get()) {}  // expected-warning{{field 'e' is uninitialized when used here}}
1021    F(char (*)[2]) : a(e.num()) {}
1022    F(char (*)[3]) : e(a) {}  // expected-warning{{field 'a' is uninitialized when used here}}
1023    F(char (*)[4]) : a(4), e(a) {}
1024    F(char (*)[5]) : e(b) {}  // expected-warning{{field 'b' is uninitialized when used here}}
1025    F(char (*)[6]) : e(b), b(4) {}  // expected-warning{{field 'b' is uninitialized when used here}}
1026  };
1027
1028  struct G {
1029    G(const A&) {};
1030  };
1031
1032  struct H {
1033    A a1;
1034    G g;
1035    A a2;
1036    H() : g(a1) {}
1037    H(int) : g(a2) {}
1038  };
1039
1040  struct I {
1041    I(int*) {}
1042  };
1043
1044  struct J : public I {
1045    int *a;
1046    int *b;
1047    int c;
1048    J() : I((a = new int(5))), b(a), c(*a) {}
1049  };
1050
1051  struct K {
1052    int a = (b = 5);
1053    int b = b + 5;
1054  };
1055
1056  struct L {
1057    int a = (b = 5);
1058    int b = b + 5;  // expected-warning{{field 'b' is uninitialized when used here}}
1059    L() : a(5) {}  // expected-note{{during field initialization in this constructor}}
1060  };
1061
1062  struct M { };
1063
1064  struct N : public M {
1065    int a;
1066    int b;
1067    N() : b(a) { }  // expected-warning{{field 'a' is uninitialized when used here}}
1068  };
1069
1070  struct O {
1071    int x = 42;
1072    int get() { return x; }
1073  };
1074
1075  struct P {
1076    O o;
1077    int x = o.get();
1078    P() : x(o.get()) { }
1079  };
1080
1081  struct Q {
1082    int a;
1083    int b;
1084    int &c;
1085    Q() :
1086      a(c = 5),  // expected-warning{{reference 'c' is not yet bound to a value when used here}}
1087      b(c),  // expected-warning{{reference 'c' is not yet bound to a value when used here}}
1088      c(a) {}
1089  };
1090
1091  struct R {
1092    int a;
1093    int b;
1094    int c;
1095    int d = a + b + c;
1096    R() : a(c = 5), b(c), c(a) {}
1097  };
1098
1099  // FIXME: Use the CFG-based analysis to give a sometimes uninitialized
1100  // warning on y.
1101  struct T {
1102    int x;
1103    int y;
1104    T(bool b)
1105        : x(b ? (y = 5) : (1 + y)),  // expected-warning{{field 'y' is uninitialized when used here}}
1106          y(y + 1) {}
1107    T(int b)
1108        : x(!b ? (1 + y) : (y = 5)),  // expected-warning{{field 'y' is uninitialized when used here}}
1109          y(y + 1) {}
1110  };
1111
1112}
1113
1114namespace base_class {
1115  struct A {
1116    A (int) {}
1117  };
1118
1119  struct B : public A {
1120    int x;
1121    B() : A(x) {}   // expected-warning{{field 'x' is uninitialized when used here}}
1122  };
1123
1124  struct C : public A {
1125    int x;
1126    int y;
1127    C() : A(y = 4), x(y) {}
1128  };
1129}
1130
1131namespace delegating_constructor {
1132  struct A {
1133    A(int);
1134    A(int&, int);
1135
1136    A(char (*)[1]) : A(x) {}
1137    // expected-warning@-1 {{field 'x' is uninitialized when used here}}
1138    A(char (*)[2]) : A(x, x) {}
1139    // expected-warning@-1 {{field 'x' is uninitialized when used here}}
1140
1141    A(char (*)[3]) : A(x, 0) {}
1142
1143    int x;
1144  };
1145}
1146
1147namespace init_list {
1148  int num = 5;
1149  struct A { int i1, i2; };
1150  struct B { A a1, a2; };
1151
1152  A a1{1,2};
1153  A a2{a2.i1 + 2};  // expected-warning{{uninitialized}}
1154  A a3 = {a3.i1 + 2};  // expected-warning{{uninitialized}}
1155  A a4 = A{a4.i2 + 2};  // expected-warning{{uninitialized}}
1156
1157  B b1 = { {}, {} };
1158  B b2 = { {}, b2.a1 };
1159  B b3 = { b3.a1 };  // expected-warning{{uninitialized}}
1160  B b4 = { {}, b4.a2} ;  // expected-warning{{uninitialized}}
1161  B b5 = { b5.a2 };  // expected-warning{{uninitialized}}
1162
1163  B b6 = { {b6.a1.i1} };  // expected-warning{{uninitialized}}
1164  B b7 = { {0, b7.a1.i1} };
1165  B b8 = { {}, {b8.a1.i1} };
1166  B b9 = { {}, {0, b9.a1.i1} };
1167
1168  B b10 = { {b10.a1.i2} };  // expected-warning{{uninitialized}}
1169  B b11 = { {0, b11.a1.i2} };  // expected-warning{{uninitialized}}
1170  B b12 = { {}, {b12.a1.i2} };
1171  B b13 = { {}, {0, b13.a1.i2} };
1172
1173  B b14 = { {b14.a2.i1} };  // expected-warning{{uninitialized}}
1174  B b15 = { {0, b15.a2.i1} };  // expected-warning{{uninitialized}}
1175  B b16 = { {}, {b16.a2.i1} };  // expected-warning{{uninitialized}}
1176  B b17 = { {}, {0, b17.a2.i1} };
1177
1178  B b18 = { {b18.a2.i2} };  // expected-warning{{uninitialized}}
1179  B b19 = { {0, b19.a2.i2} };  // expected-warning{{uninitialized}}
1180  B b20 = { {}, {b20.a2.i2} };  // expected-warning{{uninitialized}}
1181  B b21 = { {}, {0, b21.a2.i2} };  // expected-warning{{uninitialized}}
1182
1183  B b22 = { {b18.a2.i2 + 5} };
1184
1185  struct C {int a; int& b; int c; };
1186  C c1 = { 0, num, 0 };
1187  C c2 = { 1, num, c2.b };
1188  C c3 = { c3.b, num };  // expected-warning{{uninitialized}}
1189  C c4 = { 0, c4.b, 0 };  // expected-warning{{uninitialized}}
1190  C c5 = { 0, c5.c, 0 };
1191  C c6 = { c6.b, num, 0 };  // expected-warning{{uninitialized}}
1192  C c7 = { 0, c7.a, 0 };
1193
1194  struct D {int &a; int &b; };
1195  D d1 = { num, num };
1196  D d2 = { num, d2.a };
1197  D d3 = { d3.b, num };  // expected-warning{{uninitialized}}
1198
1199  // Same as above in member initializer form.
1200  struct Awrapper {
1201    A a1{1,2};
1202    A a2{a2.i1 + 2};  // expected-warning{{uninitialized}}
1203    A a3 = {a3.i1 + 2};  // expected-warning{{uninitialized}}
1204    A a4 = A{a4.i2 + 2};  // expected-warning{{uninitialized}}
1205    Awrapper() {}  // expected-note 3{{in this constructor}}
1206    Awrapper(int) :
1207      a1{1,2},
1208      a2{a2.i1 + 2},  // expected-warning{{uninitialized}}
1209      a3{a3.i1 + 2},  // expected-warning{{uninitialized}}
1210      a4{a4.i2 + 2}  // expected-warning{{uninitialized}}
1211    {}
1212  };
1213
1214  struct Bwrapper {
1215    B b1 = { {}, {} };
1216    B b2 = { {}, b2.a1 };
1217    B b3 = { b3.a1 };  // expected-warning{{uninitialized}}
1218    B b4 = { {}, b4.a2} ;  // expected-warning{{uninitialized}}
1219    B b5 = { b5.a2 };  // expected-warning{{uninitialized}}
1220
1221    B b6 = { {b6.a1.i1} };  // expected-warning{{uninitialized}}
1222    B b7 = { {0, b7.a1.i1} };
1223    B b8 = { {}, {b8.a1.i1} };
1224    B b9 = { {}, {0, b9.a1.i1} };
1225
1226    B b10 = { {b10.a1.i2} };  // expected-warning{{uninitialized}}
1227    B b11 = { {0, b11.a1.i2} };  // expected-warning{{uninitialized}}
1228    B b12 = { {}, {b12.a1.i2} };
1229    B b13 = { {}, {0, b13.a1.i2} };
1230
1231    B b14 = { {b14.a2.i1} };  // expected-warning{{uninitialized}}
1232    B b15 = { {0, b15.a2.i1} };  // expected-warning{{uninitialized}}
1233    B b16 = { {}, {b16.a2.i1} };  // expected-warning{{uninitialized}}
1234    B b17 = { {}, {0, b17.a2.i1} };
1235
1236    B b18 = { {b18.a2.i2} };  // expected-warning{{uninitialized}}
1237    B b19 = { {0, b19.a2.i2} };  // expected-warning{{uninitialized}}
1238    B b20 = { {}, {b20.a2.i2} };  // expected-warning{{uninitialized}}
1239    B b21 = { {}, {0, b21.a2.i2} };  // expected-warning{{uninitialized}}
1240
1241    B b22 = { {b18.a2.i2 + 5} };
1242    Bwrapper() {}  // expected-note 13{{in this constructor}}
1243    Bwrapper(int) :
1244      b1{ {}, {} },
1245      b2{ {}, b2.a1 },
1246      b3{ b3.a1 },  // expected-warning{{uninitialized}}
1247      b4{ {}, b4.a2}, // expected-warning{{uninitialized}}
1248      b5{ b5.a2 },  // expected-warning{{uninitialized}}
1249
1250      b6{ {b6.a1.i1} },  // expected-warning{{uninitialized}}
1251      b7{ {0, b7.a1.i1} },
1252      b8{ {}, {b8.a1.i1} },
1253      b9{ {}, {0, b9.a1.i1} },
1254
1255      b10{ {b10.a1.i2} },  // expected-warning{{uninitialized}}
1256      b11{ {0, b11.a1.i2} },  // expected-warning{{uninitialized}}
1257      b12{ {}, {b12.a1.i2} },
1258      b13{ {}, {0, b13.a1.i2} },
1259
1260      b14{ {b14.a2.i1} },  // expected-warning{{uninitialized}}
1261      b15{ {0, b15.a2.i1} },  // expected-warning{{uninitialized}}
1262      b16{ {}, {b16.a2.i1} },  // expected-warning{{uninitialized}}
1263      b17{ {}, {0, b17.a2.i1} },
1264
1265      b18{ {b18.a2.i2} },  // expected-warning{{uninitialized}}
1266      b19{ {0, b19.a2.i2} },  // expected-warning{{uninitialized}}
1267      b20{ {}, {b20.a2.i2} },  // expected-warning{{uninitialized}}
1268      b21{ {}, {0, b21.a2.i2} },  // expected-warning{{uninitialized}}
1269
1270      b22{ {b18.a2.i2 + 5} }
1271    {}
1272  };
1273
1274  struct Cwrapper {
1275    C c1 = { 0, num, 0 };
1276    C c2 = { 1, num, c2.b };
1277    C c3 = { c3.b, num };  // expected-warning{{uninitialized}}
1278    C c4 = { 0, c4.b, 0 };  // expected-warning{{uninitialized}}
1279    C c5 = { 0, c5.c, 0 };
1280    C c6 = { c6.b, num, 0 };  // expected-warning{{uninitialized}}
1281    C c7 = { 0, c7.a, 0 };
1282
1283    Cwrapper() {} // expected-note 3{{in this constructor}}
1284    Cwrapper(int) :
1285      c1{ 0, num, 0 },
1286      c2{ 1, num, c2.b },
1287      c3{ c3.b, num },  // expected-warning{{uninitialized}}
1288      c4{ 0, c4.b, 0 },  // expected-warning{{uninitialized}}
1289      c5{ 0, c5.c, 0 },
1290      c6{ c6.b, num, 0 },  // expected-warning{{uninitialized}}
1291      c7{ 0, c7.a, 0 }
1292    {}
1293  };
1294
1295  struct Dwrapper {
1296    D d1 = { num, num };
1297    D d2 = { num, d2.a };
1298    D d3 = { d3.b, num }; // expected-warning{{uninitialized}}
1299    Dwrapper() {}  // expected-note{{in this constructor}}
1300    Dwrapper(int) :
1301      d1{ num, num },
1302      d2{ num, d2.a },
1303      d3{ d3.b, num } // expected-warning{{uninitialized}}
1304    {}
1305  };
1306}
1307
1308namespace template_class {
1309class Foo {
1310 public:
1311    int *Create() { return nullptr; }
1312};
1313
1314template <typename T>
1315class A {
1316public:
1317  // Don't warn on foo here.
1318  A() : ptr(foo->Create()) {}
1319
1320private:
1321  Foo *foo = new Foo;
1322  int *ptr;
1323};
1324
1325template <typename T>
1326class B {
1327public:
1328  // foo is uninitialized here, but class B is never instantiated.
1329  B() : ptr(foo->Create()) {}
1330
1331private:
1332  Foo *foo;
1333  int *ptr;
1334};
1335
1336template <typename T>
1337class C {
1338public:
1339  C() : ptr(foo->Create()) {}
1340  // expected-warning@-1 {{field 'foo' is uninitialized when used here}}
1341private:
1342  Foo *foo;
1343  int *ptr;
1344};
1345
1346C<int> c;
1347// expected-note@-1 {{in instantiation of member function 'template_class::C<int>::C' requested here}}
1348
1349}
1350
1351namespace base_class_access {
1352struct A {
1353  A();
1354  A(int);
1355
1356  int i;
1357  int foo();
1358
1359  static int bar();
1360};
1361
1362struct B : public A {
1363  B(int (*)[1]) : A() {}
1364  B(int (*)[2]) : A(bar()) {}
1365
1366  B(int (*)[3]) : A(i) {}
1367  // expected-warning@-1 {{base class 'base_class_access::A' is uninitialized when used here to access 'base_class_access::A::i'}}
1368
1369  B(int (*)[4]) : A(foo()) {}
1370  // expected-warning@-1 {{base_class_access::A' is uninitialized when used here to access 'base_class_access::A::foo'}}
1371};
1372
1373struct C {
1374  C(int) {}
1375};
1376
1377struct D : public C, public A {
1378  D(int (*)[1]) : C(0) {}
1379  D(int (*)[2]) : C(bar()) {}
1380
1381  D(int (*)[3]) : C(i) {}
1382  // expected-warning@-1 {{base class 'base_class_access::A' is uninitialized when used here to access 'base_class_access::A::i'}}
1383
1384  D(int (*)[4]) : C(foo()) {}
1385  // expected-warning@-1 {{base_class_access::A' is uninitialized when used here to access 'base_class_access::A::foo'}}
1386};
1387
1388}
1389
1390namespace value {
1391template <class T> T move(T t);
1392template <class T> T notmove(T t);
1393}
1394namespace lvalueref {
1395template <class T> T move(T& t);
1396template <class T> T notmove(T& t);
1397}
1398namespace rvalueref {
1399template <class T> T move(T&& t);
1400template <class T> T notmove(T&& t);
1401}
1402
1403namespace move_test {
1404int a1 = std::move(a1); // expected-warning {{uninitialized}}
1405int a2 = value::move(a2); // expected-warning {{uninitialized}}
1406int a3 = value::notmove(a3); // expected-warning {{uninitialized}}
1407int a4 = lvalueref::move(a4);
1408int a5 = lvalueref::notmove(a5);
1409int a6 = rvalueref::move(a6);
1410int a7 = rvalueref::notmove(a7);
1411
1412void test() {
1413  int a1 = std::move(a1); // expected-warning {{uninitialized}}
1414  int a2 = value::move(a2); // expected-warning {{uninitialized}}
1415  int a3 = value::notmove(a3); // expected-warning {{uninitialized}}
1416  int a4 = lvalueref::move(a4);
1417  int a5 = lvalueref::notmove(a5);
1418  int a6 = rvalueref::move(a6);
1419  int a7 = rvalueref::notmove(a7);
1420}
1421
1422class A {
1423  int a;
1424  A(int (*) [1]) : a(std::move(a)) {} // expected-warning {{uninitialized}}
1425  A(int (*) [2]) : a(value::move(a)) {} // expected-warning {{uninitialized}}
1426  A(int (*) [3]) : a(value::notmove(a)) {} // expected-warning {{uninitialized}}
1427  A(int (*) [4]) : a(lvalueref::move(a)) {}
1428  A(int (*) [5]) : a(lvalueref::notmove(a)) {}
1429  A(int (*) [6]) : a(rvalueref::move(a)) {}
1430  A(int (*) [7]) : a(rvalueref::notmove(a)) {}
1431};
1432}
1433
1434void array_capture(bool b) {
1435  const char fname[] = "array_capture";
1436  if (b) {
1437    int unused; // expected-warning {{unused variable}}
1438  } else {
1439    [fname]{};
1440  }
1441}
1442
1443void if_switch_init_stmt(int k) {
1444  if (int n = 0; (n == k || k > 5)) {}
1445
1446  if (int n; (n == k || k > 5)) {} // expected-warning {{uninitialized}} expected-note {{initialize}}
1447
1448  switch (int n = 0; (n == k || k > 5)) {} // expected-warning {{boolean}}
1449
1450  switch (int n; (n == k || k > 5)) {} // expected-warning {{uninitialized}} expected-note {{initialize}} expected-warning {{boolean}}
1451}
1452
CodeThinker, Enjoy your reading code