shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity
llvm-project/clang/test/SemaCXX/uninitialized.cpp
Richard Smith c38498f046 PR23334: Perform semantic checking of lambda capture initialization in the right context. 
Previously we'd try to perform checks on the captures from the middle of
parsing the lambda's body, at the point where we detected that a variable
needed to be captured. This was wrong in a number of subtle ways. In
PR23334, we couldn't correctly handle the list of potential odr-uses
resulting from the capture, and our attempt to recover from that resulted
in a use-after-free.

We now defer building the initialization expression until we leave the lambda
body and return to the enclosing context, where the initialization does the
right thing. This patch only covers lambda-expressions, but we should apply
the same change to blocks and captured statements too.

llvm-svn: 235921
2015-04-27 21:27:54 +00:00

1440 lines
65 KiB
C++
Raw Blame History

// RUN: %clang_cc1 -fsyntax-only -Wall -Wuninitialized -Wno-unused-value -std=c++11 -verify %s
// definitions for std::move
namespace std {
inline namespace foo {
template <class T> struct remove_reference { typedef T type; };
template <class T> struct remove_reference<T&> { typedef T type; };
template <class T> struct remove_reference<T&&> { typedef T type; };
template <class T> typename remove_reference<T>::type&& move(T&& t);
}
}
int foo(int x);
int bar(int* x);
int boo(int& x);
int far(const int& x);
int moved(int&& x);
int &ref(int x);
// Test self-references within initializers which are guaranteed to be
// uninitialized.
int a = a; // no-warning: used to signal intended lack of initialization.
int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
int c = (c + c); // expected-warning 2 {{variable 'c' is uninitialized when used within its own initialization}}
int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
// Thes don't warn as they don't require the value.
int g = sizeof(g);
void* ptr = &ptr;
int h = bar(&h);
int i = boo(i);
int j = far(j);
int k = __alignof__(k);
int l = k ? l : l; // expected-warning 2{{variable 'l' is uninitialized when used within its own initialization}}
int m = 1 + (k ? m : m); // expected-warning 2{{variable 'm' is uninitialized when used within its own initialization}}
int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}}
int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}}
const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}}
int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}}
int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}}
int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}}
int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}}
int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}}
int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}}
int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}}
int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}}
int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}}
int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}}
int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}}
void test_stuff () {
int a = a; // no-warning: used to signal intended lack of initialization.
int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}}
int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
// Thes don't warn as they don't require the value.
int g = sizeof(g);
void* ptr = &ptr;
int h = bar(&h);
int i = boo(i);
int j = far(j);
int k = __alignof__(k);
int l = k ? l : l; // expected-warning {{variable 'l' is uninitialized when used within its own initialization}}
int m = 1 + (k ? m : m); // expected-warning {{'m' is uninitialized when used within its own initialization}}
int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}}
int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}}
const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}}
int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}}
int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}}
int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}}
int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}}
int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}}
int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}}
int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}}
int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}}
int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}}
int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}}
int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}}
for (;;) {
int a = a; // no-warning: used to signal intended lack of initialization.
int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}}
int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
// Thes don't warn as they don't require the value.
int g = sizeof(g);
void* ptr = &ptr;
int h = bar(&h);
int i = boo(i);
int j = far(j);
int k = __alignof__(k);
int l = k ? l : l; // expected-warning {{variable 'l' is uninitialized when used within its own initialization}}
int m = 1 + (k ? m : m); // expected-warning {{'m' is uninitialized when used within its own initialization}}
int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}}
int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}}
const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}}
int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}}
int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}}
int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}}
int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}}
int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}}
int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}}
int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}}
int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}}
int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}}
int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}}
int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}}
}
}
void test_comma() {
int a; // expected-note {{initialize the variable 'a' to silence this warning}}
int b = (a, a ?: 2); // expected-warning {{variable 'a' is uninitialized when used here}}
int c = (a, a, b, c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
int d; // expected-note {{initialize the variable 'd' to silence this warning}}
int e = (foo(d), e, b); // expected-warning {{variable 'd' is uninitialized when used here}}
int f; // expected-note {{initialize the variable 'f' to silence this warning}}
f = f + 1, 2; // expected-warning {{variable 'f' is uninitialized when used here}}
int h;
int g = (h, g, 2); // no-warning: h, g are evaluated but not used.
}
namespace member_ptr {
struct A {
int x;
int y;
A(int x) : x{x} {}
};
void test_member_ptr() {
int A::* px = &A::x;
A a{a.*px}; // expected-warning {{variable 'a' is uninitialized when used within its own initialization}}
A b = b; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
}
}
namespace const_ptr {
void foo(int *a);
void bar(const int *a);
void foobar(const int **a);
void test_const_ptr() {
int a;
int b; // expected-note {{initialize the variable 'b' to silence this warning}}
foo(&a);
bar(&b);
b = a + b; // expected-warning {{variable 'b' is uninitialized when used here}}
int *ptr; //expected-note {{initialize the variable 'ptr' to silence this warning}}
const int *ptr2;
foo(ptr); // expected-warning {{variable 'ptr' is uninitialized when used here}}
foobar(&ptr2);
}
}
// Also test similar constructs in a field's initializer.
struct S {
int x;
int y;
const int z = 5;
void *ptr;
S(bool (*)[1]) : x(x) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(bool (*)[2]) : x(x + 1) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(bool (*)[3]) : x(x + x) {} // expected-warning 2{{field 'x' is uninitialized when used here}}
S(bool (*)[4]) : x(static_cast<long>(x) + 1) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(bool (*)[5]) : x(foo(x)) {} // expected-warning {{field 'x' is uninitialized when used here}}
// These don't actually require the value of x and so shouldn't warn.
S(char (*)[1]) : x(sizeof(x)) {} // rdar://8610363
S(char (*)[2]) : ptr(&ptr) {}
S(char (*)[3]) : x(bar(&x)) {}
S(char (*)[4]) : x(boo(x)) {}
S(char (*)[5]) : x(far(x)) {}
S(char (*)[6]) : x(__alignof__(x)) {}
S(int (*)[1]) : x(0), y(x ? y : y) {} // expected-warning 2{{field 'y' is uninitialized when used here}}
S(int (*)[2]) : x(0), y(1 + (x ? y : y)) {} // expected-warning 2{{field 'y' is uninitialized when used here}}
S(int (*)[3]) : x(-x) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(int (*)[4]) : x(std::move(x)) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(int (*)[5]) : z(std::move(z)) {} // expected-warning {{field 'z' is uninitialized when used here}}
S(int (*)[6]) : x(moved(std::move(x))) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(int (*)[7]) : x(0), y(std::move((x ? x : (18, y)))) {} // expected-warning {{field 'y' is uninitialized when used here}}
S(int (*)[8]) : x(0), y(x ?: y) {} // expected-warning {{field 'y' is uninitialized when used here}}
S(int (*)[9]) : x(0), y(y ?: x) {} // expected-warning {{field 'y' is uninitialized when used here}}
S(int (*)[10]) : x(0), y((foo(y), x)) {} // expected-warning {{field 'y' is uninitialized when used here}}
S(int (*)[11]) : x(0), y(x += y) {} // expected-warning {{field 'y' is uninitialized when used here}}
S(int (*)[12]) : x(x += 10) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(int (*)[13]) : x(x++) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(int (*)[14]) : x(0), y(((x ? (y, x) : (77, y))++, sizeof(y))) {} // expected-warning {{field 'y' is uninitialized when used here}}
S(int (*)[15]) : x(++ref(x)) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(int (*)[16]) : x((ref(x) += 10)) {} // expected-warning {{field 'x' is uninitialized when used here}}
S(int (*)[17]) : x(0), y(y ? x : x) {} // expected-warning {{field 'y' is uninitialized when used here}}
};
// Test self-references with record types.
class A {
// Non-POD class.
public:
enum count { ONE, TWO, THREE };
int num;
static int count;
int get() const { return num; }
int get2() { return num; }
int set(int x) { num = x; return num; }
static int zero() { return 0; }
A() {}
A(A const &a) {}
A(int x) {}
A(int *x) {}
A(A *a) {}
A(A &&a) {}
~A();
bool operator!();
bool operator!=(const A&);
};
bool operator!=(int, const A&);
A getA() { return A(); }
A getA(int x) { return A(); }
A getA(A* a) { return A(); }
A getA(A a) { return A(); }
A moveA(A&& a) { return A(); }
A const_refA(const A& a) { return A(); }
void setupA(bool x) {
A a1;
a1.set(a1.get());
A a2(a1.get());
A a3(a1);
A a4(&a4);
A a5(a5.zero());
A a6(a6.ONE);
A a7 = getA();
A a8 = getA(a8.TWO);
A a9 = getA(&a9);
A a10(a10.count);
A a11(a11); // expected-warning {{variable 'a11' is uninitialized when used within its own initialization}}
A a12(a12.get()); // expected-warning {{variable 'a12' is uninitialized when used within its own initialization}}
A a13(a13.num); // expected-warning {{variable 'a13' is uninitialized when used within its own initialization}}
A a14 = A(a14); // expected-warning {{variable 'a14' is uninitialized when used within its own initialization}}
A a15 = getA(a15.num); // expected-warning {{variable 'a15' is uninitialized when used within its own initialization}}
A a16(&a16.num); // expected-warning {{variable 'a16' is uninitialized when used within its own initialization}}
A a17(a17.get2()); // expected-warning {{variable 'a17' is uninitialized when used within its own initialization}}
A a18 = x ? a18 : a17; // expected-warning {{variable 'a18' is uninitialized when used within its own initialization}}
A a19 = getA(x ? a19 : a17); // expected-warning {{variable 'a19' is uninitialized when used within its own initialization}}
A a20{a20}; // expected-warning {{variable 'a20' is uninitialized when used within its own initialization}}
A a21 = {a21}; // expected-warning {{variable 'a21' is uninitialized when used within its own initialization}}
// FIXME: Make the local uninitialized warning consistent with the global
// uninitialized checking.
A *a22 = new A(a22->count); // expected-warning {{variable 'a22' is uninitialized when used within its own initialization}}
A *a23 = new A(a23->ONE); // expected-warning {{variable 'a23' is uninitialized when used within its own initialization}}
A *a24 = new A(a24->TWO); // expected-warning {{variable 'a24' is uninitialized when used within its own initialization}}
A *a25 = new A(a25->zero()); // expected-warning {{variable 'a25' is uninitialized when used within its own initialization}}
A *a26 = new A(a26->get()); // expected-warning {{variable 'a26' is uninitialized when used within its own initialization}}
A *a27 = new A(a27->get2()); // expected-warning {{variable 'a27' is uninitialized when used within its own initialization}}
A *a28 = new A(a28->num); // expected-warning {{variable 'a28' is uninitialized when used within its own initialization}}
const A a29(a29); // expected-warning {{variable 'a29' is uninitialized when used within its own initialization}}
const A a30 = a30; // expected-warning {{variable 'a30' is uninitialized when used within its own initialization}}
A a31 = std::move(a31); // expected-warning {{variable 'a31' is uninitialized when used within its own initialization}}
A a32 = moveA(std::move(a32)); // expected-warning {{variable 'a32' is uninitialized when used within its own initialization}}
A a33 = A(std::move(a33)); // expected-warning {{variable 'a33' is uninitialized when used within its own initialization}}
A a34(std::move(a34)); // expected-warning {{variable 'a34' is uninitialized when used within its own initialization}}
A a35 = std::move(x ? a34 : (37, a35)); // expected-warning {{variable 'a35' is uninitialized when used within its own initialization}}
A a36 = const_refA(a36);
A a37(const_refA(a37));
A a38({a38}); // expected-warning {{variable 'a38' is uninitialized when used within its own initialization}}
A a39 = {a39}; // expected-warning {{variable 'a39' is uninitialized when used within its own initialization}}
A a40 = A({a40}); // expected-warning {{variable 'a40' is uninitialized when used within its own initialization}}
A a41 = !a41; // expected-warning {{variable 'a41' is uninitialized when used within its own initialization}}
A a42 = !(a42); // expected-warning {{variable 'a42' is uninitialized when used within its own initialization}}
A a43 = a43 != a42; // expected-warning {{variable 'a43' is uninitialized when used within its own initialization}}
A a44 = a43 != a44; // expected-warning {{variable 'a44' is uninitialized when used within its own initialization}}
A a45 = a45 != a45; // expected-warning 2{{variable 'a45' is uninitialized when used within its own initialization}}
A a46 = 0 != a46; // expected-warning {{variable 'a46' is uninitialized when used within its own initialization}}
A a47(a47.set(a47.num)); // expected-warning 2{{variable 'a47' is uninitialized when used within its own initialization}}
A a48(a47.set(a48.num)); // expected-warning {{variable 'a48' is uninitialized when used within its own initialization}}
A a49(a47.set(a48.num));
}
bool cond;
A a1;
A a2(a1.get());
A a3(a1);
A a4(&a4);
A a5(a5.zero());
A a6(a6.ONE);
A a7 = getA();
A a8 = getA(a8.TWO);
A a9 = getA(&a9);
A a10(a10.count);
A a11(a11); // expected-warning {{variable 'a11' is uninitialized when used within its own initialization}}
A a12(a12.get()); // expected-warning {{variable 'a12' is uninitialized when used within its own initialization}}
A a13(a13.num); // expected-warning {{variable 'a13' is uninitialized when used within its own initialization}}
A a14 = A(a14); // expected-warning {{variable 'a14' is uninitialized when used within its own initialization}}
A a15 = getA(a15.num); // expected-warning {{variable 'a15' is uninitialized when used within its own initialization}}
A a16(&a16.num); // expected-warning {{variable 'a16' is uninitialized when used within its own initialization}}
A a17(a17.get2()); // expected-warning {{variable 'a17' is uninitialized when used within its own initialization}}
A a18 = cond ? a18 : a17; // expected-warning {{variable 'a18' is uninitialized when used within its own initialization}}
A a19 = getA(cond ? a19 : a17); // expected-warning {{variable 'a19' is uninitialized when used within its own initialization}}
A a20{a20}; // expected-warning {{variable 'a20' is uninitialized when used within its own initialization}}
A a21 = {a21}; // expected-warning {{variable 'a21' is uninitialized when used within its own initialization}}
A *a22 = new A(a22->count);
A *a23 = new A(a23->ONE);
A *a24 = new A(a24->TWO);
A *a25 = new A(a25->zero());
A *a26 = new A(a26->get()); // expected-warning {{variable 'a26' is uninitialized when used within its own initialization}}
A *a27 = new A(a27->get2()); // expected-warning {{variable 'a27' is uninitialized when used within its own initialization}}
A *a28 = new A(a28->num); // expected-warning {{variable 'a28' is uninitialized when used within its own initialization}}
const A a29(a29); // expected-warning {{variable 'a29' is uninitialized when used within its own initialization}}
const A a30 = a30; // expected-warning {{variable 'a30' is uninitialized when used within its own initialization}}
A a31 = std::move(a31); // expected-warning {{variable 'a31' is uninitialized when used within its own initialization}}
A a32 = moveA(std::move(a32)); // expected-warning {{variable 'a32' is uninitialized when used within its own initialization}}
A a33 = A(std::move(a33)); // expected-warning {{variable 'a33' is uninitialized when used within its own initialization}}
A a34(std::move(a34)); // expected-warning {{variable 'a34' is uninitialized when used within its own initialization}}
A a35 = std::move(x ? a34 : (37, a35)); // expected-warning {{variable 'a35' is uninitialized when used within its own initialization}}
A a36 = const_refA(a36);
A a37(const_refA(a37));
A a38({a38}); // expected-warning {{variable 'a38' is uninitialized when used within its own initialization}}
A a39 = {a39}; // expected-warning {{variable 'a39' is uninitialized when used within its own initialization}}
A a40 = A({a40}); // expected-warning {{variable 'a40' is uninitialized when used within its own initialization}}
A a41 = !a41; // expected-warning {{variable 'a41' is uninitialized when used within its own initialization}}
A a42 = !(a42); // expected-warning {{variable 'a42' is uninitialized when used within its own initialization}}
A a43 = a43 != a42; // expected-warning {{variable 'a43' is uninitialized when used within its own initialization}}
A a44 = a43 != a44; // expected-warning {{variable 'a44' is uninitialized when used within its own initialization}}
A a45 = a45 != a45; // expected-warning 2{{variable 'a45' is uninitialized when used within its own initialization}}
A a46 = 0 != a46; // expected-warning {{variable 'a46' is uninitialized when used within its own initialization}}
A a47(a47.set(a47.num)); // expected-warning 2{{variable 'a47' is uninitialized when used within its own initialization}}
A a48(a47.set(a48.num)); // expected-warning {{variable 'a48' is uninitialized when used within its own initialization}}
A a49(a47.set(a48.num));
class T {
A a, a2;
const A c_a;
A* ptr_a;
T() {}
T(bool (*)[1]) : a() {}
T(bool (*)[2]) : a2(a.get()) {}
T(bool (*)[3]) : a2(a) {}
T(bool (*)[4]) : a(&a) {}
T(bool (*)[5]) : a(a.zero()) {}
T(bool (*)[6]) : a(a.ONE) {}
T(bool (*)[7]) : a(getA()) {}
T(bool (*)[8]) : a2(getA(a.TWO)) {}
T(bool (*)[9]) : a(getA(&a)) {}
T(bool (*)[10]) : a(a.count) {}
T(bool (*)[11]) : a(a) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[12]) : a(a.get()) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[13]) : a(a.num) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[14]) : a(A(a)) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[15]) : a(getA(a.num)) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[16]) : a(&a.num) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[17]) : a(a.get2()) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[18]) : a2(cond ? a2 : a) {} // expected-warning {{field 'a2' is uninitialized when used here}}
T(bool (*)[19]) : a2(cond ? a2 : a) {} // expected-warning {{field 'a2' is uninitialized when used here}}
T(bool (*)[20]) : a{a} {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[21]) : a({a}) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[22]) : ptr_a(new A(ptr_a->count)) {}
T(bool (*)[23]) : ptr_a(new A(ptr_a->ONE)) {}
T(bool (*)[24]) : ptr_a(new A(ptr_a->TWO)) {}
T(bool (*)[25]) : ptr_a(new A(ptr_a->zero())) {}
T(bool (*)[26]) : ptr_a(new A(ptr_a->get())) {} // expected-warning {{field 'ptr_a' is uninitialized when used here}}
T(bool (*)[27]) : ptr_a(new A(ptr_a->get2())) {} // expected-warning {{field 'ptr_a' is uninitialized when used here}}
T(bool (*)[28]) : ptr_a(new A(ptr_a->num)) {} // expected-warning {{field 'ptr_a' is uninitialized when used here}}
T(bool (*)[29]) : c_a(c_a) {} // expected-warning {{field 'c_a' is uninitialized when used here}}
T(bool (*)[30]) : c_a(A(c_a)) {} // expected-warning {{field 'c_a' is uninitialized when used here}}
T(bool (*)[31]) : a(std::move(a)) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[32]) : a(moveA(std::move(a))) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[33]) : a(A(std::move(a))) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[34]) : a(A(std::move(a))) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[35]) : a2(std::move(x ? a : (37, a2))) {} // expected-warning {{field 'a2' is uninitialized when used here}}
T(bool (*)[36]) : a(const_refA(a)) {}
T(bool (*)[37]) : a(A(const_refA(a))) {}
T(bool (*)[38]) : a({a}) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[39]) : a{a} {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[40]) : a({a}) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[41]) : a(!a) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[42]) : a(!(a)) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[43]) : a(), a2(a2 != a) {} // expected-warning {{field 'a2' is uninitialized when used here}}
T(bool (*)[44]) : a(), a2(a != a2) {} // expected-warning {{field 'a2' is uninitialized when used here}}
T(bool (*)[45]) : a(a != a) {} // expected-warning 2{{field 'a' is uninitialized when used here}}
T(bool (*)[46]) : a(0 != a) {} // expected-warning {{field 'a' is uninitialized when used here}}
T(bool (*)[47]) : a2(a2.set(a2.num)) {} // expected-warning 2{{field 'a2' is uninitialized when used here}}
T(bool (*)[48]) : a2(a.set(a2.num)) {} // expected-warning {{field 'a2' is uninitialized when used here}}
T(bool (*)[49]) : a2(a.set(a.num)) {}
};
struct B {
// POD struct.
int x;
int *y;
};
B getB() { return B(); };
B getB(int x) { return B(); };
B getB(int *x) { return B(); };
B getB(B *b) { return B(); };
B moveB(B &&b) { return B(); };
B* getPtrB() { return 0; };
B* getPtrB(int x) { return 0; };
B* getPtrB(int *x) { return 0; };
B* getPtrB(B **b) { return 0; };
void setupB(bool x) {
B b1;
B b2(b1);
B b3 = { 5, &b3.x };
B b4 = getB();
B b5 = getB(&b5);
B b6 = getB(&b6.x);
// Silence unused warning
(void) b2;
(void) b4;
B b7(b7); // expected-warning {{variable 'b7' is uninitialized when used within its own initialization}}
B b8 = getB(b8.x); // expected-warning {{variable 'b8' is uninitialized when used within its own initialization}}
B b9 = getB(b9.y); // expected-warning {{variable 'b9' is uninitialized when used within its own initialization}}
B b10 = getB(-b10.x); // expected-warning {{variable 'b10' is uninitialized when used within its own initialization}}
B* b11 = 0;
B* b12(b11);
B* b13 = getPtrB();
B* b14 = getPtrB(&b14);
(void) b12;
(void) b13;
B* b15 = getPtrB(b15->x); // expected-warning {{variable 'b15' is uninitialized when used within its own initialization}}
B* b16 = getPtrB(b16->y); // expected-warning {{variable 'b16' is uninitialized when used within its own initialization}}
B b17 = { b17.x = 5, b17.y = 0 };
B b18 = { b18.x + 1, b18.y }; // expected-warning 2{{variable 'b18' is uninitialized when used within its own initialization}}
const B b19 = b19; // expected-warning {{variable 'b19' is uninitialized when used within its own initialization}}
const B b20(b20); // expected-warning {{variable 'b20' is uninitialized when used within its own initialization}}
B b21 = std::move(b21); // expected-warning {{variable 'b21' is uninitialized when used within its own initialization}}
B b22 = moveB(std::move(b22)); // expected-warning {{variable 'b22' is uninitialized when used within its own initialization}}
B b23 = B(std::move(b23)); // expected-warning {{variable 'b23' is uninitialized when used within its own initialization}}
B b24 = std::move(x ? b23 : (18, b24)); // expected-warning {{variable 'b24' is uninitialized when used within its own initialization}}
}
B b1;
B b2(b1);
B b3 = { 5, &b3.x };
B b4 = getB();
B b5 = getB(&b5);
B b6 = getB(&b6.x);
B b7(b7); // expected-warning {{variable 'b7' is uninitialized when used within its own initialization}}
B b8 = getB(b8.x); // expected-warning {{variable 'b8' is uninitialized when used within its own initialization}}
B b9 = getB(b9.y); // expected-warning {{variable 'b9' is uninitialized when used within its own initialization}}
B b10 = getB(-b10.x); // expected-warning {{variable 'b10' is uninitialized when used within its own initialization}}
B* b11 = 0;
B* b12(b11);
B* b13 = getPtrB();
B* b14 = getPtrB(&b14);
B* b15 = getPtrB(b15->x); // expected-warning {{variable 'b15' is uninitialized when used within its own initialization}}
B* b16 = getPtrB(b16->y); // expected-warning {{variable 'b16' is uninitialized when used within its own initialization}}
B b17 = { b17.x = 5, b17.y = 0 };
B b18 = { b18.x + 1, b18.y }; // expected-warning 2{{variable 'b18' is uninitialized when used within its own initialization}}
const B b19 = b19; // expected-warning {{variable 'b19' is uninitialized when used within its own initialization}}
const B b20(b20); // expected-warning {{variable 'b20' is uninitialized when used within its own initialization}}
B b21 = std::move(b21); // expected-warning {{variable 'b21' is uninitialized when used within its own initialization}}
B b22 = moveB(std::move(b22)); // expected-warning {{variable 'b22' is uninitialized when used within its own initialization}}
B b23 = B(std::move(b23)); // expected-warning {{variable 'b23' is uninitialized when used within its own initialization}}
B b24 = std::move(x ? b23 : (18, b24)); // expected-warning {{variable 'b24' is uninitialized when used within its own initialization}}
class U {
B b1, b2;
B *ptr1, *ptr2;
const B constb = {};
U() {}
U(bool (*)[1]) : b1() {}
U(bool (*)[2]) : b2(b1) {}
U(bool (*)[3]) : b1{ 5, &b1.x } {}
U(bool (*)[4]) : b1(getB()) {}
U(bool (*)[5]) : b1(getB(&b1)) {}
U(bool (*)[6]) : b1(getB(&b1.x)) {}
U(bool (*)[7]) : b1(b1) {} // expected-warning {{field 'b1' is uninitialized when used here}}
U(bool (*)[8]) : b1(getB(b1.x)) {} // expected-warning {{field 'b1' is uninitialized when used here}}
U(bool (*)[9]) : b1(getB(b1.y)) {} // expected-warning {{field 'b1' is uninitialized when used here}}
U(bool (*)[10]) : b1(getB(-b1.x)) {} // expected-warning {{field 'b1' is uninitialized when used here}}
U(bool (*)[11]) : ptr1(0) {}
U(bool (*)[12]) : ptr1(0), ptr2(ptr1) {}
U(bool (*)[13]) : ptr1(getPtrB()) {}
U(bool (*)[14]) : ptr1(getPtrB(&ptr1)) {}
U(bool (*)[15]) : ptr1(getPtrB(ptr1->x)) {} // expected-warning {{field 'ptr1' is uninitialized when used here}}
U(bool (*)[16]) : ptr2(getPtrB(ptr2->y)) {} // expected-warning {{field 'ptr2' is uninitialized when used here}}
U(bool (*)[17]) : b1 { b1.x = 5, b1.y = 0 } {}
U(bool (*)[18]) : b1 { b1.x + 1, b1.y } {} // expected-warning 2{{field 'b1' is uninitialized when used here}}
U(bool (*)[19]) : constb(constb) {} // expected-warning {{field 'constb' is uninitialized when used here}}
U(bool (*)[20]) : constb(B(constb)) {} // expected-warning {{field 'constb' is uninitialized when used here}}
U(bool (*)[21]) : b1(std::move(b1)) {} // expected-warning {{field 'b1' is uninitialized when used here}}
U(bool (*)[22]) : b1(moveB(std::move(b1))) {} // expected-warning {{field 'b1' is uninitialized when used here}}
U(bool (*)[23]) : b1(B(std::move(b1))) {} // expected-warning {{field 'b1' is uninitialized when used here}}
U(bool (*)[24]) : b2(std::move(x ? b1 : (18, b2))) {} // expected-warning {{field 'b2' is uninitialized when used here}}
};
struct C { char a[100], *e; } car = { .e = car.a };
// <rdar://problem/10398199>
namespace rdar10398199 {
class FooBase { protected: ~FooBase() {} };
class Foo : public FooBase {
public:
operator int&() const;
};
void stuff();
template <typename T> class FooImpl : public Foo {
T val;
public:
FooImpl(const T &x) : val(x) {}
~FooImpl() { stuff(); }
};
template <typename T> FooImpl<T> makeFoo(const T& x) {
return FooImpl<T>(x);
}
void test() {
const Foo &x = makeFoo(42);
const int&y = makeFoo(42u);
(void)x;
(void)y;
};
}
// PR 12325 - this was a false uninitialized value warning due to
// a broken CFG.
int pr12325(int params) {
int x = ({
while (false)
;
int _v = params;
if (false)
;
_v; // no-warning
});
return x;
}
// Test lambda expressions with -Wuninitialized
int test_lambda() {
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}}
return f1(1, 2);
}
namespace {
struct A {
enum { A1 };
static int A2() {return 5;}
int A3;
int A4() { return 5;}
};
struct B {
A a;
};
struct C {
C() {}
C(int x) {}
static A a;
B b;
};
A C::a = A();
// Accessing non-static members will give a warning.
struct D {
C c;
D(char (*)[1]) : c(c.b.a.A1) {}
D(char (*)[2]) : c(c.b.a.A2()) {}
D(char (*)[3]) : c(c.b.a.A3) {} // expected-warning {{field 'c' is uninitialized when used here}}
D(char (*)[4]) : c(c.b.a.A4()) {} // expected-warning {{field 'c' is uninitialized when used here}}
// c::a is static, so it is already initialized
D(char (*)[5]) : c(c.a.A1) {}
D(char (*)[6]) : c(c.a.A2()) {}
D(char (*)[7]) : c(c.a.A3) {}
D(char (*)[8]) : c(c.a.A4()) {}
};
struct E {
int b = 1;
int c = 1;
int a; // This field needs to be last to prevent the cross field
// uninitialized warning.
E(char (*)[1]) : a(a ? b : c) {} // expected-warning {{field 'a' is uninitialized when used here}}
E(char (*)[2]) : a(b ? a : a) {} // expected-warning 2{{field 'a' is uninitialized when used here}}
E(char (*)[3]) : a(b ? (a) : c) {} // expected-warning {{field 'a' is uninitialized when used here}}
E(char (*)[4]) : a(b ? c : (a+c)) {} // expected-warning {{field 'a' is uninitialized when used here}}
E(char (*)[5]) : a(b ? c : b) {}
E(char (*)[6]) : a(a ?: a) {} // expected-warning 2{{field 'a' is uninitialized when used here}}
E(char (*)[7]) : a(b ?: a) {} // expected-warning {{field 'a' is uninitialized when used here}}
E(char (*)[8]) : a(a ?: c) {} // expected-warning {{field 'a' is uninitialized when used here}}
E(char (*)[9]) : a(b ?: c) {}
E(char (*)[10]) : a((a, a, b)) {}
E(char (*)[11]) : a((c + a, a + 1, b)) {} // expected-warning 2{{field 'a' is uninitialized when used here}}
E(char (*)[12]) : a((b + c, c, a)) {} // expected-warning {{field 'a' is uninitialized when used here}}
E(char (*)[13]) : a((a, a, a, a)) {} // expected-warning {{field 'a' is uninitialized when used here}}
E(char (*)[14]) : a((b, c, c)) {}
E(char (*)[15]) : a(b ?: a) {} // expected-warning {{field 'a' is uninitialized when used here}}
E(char (*)[16]) : a(a ?: b) {} // expected-warning {{field 'a' is uninitialized when used here}}
};
struct F {
int a;
F* f;
F(int) {}
F() {}
};
int F::*ptr = &F::a;
F* F::*f_ptr = &F::f;
struct G {
F f1, f2;
F *f3, *f4;
G(char (*)[1]) : f1(f1) {} // expected-warning {{field 'f1' is uninitialized when used here}}
G(char (*)[2]) : f2(f1) {}
G(char (*)[3]) : f2(F()) {}
G(char (*)[4]) : f1(f1.*ptr) {} // expected-warning {{field 'f1' is uninitialized when used here}}
G(char (*)[5]) : f2(f1.*ptr) {}
G(char (*)[6]) : f3(f3) {} // expected-warning {{field 'f3' is uninitialized when used here}}
G(char (*)[7]) : f3(f3->*f_ptr) {} // expected-warning {{field 'f3' is uninitialized when used here}}
G(char (*)[8]) : f3(new F(f3->*ptr)) {} // expected-warning {{field 'f3' is uninitialized when used here}}
};
struct H {
H() : a(a) {} // expected-warning {{field 'a' is uninitialized when used here}}
const A a;
};
}
namespace statics {
static int a = a; // no-warning: used to signal intended lack of initialization.
static int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
static int c = (c + c); // expected-warning 2{{variable 'c' is uninitialized when used within its own initialization}}
static int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
static int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
// Thes don't warn as they don't require the value.
static int g = sizeof(g);
int gg = g; // Silence unneeded warning
static void* ptr = &ptr;
static int h = bar(&h);
static int i = boo(i);
static int j = far(j);
static int k = __alignof__(k);
static int l = k ? l : l; // expected-warning 2{{variable 'l' is uninitialized when used within its own initialization}}
static int m = 1 + (k ? m : m); // expected-warning 2{{variable 'm' is uninitialized when used within its own initialization}}
static int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}}
static int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}}
static const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}}
static int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}}
static int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}}
static int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}}
static int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}}
static int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}}
static int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}}
static int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}}
static int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
static int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}}
static int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}}
static int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}}
static int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}}
void test() {
static int a = a; // no-warning: used to signal intended lack of initialization.
static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}}
static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}}
static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}}
static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
// Thes don't warn as they don't require the value.
static int g = sizeof(g);
static void* ptr = &ptr;
static int h = bar(&h);
static int i = boo(i);
static int j = far(j);
static int k = __alignof__(k);
static int l = k ? l : l; // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}}
static int m = 1 + (k ? m : m); // expected-warning 2{{static variable 'm' is suspiciously used within its own initialization}}
static int n = -n; // expected-warning {{static variable 'n' is suspiciously used within its own initialization}}
static int o = std::move(o); // expected-warning {{static variable 'o' is suspiciously used within its own initialization}}
static const int p = std::move(p); // expected-warning {{static variable 'p' is suspiciously used within its own initialization}}
static int q = moved(std::move(q)); // expected-warning {{static variable 'q' is suspiciously used within its own initialization}}
static int r = std::move((p ? q : (18, r))); // expected-warning {{static variable 'r' is suspiciously used within its own initialization}}
static int s = r ?: s; // expected-warning {{static variable 's' is suspiciously used within its own initialization}}
static int t = t ?: s; // expected-warning {{static variable 't' is suspiciously used within its own initialization}}
static int u = (foo(u), s); // expected-warning {{static variable 'u' is suspiciously used within its own initialization}}
static int v = (u += v); // expected-warning {{static variable 'v' is suspiciously used within its own initialization}}
static int w = (w += 10); // expected-warning {{static variable 'w' is suspiciously used within its own initialization}}
static int x = x++; // expected-warning {{static variable 'x' is suspiciously used within its own initialization}}
static int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{static variable 'y' is suspiciously used within its own initialization}}
static int z = ++ref(z); // expected-warning {{static variable 'z' is suspiciously used within its own initialization}}
static int aa = (ref(aa) += 10); // expected-warning {{static variable 'aa' is suspiciously used within its own initialization}}
static int bb = bb ? x : y; // expected-warning {{static variable 'bb' is suspiciously used within its own initialization}}
for (;;) {
static int a = a; // no-warning: used to signal intended lack of initialization.
static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}}
static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}}
static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}}
static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
// Thes don't warn as they don't require the value.
static int g = sizeof(g);
static void* ptr = &ptr;
static int h = bar(&h);
static int i = boo(i);
static int j = far(j);
static int k = __alignof__(k);
static int l = k ? l : l; // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}}
static int m = 1 + (k ? m : m); // expected-warning 2{{static variable 'm' is suspiciously used within its own initialization}}
static int n = -n; // expected-warning {{static variable 'n' is suspiciously used within its own initialization}}
static int o = std::move(o); // expected-warning {{static variable 'o' is suspiciously used within its own initialization}}
static const int p = std::move(p); // expected-warning {{static variable 'p' is suspiciously used within its own initialization}}
static int q = moved(std::move(q)); // expected-warning {{static variable 'q' is suspiciously used within its own initialization}}
static int r = std::move((p ? q : (18, r))); // expected-warning {{static variable 'r' is suspiciously used within its own initialization}}
static int s = r ?: s; // expected-warning {{static variable 's' is suspiciously used within its own initialization}}
static int t = t ?: s; // expected-warning {{static variable 't' is suspiciously used within its own initialization}}
static int u = (foo(u), s); // expected-warning {{static variable 'u' is suspiciously used within its own initialization}}
static int v = (u += v); // expected-warning {{static variable 'v' is suspiciously used within its own initialization}}
static int w = (w += 10); // expected-warning {{static variable 'w' is suspiciously used within its own initialization}}
static int x = x++; // expected-warning {{static variable 'x' is suspiciously used within its own initialization}}
static int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{static variable 'y' is suspiciously used within its own initialization}}
static int z = ++ref(z); // expected-warning {{static variable 'z' is suspiciously used within its own initialization}}
static int aa = (ref(aa) += 10); // expected-warning {{static variable 'aa' is suspiciously used within its own initialization}}
static int bb = bb ? x : y; // expected-warning {{static variable 'bb' is suspiciously used within its own initialization}}
}
}
}
namespace in_class_initializers {
struct S {
S() : a(a + 1) {} // expected-warning{{field 'a' is uninitialized when used here}}
int a = 42; // Note: because a is in a member initializer list, this initialization is ignored.
};
struct T {
T() : b(a + 1) {} // No-warning.
int a = 42;
int b;
};
struct U {
U() : a(b + 1), b(a + 1) {} // expected-warning{{field 'b' is uninitialized when used here}}
int a = 42; // Note: because a and b are in the member initializer list, these initializers are ignored.
int b = 1;
};
}
namespace references {
int &a = a; // expected-warning{{reference 'a' is not yet bound to a value when used within its own initialization}}
int &b(b); // expected-warning{{reference 'b' is not yet bound to a value when used within its own initialization}}
int &c = a ? b : c; // expected-warning{{reference 'c' is not yet bound to a value when used within its own initialization}}
int &d{d}; // expected-warning{{reference 'd' is not yet bound to a value when used within its own initialization}}
int &e = d ?: e; // expected-warning{{reference 'e' is not yet bound to a value when used within its own initialization}}
int &f = f ?: d; // expected-warning{{reference 'f' is not yet bound to a value when used within its own initialization}}
int &return_ref1(int);
int &return_ref2(int&);
int &g = return_ref1(g); // expected-warning{{reference 'g' is not yet bound to a value when used within its own initialization}}
int &h = return_ref2(h); // expected-warning{{reference 'h' is not yet bound to a value when used within its own initialization}}
struct S {
S() : a(a) {} // expected-warning{{reference 'a' is not yet bound to a value when used here}}
int &a;
};
void test() {
int &a = a; // expected-warning{{reference 'a' is not yet bound to a value when used within its own initialization}}
int &b(b); // expected-warning{{reference 'b' is not yet bound to a value when used within its own initialization}}
int &c = a ? b : c; // expected-warning{{reference 'c' is not yet bound to a value when used within its own initialization}}
int &d{d}; // expected-warning{{reference 'd' is not yet bound to a value when used within its own initialization}}
}
struct T {
T() // expected-note{{during field initialization in this constructor}}
: a(b), b(a) {} // expected-warning{{reference 'b' is not yet bound to a value when used here}}
int &a, &b;
int &c = c; // expected-warning{{reference 'c' is not yet bound to a value when used here}}
};
int x;
struct U {
U() : b(a) {} // No-warning.
int &a = x;
int &b;
};
}
namespace operators {
struct A {
A(bool);
bool operator==(A);
};
A makeA();
A a1 = a1 = makeA(); // expected-warning{{variable 'a1' is uninitialized when used within its own initialization}}
A a2 = a2 == a1; // expected-warning{{variable 'a2' is uninitialized when used within its own initialization}}
A a3 = a2 == a3; // expected-warning{{variable 'a3' is uninitialized when used within its own initialization}}
int x = x = 5;
}
namespace lambdas {
struct A {
template<typename T> A(T) {}
int x;
};
A a0([] { return a0.x; }); // ok
void f() {
A a1([=] { return a1.x; }); // expected-warning{{variable 'a1' is uninitialized when used within its own initialization}}
A a2([&] { return a2.x; }); // ok
}
}
namespace record_fields {
bool x;
struct A {
A() {}
A get();
static A num();
static A copy(A);
static A something(A&);
};
A ref(A&);
A const_ref(const A&);
A pointer(A*);
A normal(A);
A rref(A&&);
struct B {
A a;
B(char (*)[1]) : a(a) {} // expected-warning {{uninitialized}}
B(char (*)[2]) : a(a.get()) {} // expected-warning {{uninitialized}}
B(char (*)[3]) : a(a.num()) {}
B(char (*)[4]) : a(a.copy(a)) {} // expected-warning {{uninitialized}}
B(char (*)[5]) : a(a.something(a)) {}
B(char (*)[6]) : a(ref(a)) {}
B(char (*)[7]) : a(const_ref(a)) {}
B(char (*)[8]) : a(pointer(&a)) {}
B(char (*)[9]) : a(normal(a)) {} // expected-warning {{uninitialized}}
B(char (*)[10]) : a(std::move(a)) {} // expected-warning {{uninitialized}}
B(char (*)[11]) : a(A(std::move(a))) {} // expected-warning {{uninitialized}}
B(char (*)[12]) : a(rref(std::move(a))) {} // expected-warning {{uninitialized}}
B(char (*)[13]) : a(std::move(x ? a : (25, a))) {} // expected-warning 2{{uninitialized}}
};
struct C {
C() {} // expected-note9{{in this constructor}}
A a1 = a1; // expected-warning {{uninitialized}}
A a2 = a2.get(); // expected-warning {{uninitialized}}
A a3 = a3.num();
A a4 = a4.copy(a4); // expected-warning {{uninitialized}}
A a5 = a5.something(a5);
A a6 = ref(a6);
A a7 = const_ref(a7);
A a8 = pointer(&a8);
A a9 = normal(a9); // expected-warning {{uninitialized}}
const A a10 = a10; // expected-warning {{uninitialized}}
A a11 = std::move(a11); // expected-warning {{uninitialized}}
A a12 = A(std::move(a12)); // expected-warning {{uninitialized}}
A a13 = rref(std::move(a13)); // expected-warning {{uninitialized}}
A a14 = std::move(x ? a13 : (22, a14)); // expected-warning {{uninitialized}}
};
struct D { // expected-note9{{in the implicit default constructor}}
A a1 = a1; // expected-warning {{uninitialized}}
A a2 = a2.get(); // expected-warning {{uninitialized}}
A a3 = a3.num();
A a4 = a4.copy(a4); // expected-warning {{uninitialized}}
A a5 = a5.something(a5);
A a6 = ref(a6);
A a7 = const_ref(a7);
A a8 = pointer(&a8);
A a9 = normal(a9); // expected-warning {{uninitialized}}
const A a10 = a10; // expected-warning {{uninitialized}}
A a11 = std::move(a11); // expected-warning {{uninitialized}}
A a12 = A(std::move(a12)); // expected-warning {{uninitialized}}
A a13 = rref(std::move(a13)); // expected-warning {{uninitialized}}
A a14 = std::move(x ? a13 : (22, a14)); // expected-warning {{uninitialized}}
};
D d;
struct E {
A a1 = a1;
A a2 = a2.get();
A a3 = a3.num();
A a4 = a4.copy(a4);
A a5 = a5.something(a5);
A a6 = ref(a6);
A a7 = const_ref(a7);
A a8 = pointer(&a8);
A a9 = normal(a9);
const A a10 = a10;
A a11 = std::move(a11);
A a12 = A(std::move(a12));
A a13 = rref(std::move(a13));
A a14 = std::move(x ? a13 : (22, a14));
};
}
namespace cross_field_warnings {
struct A {
int a, b;
A() {}
A(char (*)[1]) : b(a) {} // expected-warning{{field 'a' is uninitialized when used here}}
A(char (*)[2]) : a(b) {} // expected-warning{{field 'b' is uninitialized when used here}}
};
struct B {
int a = b; // expected-warning{{field 'b' is uninitialized when used here}}
int b;
B() {} // expected-note{{during field initialization in this constructor}}
};
struct C {
int a;
int b = a; // expected-warning{{field 'a' is uninitialized when used here}}
C(char (*)[1]) : a(5) {}
C(char (*)[2]) {} // expected-note{{during field initialization in this constructor}}
};
struct D {
int a;
int &b;
int &c = a;
int d = b;
D() : b(a) {}
};
struct E {
int a;
int get();
static int num();
E() {}
E(int) {}
};
struct F {
int a;
E e;
int b;
F(char (*)[1]) : a(e.get()) {} // expected-warning{{field 'e' is uninitialized when used here}}
F(char (*)[2]) : a(e.num()) {}
F(char (*)[3]) : e(a) {} // expected-warning{{field 'a' is uninitialized when used here}}
F(char (*)[4]) : a(4), e(a) {}
F(char (*)[5]) : e(b) {} // expected-warning{{field 'b' is uninitialized when used here}}
F(char (*)[6]) : e(b), b(4) {} // expected-warning{{field 'b' is uninitialized when used here}}
};
struct G {
G(const A&) {};
};
struct H {
A a1;
G g;
A a2;
H() : g(a1) {}
H(int) : g(a2) {}
};
struct I {
I(int*) {}
};
struct J : public I {
int *a;
int *b;
int c;
J() : I((a = new int(5))), b(a), c(*a) {}
};
struct K {
int a = (b = 5);
int b = b + 5;
};
struct L {
int a = (b = 5);
int b = b + 5; // expected-warning{{field 'b' is uninitialized when used here}}
L() : a(5) {} // expected-note{{during field initialization in this constructor}}
};
struct M { };
struct N : public M {
int a;
int b;
N() : b(a) { } // expected-warning{{field 'a' is uninitialized when used here}}
};
struct O {
int x = 42;
int get() { return x; }
};
struct P {
O o;
int x = o.get();
P() : x(o.get()) { }
};
struct Q {
int a;
int b;
int &c;
Q() :
a(c = 5), // expected-warning{{reference 'c' is not yet bound to a value when used here}}
b(c), // expected-warning{{reference 'c' is not yet bound to a value when used here}}
c(a) {}
};
struct R {
int a;
int b;
int c;
int d = a + b + c;
R() : a(c = 5), b(c), c(a) {}
};
// FIXME: Use the CFG-based analysis to give a sometimes uninitialized
// warning on y.
struct T {
int x;
int y;
T(bool b)
: x(b ? (y = 5) : (1 + y)), // expected-warning{{field 'y' is uninitialized when used here}}
y(y + 1) {}
T(int b)
: x(!b ? (1 + y) : (y = 5)), // expected-warning{{field 'y' is uninitialized when used here}}
y(y + 1) {}
};
}
namespace base_class {
struct A {
A (int) {}
};
struct B : public A {
int x;
B() : A(x) {} // expected-warning{{field 'x' is uninitialized when used here}}
};
struct C : public A {
int x;
int y;
C() : A(y = 4), x(y) {}
};
}
namespace delegating_constructor {
struct A {
A(int);
A(int&, int);
A(char (*)[1]) : A(x) {}
// expected-warning@-1 {{field 'x' is uninitialized when used here}}
A(char (*)[2]) : A(x, x) {}
// expected-warning@-1 {{field 'x' is uninitialized when used here}}
A(char (*)[3]) : A(x, 0) {}
int x;
};
}
namespace init_list {
int num = 5;
struct A { int i1, i2; };
struct B { A a1, a2; };
A a1{1,2};
A a2{a2.i1 + 2}; // expected-warning{{uninitialized}}
A a3 = {a3.i1 + 2}; // expected-warning{{uninitialized}}
A a4 = A{a4.i2 + 2}; // expected-warning{{uninitialized}}
B b1 = { {}, {} };
B b2 = { {}, b2.a1 };
B b3 = { b3.a1 }; // expected-warning{{uninitialized}}
B b4 = { {}, b4.a2} ; // expected-warning{{uninitialized}}
B b5 = { b5.a2 }; // expected-warning{{uninitialized}}
B b6 = { {b6.a1.i1} }; // expected-warning{{uninitialized}}
B b7 = { {0, b7.a1.i1} };
B b8 = { {}, {b8.a1.i1} };
B b9 = { {}, {0, b9.a1.i1} };
B b10 = { {b10.a1.i2} }; // expected-warning{{uninitialized}}
B b11 = { {0, b11.a1.i2} }; // expected-warning{{uninitialized}}
B b12 = { {}, {b12.a1.i2} };
B b13 = { {}, {0, b13.a1.i2} };
B b14 = { {b14.a2.i1} }; // expected-warning{{uninitialized}}
B b15 = { {0, b15.a2.i1} }; // expected-warning{{uninitialized}}
B b16 = { {}, {b16.a2.i1} }; // expected-warning{{uninitialized}}
B b17 = { {}, {0, b17.a2.i1} };
B b18 = { {b18.a2.i2} }; // expected-warning{{uninitialized}}
B b19 = { {0, b19.a2.i2} }; // expected-warning{{uninitialized}}
B b20 = { {}, {b20.a2.i2} }; // expected-warning{{uninitialized}}
B b21 = { {}, {0, b21.a2.i2} }; // expected-warning{{uninitialized}}
B b22 = { {b18.a2.i2 + 5} };
struct C {int a; int& b; int c; };
C c1 = { 0, num, 0 };
C c2 = { 1, num, c2.b };
C c3 = { c3.b, num }; // expected-warning{{uninitialized}}
C c4 = { 0, c4.b, 0 }; // expected-warning{{uninitialized}}
C c5 = { 0, c5.c, 0 };
C c6 = { c6.b, num, 0 }; // expected-warning{{uninitialized}}
C c7 = { 0, c7.a, 0 };
struct D {int &a; int &b; };
D d1 = { num, num };
D d2 = { num, d2.a };
D d3 = { d3.b, num }; // expected-warning{{uninitialized}}
// Same as above in member initializer form.
struct Awrapper {
A a1{1,2};
A a2{a2.i1 + 2}; // expected-warning{{uninitialized}}
A a3 = {a3.i1 + 2}; // expected-warning{{uninitialized}}
A a4 = A{a4.i2 + 2}; // expected-warning{{uninitialized}}
Awrapper() {} // expected-note 3{{in this constructor}}
Awrapper(int) :
a1{1,2},
a2{a2.i1 + 2}, // expected-warning{{uninitialized}}
a3{a3.i1 + 2}, // expected-warning{{uninitialized}}
a4{a4.i2 + 2} // expected-warning{{uninitialized}}
{}
};
struct Bwrapper {
B b1 = { {}, {} };
B b2 = { {}, b2.a1 };
B b3 = { b3.a1 }; // expected-warning{{uninitialized}}
B b4 = { {}, b4.a2} ; // expected-warning{{uninitialized}}
B b5 = { b5.a2 }; // expected-warning{{uninitialized}}
B b6 = { {b6.a1.i1} }; // expected-warning{{uninitialized}}
B b7 = { {0, b7.a1.i1} };
B b8 = { {}, {b8.a1.i1} };
B b9 = { {}, {0, b9.a1.i1} };
B b10 = { {b10.a1.i2} }; // expected-warning{{uninitialized}}
B b11 = { {0, b11.a1.i2} }; // expected-warning{{uninitialized}}
B b12 = { {}, {b12.a1.i2} };
B b13 = { {}, {0, b13.a1.i2} };
B b14 = { {b14.a2.i1} }; // expected-warning{{uninitialized}}
B b15 = { {0, b15.a2.i1} }; // expected-warning{{uninitialized}}
B b16 = { {}, {b16.a2.i1} }; // expected-warning{{uninitialized}}
B b17 = { {}, {0, b17.a2.i1} };
B b18 = { {b18.a2.i2} }; // expected-warning{{uninitialized}}
B b19 = { {0, b19.a2.i2} }; // expected-warning{{uninitialized}}
B b20 = { {}, {b20.a2.i2} }; // expected-warning{{uninitialized}}
B b21 = { {}, {0, b21.a2.i2} }; // expected-warning{{uninitialized}}
B b22 = { {b18.a2.i2 + 5} };
Bwrapper() {} // expected-note 13{{in this constructor}}
Bwrapper(int) :
b1{ {}, {} },
b2{ {}, b2.a1 },
b3{ b3.a1 }, // expected-warning{{uninitialized}}
b4{ {}, b4.a2}, // expected-warning{{uninitialized}}
b5{ b5.a2 }, // expected-warning{{uninitialized}}
b6{ {b6.a1.i1} }, // expected-warning{{uninitialized}}
b7{ {0, b7.a1.i1} },
b8{ {}, {b8.a1.i1} },
b9{ {}, {0, b9.a1.i1} },
b10{ {b10.a1.i2} }, // expected-warning{{uninitialized}}
b11{ {0, b11.a1.i2} }, // expected-warning{{uninitialized}}
b12{ {}, {b12.a1.i2} },
b13{ {}, {0, b13.a1.i2} },
b14{ {b14.a2.i1} }, // expected-warning{{uninitialized}}
b15{ {0, b15.a2.i1} }, // expected-warning{{uninitialized}}
b16{ {}, {b16.a2.i1} }, // expected-warning{{uninitialized}}
b17{ {}, {0, b17.a2.i1} },
b18{ {b18.a2.i2} }, // expected-warning{{uninitialized}}
b19{ {0, b19.a2.i2} }, // expected-warning{{uninitialized}}
b20{ {}, {b20.a2.i2} }, // expected-warning{{uninitialized}}
b21{ {}, {0, b21.a2.i2} }, // expected-warning{{uninitialized}}
b22{ {b18.a2.i2 + 5} }
{}
};
struct Cwrapper {
C c1 = { 0, num, 0 };
C c2 = { 1, num, c2.b };
C c3 = { c3.b, num }; // expected-warning{{uninitialized}}
C c4 = { 0, c4.b, 0 }; // expected-warning{{uninitialized}}
C c5 = { 0, c5.c, 0 };
C c6 = { c6.b, num, 0 }; // expected-warning{{uninitialized}}
C c7 = { 0, c7.a, 0 };
Cwrapper() {} // expected-note 3{{in this constructor}}
Cwrapper(int) :
c1{ 0, num, 0 },
c2{ 1, num, c2.b },
c3{ c3.b, num }, // expected-warning{{uninitialized}}
c4{ 0, c4.b, 0 }, // expected-warning{{uninitialized}}
c5{ 0, c5.c, 0 },
c6{ c6.b, num, 0 }, // expected-warning{{uninitialized}}
c7{ 0, c7.a, 0 }
{}
};
struct Dwrapper {
D d1 = { num, num };
D d2 = { num, d2.a };
D d3 = { d3.b, num }; // expected-warning{{uninitialized}}
Dwrapper() {} // expected-note{{in this constructor}}
Dwrapper(int) :
d1{ num, num },
d2{ num, d2.a },
d3{ d3.b, num } // expected-warning{{uninitialized}}
{}
};
}
namespace template_class {
class Foo {
public:
int *Create() { return nullptr; }
};
template <typename T>
class A {
public:
// Don't warn on foo here.
A() : ptr(foo->Create()) {}
private:
Foo *foo = new Foo;
int *ptr;
};
template <typename T>
class B {
public:
// foo is uninitialized here, but class B is never instantiated.
B() : ptr(foo->Create()) {}
private:
Foo *foo;
int *ptr;
};
template <typename T>
class C {
public:
C() : ptr(foo->Create()) {}
// expected-warning@-1 {{field 'foo' is uninitialized when used here}}
private:
Foo *foo;
int *ptr;
};
C<int> c;
// expected-note@-1 {{in instantiation of member function 'template_class::C<int>::C' requested here}}
}
namespace base_class_access {
struct A {
A();
A(int);
int i;
int foo();
static int bar();
};
struct B : public A {
B(int (*)[1]) : A() {}
B(int (*)[2]) : A(bar()) {}
B(int (*)[3]) : A(i) {}
// expected-warning@-1 {{base class 'base_class_access::A' is uninitialized when used here to access 'base_class_access::A::i'}}
B(int (*)[4]) : A(foo()) {}
// expected-warning@-1 {{base_class_access::A' is uninitialized when used here to access 'base_class_access::A::foo'}}
};
struct C {
C(int) {}
};
struct D : public C, public A {
D(int (*)[1]) : C(0) {}
D(int (*)[2]) : C(bar()) {}
D(int (*)[3]) : C(i) {}
// expected-warning@-1 {{base class 'base_class_access::A' is uninitialized when used here to access 'base_class_access::A::i'}}
D(int (*)[4]) : C(foo()) {}
// expected-warning@-1 {{base_class_access::A' is uninitialized when used here to access 'base_class_access::A::foo'}}
};
}
namespace value {
template <class T> T move(T t);
template <class T> T notmove(T t);
}
namespace lvalueref {
template <class T> T move(T& t);
template <class T> T notmove(T& t);
}
namespace rvalueref {
template <class T> T move(T&& t);
template <class T> T notmove(T&& t);
}
namespace move_test {
int a1 = std::move(a1); // expected-warning {{uninitialized}}
int a2 = value::move(a2); // expected-warning {{uninitialized}}
int a3 = value::notmove(a3); // expected-warning {{uninitialized}}
int a4 = lvalueref::move(a4);
int a5 = lvalueref::notmove(a5);
int a6 = rvalueref::move(a6);
int a7 = rvalueref::notmove(a7);
void test() {
int a1 = std::move(a1); // expected-warning {{uninitialized}}
int a2 = value::move(a2); // expected-warning {{uninitialized}}
int a3 = value::notmove(a3); // expected-warning {{uninitialized}}
int a4 = lvalueref::move(a4);
int a5 = lvalueref::notmove(a5);
int a6 = rvalueref::move(a6);
int a7 = rvalueref::notmove(a7);
}
class A {
int a;
A(int (*) [1]) : a(std::move(a)) {} // expected-warning {{uninitialized}}
A(int (*) [2]) : a(value::move(a)) {} // expected-warning {{uninitialized}}
A(int (*) [3]) : a(value::notmove(a)) {} // expected-warning {{uninitialized}}
A(int (*) [4]) : a(lvalueref::move(a)) {}
A(int (*) [5]) : a(lvalueref::notmove(a)) {}
A(int (*) [6]) : a(rvalueref::move(a)) {}
A(int (*) [7]) : a(rvalueref::notmove(a)) {}
};
}
void array_capture(bool b) {
const char fname[] = "array_capture";
if (b) {
int unused; // expected-warning {{unused variable}}
} else {
[fname]{};
}
}
Reference in New Issue View Git Blame Copy Permalink