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 #ifdef HEADER
      5 
      6 static void headerstatic() {}  // expected-warning{{unused}}
      7 static inline void headerstaticinline() {}
      8 
      9 namespace {
     10   void headeranon() {}  // expected-warning{{unused}}
     11   inline void headerinlineanon() {}
     12 }
     13 
     14 namespace test7
     15 {
     16   template<typename T>
     17   static inline void foo(T) { }
     18 
     19   // This should not emit an unused-function warning since it inherits
     20   // the static storage type from the base template.
     21   template<>
     22   inline void foo(int) {  }
     23 
     24   // Partial specialization
     25   template<typename T, typename U>
     26   static inline void bar(T, U) { }
     27 
     28   template<typename U>
     29   inline void bar(int, U) { }
     30 
     31   template<>
     32   inline void bar(int, int) { }
     33 };
     34 
     35 namespace pr19713 {
     36 #if __cplusplus >= 201103L
     37   static constexpr int constexpr1() { return 1; }
     38   constexpr int constexpr2() { return 2; }
     39 #endif
     40 }
     41 
     42 #else
     43 #define HEADER
     44 #include "warn-unused-filescoped.cpp"
     45 
     46 static void f1(); // expected-warning{{unused}}
     47 
     48 namespace {
     49   void f2();  // expected-warning{{unused}}
     50 
     51   void f3() { }  // expected-warning{{unused}}
     52 
     53   struct S {
     54     void m1() { }  // expected-warning{{unused}}
     55     void m2();  // expected-warning{{unused}}
     56     void m3();
     57     S(const S&);
     58     void operator=(const S&);
     59   };
     60 
     61   template <typename T>
     62   struct TS {
     63     void m();
     64   };
     65   template <> void TS<int>::m() { }  // expected-warning{{unused}}
     66 
     67   template <typename T>
     68   void tf() { }
     69   template <> void tf<int>() { }  // expected-warning{{unused}}
     70 
     71   struct VS {
     72     virtual void vm() { }
     73   };
     74 
     75   struct SVS : public VS {
     76     void vm() { }
     77   };
     78 }
     79 
     80 void S::m3() { }  // expected-warning{{unused}}
     81 
     82 static inline void f4() { }  // expected-warning{{unused}}
     83 const unsigned int cx = 0; // expected-warning{{unused}}
     84 const unsigned int cy = 0;
     85 int f5() { return cy; }
     86 
     87 static int x1;  // expected-warning{{unused}}
     88 
     89 namespace {
     90   int x2;  // expected-warning{{unused}}
     91 
     92   struct S2 {
     93     static int x;  // expected-warning{{unused}}
     94   };
     95 
     96   template <typename T>
     97   struct TS2 {
     98     static int x;
     99   };
    100   template <> int TS2<int>::x;  // expected-warning{{unused}}
    101 }
    102 
    103 namespace PR8841 {
    104   // Ensure that friends of class templates are considered to have a dependent
    105   // context and not marked unused.
    106   namespace {
    107     template <typename T> struct X {
    108       friend bool operator==(const X&, const X&) { return false; }
    109     };
    110   }
    111   template <typename T> void template_test(X<T> x) {
    112     (void)(x == x);
    113   }
    114   void test() {
    115     X<int> x;
    116     template_test(x);
    117   }
    118 }
    119 
    120 namespace test4 {
    121   namespace { struct A {}; }
    122 
    123   void test(A a); // expected-warning {{unused function}}
    124   extern "C" void test4(A a);
    125 }
    126 
    127 namespace rdar8733476 {
    128   static void foo() { } // expected-warning {{not needed and will not be emitted}}
    129 
    130   template <int>
    131   void bar() {
    132     foo();
    133   }
    134 }
    135 
    136 namespace test5 {
    137   static int n = 0;
    138   static int &r = n;
    139   int f(int &);
    140   int k = f(r);
    141 
    142   // FIXME: We should produce warnings for both of these.
    143   static const int m = n;
    144   int x = sizeof(m);
    145   static const double d = 0.0; // expected-warning{{not needed and will not be emitted}}
    146   int y = sizeof(d);
    147 }
    148 
    149 namespace unused_nested {
    150   class outer {
    151     void func1();
    152     struct {
    153       void func2() {
    154       }
    155     } x;
    156   };
    157 }
    158 
    159 namespace unused {
    160   struct {
    161     void func() { // expected-warning {{unused member function}}
    162     }
    163   } x; // expected-warning {{unused variable}}
    164 }
    165 
    166 namespace test6 {
    167   typedef struct {
    168     void bar();
    169   } A;
    170 
    171   typedef struct {
    172     void bar();  // expected-warning {{unused member function 'bar'}}
    173   } *B;
    174 
    175   struct C {
    176     void bar();
    177   };
    178 }
    179 
    180 namespace pr14776 {
    181   namespace {
    182     struct X {};
    183   }
    184   X a = X(); // expected-warning {{unused variable 'a'}}
    185   auto b = X(); // expected-warning {{unused variable 'b'}}
    186 }
    187 
    188 namespace UndefinedInternalStaticMember {
    189   namespace {
    190     struct X {
    191       static const unsigned x = 3;
    192       int y[x];
    193     };
    194   }
    195 }
    196 
    197 namespace test8 {
    198 static void func();
    199 void bar() { void func() __attribute__((used)); }
    200 static void func() {}
    201 }
    202 
    203 namespace pr19713 {
    204 #if __cplusplus >= 201103L
    205   // FIXME: We should warn on both of these.
    206   static constexpr int constexpr3() { return 1; } // expected-warning {{unused}}
    207   constexpr int constexpr4() { return 2; }
    208 #endif
    209 }
    210 
    211 #endif
    212