1 // RUN: %clang_cc1 -fsyntax-only -Wuninitialized -fsyntax-only -fcxx-exceptions %s -verify -std=c++1y 2 3 // Stub out types for 'typeid' to work. 4 namespace std { class type_info {}; } 5 6 int test1_aux(int &x); 7 int test1() { 8 int x; 9 test1_aux(x); 10 return x; // no-warning 11 } 12 13 int test2_aux() { 14 int x; 15 int &y = x; 16 return x; // no-warning 17 } 18 19 // Don't warn on unevaluated contexts. 20 void unevaluated_tests() { 21 int x; 22 (void)sizeof(x); 23 (void)typeid(x); 24 } 25 26 // Warn for glvalue arguments to typeid whose type is polymorphic. 27 struct A { virtual ~A() {} }; 28 void polymorphic_test() { 29 A *a; // expected-note{{initialize the variable 'a' to silence this warning}} 30 (void)typeid(*a); // expected-warning{{variable 'a' is uninitialized when used here}} 31 } 32 33 // Handle cases where the CFG may constant fold some branches, thus 34 // mitigating the need for some path-sensitivity in the analysis. 35 unsigned test3_aux(); 36 unsigned test3() { 37 unsigned x = 0; 38 const bool flag = true; 39 if (flag && (x = test3_aux()) == 0) { 40 return x; 41 } 42 return x; 43 } 44 unsigned test3_b() { 45 unsigned x ; 46 const bool flag = true; 47 if (flag && (x = test3_aux()) == 0) { 48 x = 1; 49 } 50 return x; // no-warning 51 } 52 unsigned test3_c() { 53 unsigned x; // expected-note{{initialize the variable 'x' to silence this warning}} 54 const bool flag = false; 55 if (flag && (x = test3_aux()) == 0) { 56 x = 1; 57 } 58 return x; // expected-warning{{variable 'x' is uninitialized when used here}} 59 } 60 61 enum test4_A { 62 test4_A_a, test_4_A_b 63 }; 64 test4_A test4() { 65 test4_A a; // expected-note{{variable 'a' is declared here}} 66 return a; // expected-warning{{variable 'a' is uninitialized when used here}} 67 } 68 69 // Test variables getting invalidated by function calls with reference arguments 70 // *AND* there are multiple invalidated arguments. 71 void test5_aux(int &, int &); 72 73 int test5() { 74 int x, y; 75 test5_aux(x, y); 76 return x + y; // no-warning 77 } 78 79 // This test previously crashed Sema. 80 class Rdar9188004A { 81 public: 82 virtual ~Rdar9188004A(); 83 }; 84 85 template< typename T > class Rdar9188004B : public Rdar9188004A { 86 virtual double *foo(Rdar9188004B *next) const { 87 double *values = next->foo(0); 88 try { 89 } 90 catch(double e) { 91 values[0] = e; 92 } 93 return 0; 94 } 95 }; 96 class Rdar9188004C : public Rdar9188004B<Rdar9188004A> { 97 virtual void bar(void) const; 98 }; 99 void Rdar9188004C::bar(void) const {} 100 101 // Don't warn about uninitialized variables in unreachable code. 102 void PR9625() { 103 if (false) { 104 int x; 105 (void)static_cast<float>(x); // no-warning 106 } 107 } 108 109 // Don't warn about variables declared in "catch" 110 void RDar9251392_bar(const char *msg); 111 112 void RDar9251392() { 113 try { 114 throw "hi"; 115 } 116 catch (const char* msg) { 117 RDar9251392_bar(msg); // no-warning 118 } 119 } 120 121 // Test handling of "no-op" casts. 122 void test_noop_cast() 123 { 124 int x = 1; 125 int y = (int&)x; // no-warning 126 } 127 128 void test_noop_cast2() { 129 int x; // expected-note {{initialize the variable 'x' to silence this warning}} 130 int y = (int&)x; // expected-warning {{uninitialized when used here}} 131 } 132 133 // Test handling of bit casts. 134 void test_bitcasts() { 135 int x = 1; 136 int y = (float &)x; // no-warning 137 } 138 139 void test_bitcasts_2() { 140 int x; // expected-note {{initialize the variable 'x' to silence this warning}} 141 int y = (float &)x; // expected-warning {{uninitialized when used here}} 142 } 143 144 void consume_const_ref(const int &n); 145 int test_const_ref() { 146 int n; // expected-note {{variable}} 147 consume_const_ref(n); 148 return n; // expected-warning {{uninitialized when used here}} 149 } 150 151 // Don't crash here. 152 auto PR19996 = [a=0]{int t; return a;}; 153
