1 // RUN: %clang_cc1 -fsyntax-only -verify -Wunused %s 2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 -Wunused %s 3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wunused %s 4 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 -Wunused %s 5 6 // PR4103 : Make sure we don't get a bogus unused expression warning 7 namespace PR4103 { 8 class APInt { 9 char foo; // expected-warning {{private field 'foo' is not used}} 10 }; 11 class APSInt : public APInt { 12 char bar; // expected-warning {{private field 'bar' is not used}} 13 public: 14 APSInt &operator=(const APSInt &RHS); 15 }; 16 operator =(const APSInt & RHS)17 APSInt& APSInt::operator=(const APSInt &RHS) { 18 APInt::operator=(RHS); 19 return *this; 20 } 21 22 template<typename T> 23 struct X { 24 X(); 25 }; 26 test()27 void test() { 28 X<int>(); 29 } 30 } 31 32 namespace derefvolatile { f(volatile char * x)33 void f(volatile char* x) { 34 *x; 35 #if __cplusplus <= 199711L 36 // expected-warning@-2 {{expression result unused; assign into a variable to force a volatile load}} 37 #endif 38 (void)*x; 39 #if __cplusplus <= 199711L 40 // expected-warning@-2 {{expression result unused; assign into a variable to force a volatile load}} 41 #endif 42 volatile char y = 10; 43 (void)y; // don't warn here, because it's a common pattern. 44 } 45 } 46 47 // <rdar://problem/12359208> 48 namespace AnonObject { 49 struct Foo { 50 Foo(const char* const message); 51 ~Foo(); 52 }; f()53 void f() { 54 Foo("Hello World!"); // don't warn 55 int(1); // expected-warning {{expression result unused}} 56 } 57 } 58 59 // Test that constructing an object (which may have side effects) with 60 // constructor arguments which are dependent doesn't produce an unused value 61 // warning. 62 namespace UnresolvedLookup { 63 struct Foo { 64 Foo(int i, int j); 65 }; 66 template <typename T> 67 struct Bar { fUnresolvedLookup::Bar68 void f(T t) { 69 Foo(t, 0); // no warning 70 } 71 }; 72 } 73 74 #if __cplusplus >= 201703L 75 namespace PR33839 { a()76 void a() { 77 struct X { int a, b; } x; 78 auto [a, b] = x; // expected-warning {{unused variable '[a, b]'}} 79 auto [c, d] = x; 80 (void)d; 81 } 82 f()83 template<typename T> void f() { 84 struct A { int n; } a[1]; 85 for (auto [x] : a) { 86 (void)x; 87 } 88 auto [y] = a[0]; // expected-warning {{unused}} 89 } g()90 template<bool b> void g() { 91 struct A { int n; } a[1]; 92 for (auto [x] : a) { 93 if constexpr (b) 94 (void)x; 95 } 96 97 auto [y] = a[0]; 98 if constexpr (b) 99 (void)y; // ok, even when b == false 100 } h()101 template<typename T> void h() { 102 struct A { int n; } a[1]; 103 for (auto [x] : a) { // expected-warning {{unused variable '[x]'}} 104 } 105 } use()106 void use() { 107 f<int>(); // expected-note {{instantiation of}} 108 g<true>(); 109 g<false>(); 110 h<int>(); // expected-note {{instantiation of}} 111 } 112 } 113 #endif 114