clang/test/SemaCXX/unused.cpp

   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
  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
  27   void test() {
  28     X<int>();
  29   }
  30 }
  31
  32 namespace derefvolatile {
  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 namespace AnonObject {
  48   struct Foo {
  49     Foo(const char* const message);
  50     ~Foo();
  51   };
  52   void f() {
  53     Foo("Hello World!");  // don't warn
  54     int(1); // expected-warning {{expression result unused}}
  55   }
  56 }
  57
  58 // Test that constructing an object (which may have side effects) with
  59 // constructor arguments which are dependent doesn't produce an unused value
  60 // warning.
  61 namespace UnresolvedLookup {
  62   struct Foo {
  63     Foo(int i, int j);
  64   };
  65   template <typename T>
  66   struct Bar {
  67     void f(T t) {
  68       Foo(t, 0);  // no warning
  69     }
  70   };
  71 }
  72
  73 #if __cplusplus >= 201703L
  74 namespace PR33839 {
  75   void a() {
  76     struct X { int a, b; } x;
  77     auto [a, b] = x; // expected-warning {{unused variable '[a, b]'}}
  78     auto [c, d] = x;
  79     (void)d;
  80   }
  81
  82   template<typename T> void f() {
  83     struct A { int n; } a[1];
  84     for (auto [x] : a) {
  85       (void)x;
  86     }
  87     auto [y] = a[0]; // expected-warning {{unused}}
  88   }
  89   template<bool b> void g() {
  90     struct A { int n; } a[1];
  91     for (auto [x] : a) {
  92       if constexpr (b)
  93         (void)x;
  94     }
  95
  96     auto [y] = a[0];
  97     if constexpr (b)
  98       (void)y; // ok, even when b == false
  99   }
 100   template<typename T> void h() {
 101     struct A { int n; } a[1];
 102     for (auto [x] : a) { // expected-warning {{unused variable '[x]'}}
 103     }
 104   }
 105   void use() {
 106     f<int>(); // expected-note {{instantiation of}}
 107     g<true>();
 108     g<false>();
 109     h<int>(); // expected-note {{instantiation of}}
 110   }
 111 }
 112
 113 namespace maybe_unused_binding {
 114
 115 void test() {
 116   struct X { int a, b; } x;
 117   auto [a [[maybe_unused]], b] = x; // expected-warning {{an attribute specifier sequence attached to a structured binding declaration is a C++2c extension}}
 118 }
 119
 120 }
 121
 122 #endif