1 // RUN: %clang_cc1 -fsyntax-only -Wunused-private-field -Wused-but-marked-unused -Wno-uninitialized -verify -std=c++11 %s
2 
3 class NotFullyDefined {
4  public:
5   NotFullyDefined();
6  private:
7   int y;
8 };
9 
10 class HasUndefinedNestedClass {
11   class Undefined;
12   int unused_;
13 };
14 
15 class HasUndefinedPureVirtualDestructor {
16   virtual ~HasUndefinedPureVirtualDestructor() = 0;
17   int unused_;
18 };
19 
20 class HasDefinedNestedClasses {
21   class DefinedHere {};
22   class DefinedOutside;
23   int unused_; // expected-warning{{private field 'unused_' is not used}}
24 };
25 class HasDefinedNestedClasses::DefinedOutside {};
26 
27 class HasUndefinedFriendFunction {
28   friend void undefinedFriendFunction();
29   int unused_;
30 };
31 
32 class HasUndefinedFriendClass {
33   friend class NotFullyDefined;
34   friend class NotDefined;
35   int unused_;
36 };
37 
38 class HasFriend {
39   friend class FriendClass;
40   friend void friendFunction(HasFriend f);
41   int unused_; // expected-warning{{private field 'unused_' is not used}}
42   int used_by_friend_class_;
43   int used_by_friend_function_;
44 };
45 
46 class ClassWithTemplateFriend {
47   template <typename T> friend class TemplateFriend;
48   int used_by_friend_;
49   int unused_;
50 };
51 
52 template <typename T> class TemplateFriend {
53 public:
54   TemplateFriend(ClassWithTemplateFriend my_friend) {
55     int var = my_friend.used_by_friend_;
56   }
57 };
58 
59 class FriendClass {
60   HasFriend my_friend_;
61   void use() {
62     my_friend_.used_by_friend_class_ = 42;
63   }
64 };
65 
66 void friendFunction(HasFriend my_friend) {
67   my_friend.used_by_friend_function_ = 42;
68 }
69 
70 class NonTrivialConstructor {
71  public:
72   NonTrivialConstructor() {}
73 };
74 
75 class NonTrivialDestructor {
76  public:
77   ~NonTrivialDestructor() {}
78 };
79 
80 class Trivial {
81  public:
82   Trivial() = default;
83   Trivial(int a) {}
84 };
85 
86 int side_effect() {
87   return 42;
88 }
89 
90 class A {
91  public:
92   A() : primitive_type_(42), default_initializer_(), other_initializer_(42),
93         trivial_(), user_constructor_(42),
94         initialized_with_side_effect_(side_effect()) {
95     used_ = 42;
96     attr_used_ = 42; // expected-warning{{'attr_used_' was marked unused but was used}}
97   }
98 
99   A(int x, A* a) : pointer_(a) {}
100 
101  private:
102   int primitive_type_; // expected-warning{{private field 'primitive_type_' is not used}}
103   A* pointer_; // expected-warning{{private field 'pointer_' is not used}}
104   int no_initializer_; // expected-warning{{private field 'no_initializer_' is not used}}
105   int default_initializer_; // expected-warning{{private field 'default_initializer_' is not used}}
106   int other_initializer_; // expected-warning{{private field 'other_initializer_' is not used}}
107   int used_, unused_; // expected-warning{{private field 'unused_' is not used}}
108   int in_class_initializer_ = 42; // expected-warning{{private field 'in_class_initializer_' is not used}}
109   int in_class_initializer_with_side_effect_ = side_effect();
110   Trivial trivial_initializer_ = Trivial(); // expected-warning{{private field 'trivial_initializer_' is not used}}
111   Trivial non_trivial_initializer_ = Trivial(42);
112   int initialized_with_side_effect_;
113   static int static_fields_are_ignored_;
114 
115   Trivial trivial_; // expected-warning{{private field 'trivial_' is not used}}
116   Trivial user_constructor_;
117   NonTrivialConstructor non_trivial_constructor_;
118   NonTrivialDestructor non_trivial_destructor_;
119 
120   int attr_ __attribute__((unused));
121   int attr_used_ __attribute__((unused));
122 };
123 
124 class EverythingUsed {
125  public:
126   EverythingUsed() : as_array_index_(0), var_(by_initializer_) {
127     var_ = sizeof(sizeof_);
128     int *use = &by_reference_;
129     int test[2];
130     test[as_array_index_] = 42;
131   }
132 
133   template<class T>
134   void useStuff(T t) {
135     by_template_function_ = 42;
136   }
137 
138  private:
139   int var_;
140   int sizeof_;
141   int by_reference_;
142   int by_template_function_;
143   int as_array_index_;
144   int by_initializer_;
145 };
146 
147 class HasFeatureTest {
148 #if __has_feature(attribute_unused_on_fields)
149   int unused_; // expected-warning{{private field 'unused_' is not used}}
150   int unused2_ __attribute__((unused)); // no-warning
151 #endif
152 };
153 
154 namespace templates {
155 class B {
156   template <typename T> void f(T t);
157   int a;
158 };
159 }  // namespace templates
160 
161 namespace mutual_friends {
162 // Undefined methods make mutual friends undefined.
163 class A {
164   int a;
165   friend class B;
166   void doSomethingToAOrB();
167 };
168 class B {
169   int b;
170   friend class A;
171 };
172 
173 // Undefined friends do not make a mutual friend undefined.
174 class C {
175   int c;
176   void doSomethingElse() {}
177   friend class E;
178   friend class D;
179 };
180 class D {
181   int d; // expected-warning{{private field 'd' is not used}}
182   friend class C;
183 };
184 
185 // Undefined nested classes make mutual friends undefined.
186 class F {
187   int f;
188   class G;
189   friend class H;
190 };
191 class H {
192   int h;
193   friend class F;
194 };
195 }  // namespace mutual_friends
196 
197 namespace anonymous_structs_unions {
198 class A {
199  private:
200   // FIXME: Look at the DeclContext for anonymous structs/unions.
201   union {
202     int *Aligner;
203     unsigned char Data[8];
204   };
205 };
206 union S {
207  private:
208   int *Aligner;
209   unsigned char Data[8];
210 };
211 }  // namespace anonymous_structs_unions
212 
213 namespace pr13413 {
214 class A {
215   A() : p_(__null), b_(false), a_(this), p2_(nullptr) {}
216   void* p_;  // expected-warning{{private field 'p_' is not used}}
217   bool b_;  // expected-warning{{private field 'b_' is not used}}
218   A* a_;  // expected-warning{{private field 'a_' is not used}}
219   void* p2_;  // expected-warning{{private field 'p2_' is not used}}
220 };
221 }
222 
223 namespace pr13543 {
224   void f(int);
225   void f(char);
226   struct S {
227     S() : p(&f) {}
228   private:
229     void (*p)(int); // expected-warning{{private field 'p' is not used}}
230   };
231 
232   struct A { int n; };
233   struct B {
234     B() : a(A()) {}
235     B(char) {}
236     B(int n) : a{n}, b{(f(n), 0)} {}
237   private:
238     A a = A(); // expected-warning{{private field 'a' is not used}}
239     A b;
240   };
241 
242   struct X { ~X(); };
243   class C {
244     X x[4]; // no-warning
245   };
246 }
247