1 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify %s 2 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify -std=c++11 %s 3 template<typename T> void f() { 4 T t; 5 t = 17; 6 } 7 8 // PR5407 9 struct A { A(); }; 10 struct B { ~B(); }; 11 void f() { 12 A a; 13 B b; 14 } 15 16 // PR5531 17 namespace PR5531 { 18 struct A { 19 }; 20 21 struct B { 22 B(int); 23 }; 24 25 struct C { 26 ~C(); 27 }; 28 29 void test() { 30 A(); 31 B(17); 32 C(); 33 } 34 } 35 36 template<typename T> 37 struct X0 { }; 38 39 template<typename T> 40 void test_dependent_init(T *p) { 41 X0<int> i(p); 42 (void)i; 43 } 44 45 void unused_local_static() { 46 static int x = 0; 47 static int y = 0; // expected-warning{{unused variable 'y'}} 48 #pragma unused(x) 49 } 50 51 // PR10168 52 namespace PR10168 { 53 // We expect a warning in the definition only for non-dependent variables, and 54 // a warning in the instantiation only for dependent variables. 55 template<typename T> 56 struct S { 57 void f() { 58 int a; // expected-warning {{unused variable 'a'}} 59 T b; // expected-warning 2{{unused variable 'b'}} 60 } 61 }; 62 63 template<typename T> 64 void f() { 65 int a; // expected-warning {{unused variable 'a'}} 66 T b; // expected-warning 2{{unused variable 'b'}} 67 } 68 69 void g() { 70 S<int>().f(); // expected-note {{here}} 71 S<char>().f(); // expected-note {{here}} 72 f<int>(); // expected-note {{here}} 73 f<char>(); // expected-note {{here}} 74 } 75 } 76 77 namespace PR11550 { 78 struct S1 { 79 S1(); 80 }; 81 S1 makeS1(); 82 void testS1(S1 a) { 83 // This constructor call can be elided. 84 S1 x = makeS1(); // expected-warning {{unused variable 'x'}} 85 86 // This one cannot, so no warning. 87 S1 y; 88 89 // This call cannot, but the constructor is trivial. 90 S1 z = a; // expected-warning {{unused variable 'z'}} 91 } 92 93 // The same is true even when we know thet constructor has side effects. 94 void foo(); 95 struct S2 { 96 S2() { 97 foo(); 98 } 99 }; 100 S2 makeS2(); 101 void testS2(S2 a) { 102 S2 x = makeS2(); // expected-warning {{unused variable 'x'}} 103 S2 y; 104 S2 z = a; // expected-warning {{unused variable 'z'}} 105 } 106 107 // Or when the constructor is not declared by the user. 108 struct S3 { 109 S1 m; 110 }; 111 S3 makeS3(); 112 void testS3(S3 a) { 113 S3 x = makeS3(); // expected-warning {{unused variable 'x'}} 114 S3 y; 115 S3 z = a; // expected-warning {{unused variable 'z'}} 116 } 117 } 118 119 namespace PR19305 { 120 template<typename T> int n = 0; // no warning 121 int a = n<int>; 122 123 template<typename T> const int l = 0; // no warning 124 int b = l<int>; 125 126 // PR19558 127 template<typename T> const int o = 0; // no warning 128 template<typename T> const int o<T*> = 0; // no warning 129 int c = o<int*>; 130 131 template<> int o<void> = 0; // no warning 132 int d = o<void>; 133 134 // FIXME: It'd be nice to warn here. 135 template<typename T> int m = 0; 136 template<typename T> int m<T*> = 0; 137 138 template<> const int m<void> = 0; // expected-warning {{unused variable}} 139 } 140 141 namespace ctor_with_cleanups { 142 struct S1 { 143 ~S1(); 144 }; 145 struct S2 { 146 S2(const S1&); 147 }; 148 void func() { 149 S2 s((S1())); 150 } 151 } 152 153 #include "Inputs/warn-unused-variables.h" 154 155 namespace arrayRecords { 156 157 class NonTriviallyDestructible { 158 public: 159 ~NonTriviallyDestructible() {} 160 }; 161 162 struct Foo { 163 int x; 164 Foo(int x) : x(x) {} 165 }; 166 167 struct Elidable { 168 Elidable(); 169 }; 170 171 void foo(int size) { 172 Elidable elidable; // no warning 173 Elidable elidableArray[2]; // no warning 174 Elidable elidableDynArray[size]; // no warning 175 Elidable elidableNestedArray[1][2][3]; // no warning 176 177 NonTriviallyDestructible scalar; // no warning 178 NonTriviallyDestructible array[2]; // no warning 179 NonTriviallyDestructible nestedArray[2][2]; // no warning 180 181 Foo fooScalar = 1; // expected-warning {{unused variable 'fooScalar'}} 182 Foo fooArray[] = {1,2}; // expected-warning {{unused variable 'fooArray'}} 183 Foo fooNested[2][2] = { {1,2}, {3,4} }; // expected-warning {{unused variable 'fooNested'}} 184 } 185 186 template<int N> 187 void bar() { 188 NonTriviallyDestructible scaler; // no warning 189 NonTriviallyDestructible array[N]; // no warning 190 } 191 192 void test() { 193 foo(10); 194 bar<2>(); 195 } 196 197 } 198 199 #if __cplusplus >= 201103L 200 namespace with_constexpr { 201 template <typename T> 202 struct Literal { 203 T i; 204 Literal() = default; 205 constexpr Literal(T i) : i(i) {} 206 }; 207 208 struct NoLiteral { 209 int i; 210 NoLiteral() = default; 211 constexpr NoLiteral(int i) : i(i) {} 212 ~NoLiteral() {} 213 }; 214 215 static Literal<int> gl1; // expected-warning {{unused variable 'gl1'}} 216 static Literal<int> gl2(1); // expected-warning {{unused variable 'gl2'}} 217 static const Literal<int> gl3(0); // expected-warning {{unused variable 'gl3'}} 218 219 template <typename T> 220 void test(int i) { 221 Literal<int> l1; // expected-warning {{unused variable 'l1'}} 222 Literal<int> l2(42); // expected-warning {{unused variable 'l2'}} 223 Literal<int> l3(i); // no-warning 224 Literal<T> l4(0); // no-warning 225 NoLiteral nl1; // no-warning 226 NoLiteral nl2(42); // no-warning 227 } 228 } 229 230 namespace crash { 231 struct a { 232 a(const char *); 233 }; 234 template <typename b> 235 void c() { 236 a d(b::e ? "" : ""); 237 } 238 } 239 #endif 240