clang/test/SemaCXX/warn-unused-variables.cpp

   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=expected,cxx98-14 -std=gnu++11 %s
   3 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify=expected,cxx98-14 -std=gnu++14 %s
   4 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify -std=gnu++17 %s
   5
   6 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify %s -fexperimental-new-constant-interpreter
   7 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify=expected,cxx98-14 -std=gnu++11 %s -fexperimental-new-constant-interpreter
   8 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify=expected,cxx98-14 -std=gnu++14 %s -fexperimental-new-constant-interpreter
   9 // RUN: %clang_cc1 -fsyntax-only -Wunused-variable -Wunused-label -Wno-c++1y-extensions -verify -std=gnu++17 %s -fexperimental-new-constant-interpreter
  10
  11 template<typename T> void f() {
  12   T t;
  13   t = 17;
  14 }
  15
  16 // PR5407
  17 struct A { A(); };
  18 struct B { ~B(); };
  19 void f() {
  20   A a;
  21   B b;
  22 }
  23
  24 // PR5531
  25 namespace PR5531 {
  26   struct A {
  27   };
  28
  29   struct B {
  30     B(int);
  31   };
  32
  33   struct C {
  34     ~C();
  35   };
  36
  37   void test() {
  38     A();
  39     B(17);
  40     C();
  41   }
  42 }
  43
  44 template<typename T>
  45 struct X0 { };
  46
  47 template<typename T>
  48 void test_dependent_init(T *p) {
  49   X0<int> i(p);
  50   (void)i;
  51 }
  52
  53 void unused_local_static() {
  54   static int x = 0;
  55   static int y = 0; // expected-warning{{unused variable 'y'}}
  56 #pragma unused(x)
  57   static __attribute__((used)) int z;
  58   static __attribute__((unused)) int w;
  59   [[maybe_unused]] static int v;
  60 }
  61
  62 // PR10168
  63 namespace PR10168 {
  64   // We expect a warning in the definition only for non-dependent variables, and
  65   // a warning in the instantiation only for dependent variables.
  66   template<typename T>
  67   struct S {
  68     void f() {
  69       int a; // expected-warning {{unused variable 'a'}}
  70       T b; // expected-warning 2{{unused variable 'b'}}
  71     }
  72   };
  73
  74   template<typename T>
  75   void f() {
  76     int a; // expected-warning {{unused variable 'a'}}
  77     T b; // expected-warning 2{{unused variable 'b'}}
  78   }
  79
  80   void g() {
  81     S<int>().f(); // expected-note {{here}}
  82     S<char>().f(); // expected-note {{here}}
  83     f<int>(); // expected-note {{here}}
  84     f<char>(); // expected-note {{here}}
  85   }
  86 }
  87
  88 namespace PR11550 {
  89   struct S1 {
  90     S1();
  91   };
  92   S1 makeS1();
  93   void testS1(S1 a) {
  94     // This constructor call can be elided.
  95     S1 x = makeS1(); // expected-warning {{unused variable 'x'}}
  96
  97     // This one cannot, so no warning.
  98     S1 y;
  99
 100     // This call cannot, but the constructor is trivial.
 101     S1 z = a; // expected-warning {{unused variable 'z'}}
 102   }
 103
 104   // The same is true even when we know thet constructor has side effects.
 105   void foo();
 106   struct S2 {
 107     S2() {
 108       foo();
 109     }
 110   };
 111   S2 makeS2();
 112   void testS2(S2 a) {
 113     S2 x = makeS2(); // expected-warning {{unused variable 'x'}}
 114     S2 y;
 115     S2 z = a; // expected-warning {{unused variable 'z'}}
 116   }
 117
 118   // Or when the constructor is not declared by the user.
 119   struct S3 {
 120     S1 m;
 121   };
 122   S3 makeS3();
 123   void testS3(S3 a) {
 124     S3 x = makeS3(); // expected-warning {{unused variable 'x'}}
 125     S3 y;
 126     S3 z = a; // expected-warning {{unused variable 'z'}}
 127   }
 128 }
 129
 130 namespace PR19305 {
 131   template<typename T> int n = 0; // no warning
 132   int a = n<int>;
 133
 134   template<typename T> const int l = 0; // no warning
 135   int b = l<int>;
 136
 137   // PR19558
 138   template<typename T> const int o = 0; // no warning
 139   template<typename T> const int o<T*> = 0; // no warning
 140   int c = o<int*>;
 141
 142   template<> int o<void> = 0; // no warning
 143   int d = o<void>;
 144
 145   // FIXME: It'd be nice to warn here.
 146   template<typename T> int m = 0;
 147   template<typename T> int m<T*> = 0;
 148
 149   // This has external linkage, so could be referenced by a declaration in a
 150   // different translation unit.
 151   template<> const int m<void> = 0; // no warning
 152 }
 153
 154 namespace ctor_with_cleanups {
 155   struct S1 {
 156     ~S1();
 157   };
 158   struct S2 {
 159     S2(const S1&);
 160   };
 161   void func() {
 162     S2 s((S1()));
 163   }
 164 }
 165
 166 #include "Inputs/warn-unused-variables.h"
 167
 168 class NonTriviallyDestructible {
 169 public:
 170   ~NonTriviallyDestructible() {}
 171 };
 172
 173 namespace arrayRecords {
 174
 175 struct Foo {
 176   int x;
 177   Foo(int x) : x(x) {}
 178 };
 179
 180 struct Elidable {
 181   Elidable();
 182 };
 183
 184 void foo(int size) {
 185   Elidable elidable; // no warning
 186   Elidable elidableArray[2]; // no warning
 187   Elidable elidableDynArray[size]; // no warning
 188   Elidable elidableNestedArray[1][2][3]; // no warning
 189
 190   NonTriviallyDestructible scalar; // no warning
 191   NonTriviallyDestructible array[2];  // no warning
 192   NonTriviallyDestructible nestedArray[2][2]; // no warning
 193
 194   // Copy initialzation gives warning before C++17
 195   Foo fooScalar = 1; // cxx98-14-warning {{unused variable 'fooScalar'}}
 196   Foo fooArray[] = {1,2}; // expected-warning {{unused variable 'fooArray'}}
 197   Foo fooNested[2][2] = { {1,2}, {3,4} }; // expected-warning {{unused variable 'fooNested'}}
 198 }
 199
 200 template<int N>
 201 void bar() {
 202   NonTriviallyDestructible scaler; // no warning
 203   NonTriviallyDestructible array[N]; // no warning
 204 }
 205
 206 void test() {
 207   foo(10);
 208   bar<2>();
 209 }
 210
 211 } // namespace arrayRecords
 212
 213 #if __cplusplus >= 201103L
 214 namespace with_constexpr {
 215 template <typename T>
 216 struct Literal {
 217   T i;
 218   Literal() = default;
 219   constexpr Literal(T i) : i(i) {}
 220 };
 221
 222 struct NoLiteral {
 223   int i;
 224   NoLiteral() = default;
 225   constexpr NoLiteral(int i) : i(i) {}
 226   ~NoLiteral() {}
 227 };
 228
 229 static Literal<int> gl1;          // expected-warning {{unused variable 'gl1'}}
 230 static Literal<int> gl2(1);       // expected-warning {{unused variable 'gl2'}}
 231 static const Literal<int> gl3(0); // expected-warning {{unused variable 'gl3'}}
 232
 233 template <typename T>
 234 void test(int i) {
 235   Literal<int> l1;     // expected-warning {{unused variable 'l1'}}
 236   Literal<int> l2(42); // expected-warning {{unused variable 'l2'}}
 237   Literal<int> l3(i);  // no-warning
 238   Literal<T> l4(0);    // no-warning
 239   NoLiteral nl1;       // no-warning
 240   NoLiteral nl2(42);   // no-warning
 241 }
 242 }
 243
 244 namespace crash {
 245 struct a {
 246   a(const char *);
 247 };
 248 template <typename b>
 249 void c() {
 250   a d(b::e ? "" : "");
 251 }
 252 }
 253
 254 // Ensure we don't warn on dependent constructor calls.
 255 namespace dependent_ctor {
 256 struct S {
 257   S() = default;
 258   S(const S &) = default;
 259   S(int);
 260 };
 261
 262 template <typename T>
 263 void foo(T &t) {
 264   S s{t};
 265 }
 266 }
 267 #endif
 268
 269 // Ensure we do not warn on lifetime extension
 270 namespace gh54489 {
 271
 272 void f() {
 273   const auto &a = NonTriviallyDestructible();
 274   const auto &b = a; // expected-warning {{unused variable 'b'}}
 275 #if __cplusplus >= 201103L
 276   const auto &&c = NonTriviallyDestructible();
 277   auto &&d = c; // expected-warning {{unused variable 'd'}}
 278 #endif
 279 }
 280
 281 struct S {
 282   S() = default;
 283   S(const S &) = default;
 284   S(int);
 285 };
 286
 287 template <typename T>
 288 void foo(T &t) {
 289   const auto &extended = S{t};
 290 }
 291
 292 void test_foo() {
 293   int i;
 294   foo(i);
 295 }
 296
 297 struct RAIIWrapper {
 298   RAIIWrapper();
 299   ~RAIIWrapper();
 300 };
 301
 302 void RAIIWrapperTest() {
 303   auto const guard = RAIIWrapper();
 304   auto const &guard2 = RAIIWrapper();
 305   auto &&guard3 = RAIIWrapper();
 306 }
 307
 308 } // namespace gh54489
 309
 310 // Ensure that -Wunused-variable does not emit warning
 311 // on copy constructors with side effects (C++17 and later)
 312 #if __cplusplus >= 201703L
 313 namespace gh79518 {
 314
 315 struct S {
 316     S(int);
 317 };
 318
 319 // With an initializer list
 320 struct A {
 321   int x;
 322   A(int x) : x(x) {}
 323 };
 324
 325 void foo() {
 326     S s(0); // no warning
 327     S s2 = 0; // no warning
 328     S s3{0}; // no warning
 329
 330     A a = 1; // no warning
 331 }
 332
 333 } // namespace gh79518
 334 #endif