Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -fsyntax-only -verify -Wunused -Wunused-member-function -Wno-c++11-extensions -std=c++98 %s
      2 // RUN: %clang_cc1 -fsyntax-only -verify -Wunused -Wunused-member-function -std=c++11 %s
      3 
      4 static void f1(); // expected-warning{{unused}}
      5 
      6 namespace {
      7   void f2();  // expected-warning{{unused}}
      8 
      9   void f3() { }  // expected-warning{{unused}}
     10 
     11   struct S {
     12     void m1() { }  // expected-warning{{unused}}
     13     void m2();  // expected-warning{{unused}}
     14     void m3();
     15     S(const S&);
     16     void operator=(const S&);
     17   };
     18 
     19   template <typename T>
     20   struct TS {
     21     void m();
     22   };
     23   template <> void TS<int>::m() { }  // expected-warning{{unused}}
     24 
     25   template <typename T>
     26   void tf() { }
     27   template <> void tf<int>() { }  // expected-warning{{unused}}
     28 
     29   struct VS {
     30     virtual void vm() { }
     31   };
     32 
     33   struct SVS : public VS {
     34     void vm() { }
     35   };
     36 }
     37 
     38 void S::m3() { }  // expected-warning{{unused}}
     39 
     40 static inline void f4() { }
     41 const unsigned int cx = 0;
     42 
     43 static int x1;  // expected-warning{{unused}}
     44 
     45 namespace {
     46   int x2;  // expected-warning{{unused}}
     47 
     48   struct S2 {
     49     static int x;  // expected-warning{{unused}}
     50   };
     51 
     52   template <typename T>
     53   struct TS2 {
     54     static int x;
     55   };
     56   template <> int TS2<int>::x;  // expected-warning{{unused}}
     57 }
     58 
     59 namespace PR8841 {
     60   // Ensure that friends of class templates are considered to have a dependent
     61   // context and not marked unused.
     62   namespace {
     63     template <typename T> struct X {
     64       friend bool operator==(const X&, const X&) { return false; }
     65     };
     66   }
     67   template <typename T> void template_test(X<T> x) {
     68     (void)(x == x);
     69   }
     70   void test() {
     71     X<int> x;
     72     template_test(x);
     73   }
     74 }
     75 
     76 namespace test4 {
     77   namespace { struct A {}; }
     78 
     79   void test(A a); // expected-warning {{unused function}}
     80   extern "C" void test4(A a);
     81 }
     82 
     83 namespace rdar8733476 {
     84   static void foo() { } // expected-warning {{not needed and will not be emitted}}
     85 
     86   template <int>
     87   void bar() {
     88     foo();
     89   }
     90 }
     91 
     92 namespace test5 {
     93   static int n = 0;
     94   static int &r = n;
     95   int f(int &);
     96   int k = f(r);
     97 
     98   // FIXME: We should produce warnings for both of these.
     99   static const int m = n;
    100   int x = sizeof(m);
    101   static const double d = 0.0;
    102   int y = sizeof(d);
    103 }
    104 
    105 namespace unused_nested {
    106   class outer {
    107     void func1();
    108     struct {
    109       void func2() {
    110       }
    111     } x;
    112   };
    113 }
    114 
    115 namespace unused {
    116   struct {
    117     void func() { // expected-warning {{unused member function}}
    118     }
    119   } x; // expected-warning {{unused variable}}
    120 }
    121 
    122 namespace test6 {
    123   typedef struct {
    124     void bar();
    125   } A;
    126 
    127   typedef struct {
    128     void bar();  // expected-warning {{unused member function 'bar'}}
    129   } *B;
    130 
    131   struct C {
    132     void bar();
    133   };
    134 }
    135 
    136 namespace pr14776 {
    137   namespace {
    138     struct X {};
    139   }
    140   X a = X(); // expected-warning {{unused variable 'a'}}
    141   auto b = X(); // expected-warning {{unused variable 'b'}}
    142 }
    143