1 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -verify %s 2 template<typename T> void f() { 3 T t; 4 t = 17; 5 } 6 7 // PR5407 8 struct A { A(); }; 9 struct B { ~B(); }; 10 void f() { 11 A a; 12 B b; 13 } 14 15 // PR5531 16 namespace PR5531 { 17 struct A { 18 }; 19 20 struct B { 21 B(int); 22 }; 23 24 struct C { 25 ~C(); 26 }; 27 28 void test() { 29 A(); 30 B(17); 31 C(); 32 } 33 } 34 35 template<typename T> 36 struct X0 { }; 37 38 template<typename T> 39 void test_dependent_init(T *p) { 40 X0<int> i(p); 41 (void)i; 42 } 43 44 namespace PR6948 { 45 template<typename T> class X; 46 47 void f() { 48 X<char> str (read_from_file()); // expected-error{{use of undeclared identifier 'read_from_file'}} 49 } 50 } 51 52 void unused_local_static() { 53 static int x = 0; 54 static int y = 0; // expected-warning{{unused variable 'y'}} 55 #pragma unused(x) 56 } 57 58 // PR10168 59 namespace PR10168 { 60 // We expect a warning in the definition only for non-dependent variables, and 61 // a warning in the instantiation only for dependent variables. 62 template<typename T> 63 struct S { 64 void f() { 65 int a; // expected-warning {{unused variable 'a'}} 66 T b; // expected-warning 2{{unused variable 'b'}} 67 } 68 }; 69 70 template<typename T> 71 void f() { 72 int a; // expected-warning {{unused variable 'a'}} 73 T b; // expected-warning 2{{unused variable 'b'}} 74 } 75 76 void g() { 77 S<int>().f(); // expected-note {{here}} 78 S<char>().f(); // expected-note {{here}} 79 f<int>(); // expected-note {{here}} 80 f<char>(); // expected-note {{here}} 81 } 82 } 83 84 namespace PR11550 { 85 struct S1 { 86 S1(); 87 }; 88 S1 makeS1(); 89 void testS1(S1 a) { 90 // This constructor call can be elided. 91 S1 x = makeS1(); // expected-warning {{unused variable 'x'}} 92 93 // This one cannot, so no warning. 94 S1 y; 95 96 // This call cannot, but the constructor is trivial. 97 S1 z = a; // expected-warning {{unused variable 'z'}} 98 } 99 100 // The same is true even when we know thet constructor has side effects. 101 void foo(); 102 struct S2 { 103 S2() { 104 foo(); 105 } 106 }; 107 S2 makeS2(); 108 void testS2(S2 a) { 109 S2 x = makeS2(); // expected-warning {{unused variable 'x'}} 110 S2 y; 111 S2 z = a; // expected-warning {{unused variable 'z'}} 112 } 113 114 // Or when the constructor is not declared by the user. 115 struct S3 { 116 S1 m; 117 }; 118 S3 makeS3(); 119 void testS3(S3 a) { 120 S3 x = makeS3(); // expected-warning {{unused variable 'x'}} 121 S3 y; 122 S3 z = a; // expected-warning {{unused variable 'z'}} 123 } 124 } 125