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
f3()9 void f3() { } // expected-warning{{unused}}
10
11 struct S {
m1__anon853b11db0111::S12 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 };
m()23 template <> void TS<int>::m() { } // expected-warning{{unused}}
24
25 template <typename T>
tf()26 void tf() { }
tf()27 template <> void tf<int>() { } // expected-warning{{unused}}
28
29 struct VS {
vm__anon853b11db0111::VS30 virtual void vm() { }
31 };
32
33 struct SVS : public VS {
vm__anon853b11db0111::SVS34 void vm() { }
35 };
36 }
37
m3()38 void S::m3() { } // expected-warning{{unused}}
39
f4()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 {
operator ==(const X &,const X &)64 friend bool operator==(const X&, const X&) { return false; }
65 };
66 }
template_test(X<T> x)67 template <typename T> void template_test(X<T> x) {
68 (void)(x == x);
69 }
test()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 {
foo()84 static void foo() { } // expected-warning {{not needed and will not be emitted}}
85
86 template <int>
bar()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 {
func2unused_nested::outer::__anon853b11db0508109 void func2() {
110 }
111 } x;
112 };
113 }
114
115 namespace unused {
116 struct {
funcunused::__anon853b11db0608117 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 test7
137 {
138 template<typename T>
foo(T)139 static inline void foo(T) { }
140
141 // This should not emit an unused-function warning since it inherits
142 // the static storage type from the base template.
143 template<>
foo(int)144 inline void foo(int) { }
145
146 // Partial specialization
147 template<typename T, typename U>
bar(T,U)148 static inline void bar(T, U) { }
149
150 template<typename U>
bar(int,U)151 inline void bar(int, U) { }
152
153 template<>
bar(int,int)154 inline void bar(int, int) { }
155 };
156
157 namespace pr14776 {
158 namespace {
159 struct X {};
160 }
161 X a = X(); // expected-warning {{unused variable 'a'}}
162 auto b = X(); // expected-warning {{unused variable 'b'}}
163 }
164