warn-unused-filescoped.cpp revision 6bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89 
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
6static void headerstatic() {}  // expected-warning{{unused}}
7static inline void headerstaticinline() {}
8
9namespace {
10  void headeranon() {}  // expected-warning{{unused}}
11  inline void headerinlineanon() {}
12}
13
14namespace 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
35namespace 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
46static void f1(); // expected-warning{{unused}}
47
48namespace {
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
80void S::m3() { }  // expected-warning{{unused}}
81
82static inline void f4() { }  // expected-warning{{unused}}
83const unsigned int cx = 0; // expected-warning{{unused}}
84const unsigned int cy = 0;
85int f5() { return cy; }
86
87static int x1;  // expected-warning{{unused}}
88
89namespace {
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
103namespace 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
120namespace test4 {
121  namespace { struct A {}; }
122
123  void test(A a); // expected-warning {{unused function}}
124  extern "C" void test4(A a);
125}
126
127namespace 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
136namespace 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
149namespace unused_nested {
150  class outer {
151    void func1();
152    struct {
153      void func2() {
154      }
155    } x;
156  };
157}
158
159namespace unused {
160  struct {
161    void func() { // expected-warning {{unused member function}}
162    }
163  } x; // expected-warning {{unused variable}}
164}
165
166namespace 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
180namespace 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
188namespace UndefinedInternalStaticMember {
189  namespace {
190    struct X {
191      static const unsigned x = 3;
192      int y[x];
193    };
194  }
195}
196
197namespace test8 {
198static void func();
199void bar() { void func() __attribute__((used)); }
200static void func() {}
201}
202
203namespace 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