1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2
3 struct A {};
4 enum B { Dummy };
5 namespace C {}
6 struct D : A {};
7 struct E : A {};
8 struct F : D, E {};
9 struct G : virtual D {};
10 class H : A {}; // expected-note 2{{implicitly declared private here}}
11
12 int A::*pdi1;
13 int (::A::*pdi2);
14 int (A::*pfi)(int);
15 void (*A::*ppfie)() throw(); // expected-error {{exception specifications are not allowed beyond a single level of indirection}}
16
17 int B::*pbi; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \
18 // expected-error {{'pbi' does not point into a class}}
19 int C::*pci; // expected-error {{'pci' does not point into a class}}
20 void A::*pdv; // expected-error {{'pdv' declared as a member pointer to void}}
21 int& A::*pdr; // expected-error {{'pdr' declared as a member pointer to a reference}}
22
f()23 void f() {
24 // This requires tentative parsing.
25 int (A::*pf)(int, int);
26
27 // Implicit conversion to bool.
28 bool b = pdi1;
29 b = pfi;
30
31 // Conversion from null pointer constant.
32 pf = 0;
33 pf = __null;
34
35 // Conversion to member of derived.
36 int D::*pdid = pdi1;
37 pdid = pdi2;
38
39 // Fail conversion due to ambiguity and virtuality.
40 int F::*pdif = pdi1; // expected-error {{ambiguous conversion from pointer to member of base class 'A' to pointer to member of derived class 'F':}}
41 int G::*pdig = pdi1; // expected-error {{conversion from pointer to member of class 'A' to pointer to member of class 'G' via virtual base 'D' is not allowed}}
42
43 // Conversion to member of base.
44 pdi1 = pdid; // expected-error {{assigning to 'int A::*' from incompatible type 'int D::*'}}
45
46 // Comparisons
47 int (A::*pf2)(int, int);
48 int (D::*pf3)(int, int) = 0;
49 bool b1 = (pf == pf2); (void)b1;
50 bool b2 = (pf != pf2); (void)b2;
51 bool b3 = (pf == pf3); (void)b3;
52 bool b4 = (pf != 0); (void)b4;
53 }
54
55 struct TheBase
56 {
57 void d();
58 };
59
60 struct HasMembers : TheBase
61 {
62 int i;
63 void f();
64
65 void g();
66 void g(int);
67 static void g(double);
68 };
69
70 namespace Fake
71 {
72 int i;
73 void f();
74 }
75
g()76 void g() {
77 HasMembers hm;
78
79 int HasMembers::*pmi = &HasMembers::i;
80 int *pni = &Fake::i;
81 int *pmii = &hm.i;
82
83 void (HasMembers::*pmf)() = &HasMembers::f;
84 void (*pnf)() = &Fake::f;
85 &hm.f; // expected-error {{cannot create a non-constant pointer to member function}}
86
87 void (HasMembers::*pmgv)() = &HasMembers::g;
88 void (HasMembers::*pmgi)(int) = &HasMembers::g;
89 void (*pmgd)(double) = &HasMembers::g;
90
91 void (HasMembers::*pmd)() = &HasMembers::d;
92 }
93
94 struct Incomplete;
95
h()96 void h() {
97 HasMembers hm, *phm = &hm;
98
99 int HasMembers::*pi = &HasMembers::i;
100 hm.*pi = 0;
101 int i = phm->*pi;
102 (void)&(hm.*pi);
103 (void)&(phm->*pi);
104 (void)&((&hm)->*pi);
105
106 void (HasMembers::*pf)() = &HasMembers::f;
107 (hm.*pf)();
108 (phm->*pf)();
109
110 (void)(hm->*pi); // expected-error {{left hand operand to ->* must be a pointer to class compatible with the right hand operand, but is 'HasMembers'}}
111 (void)(phm.*pi); // expected-error {{left hand operand to .* must be a class compatible with the right hand operand, but is 'HasMembers *'}}
112 (void)(i.*pi); // expected-error {{left hand operand to .* must be a class compatible with the right hand operand, but is 'int'}}
113 int *ptr;
114 (void)(ptr->*pi); // expected-error {{left hand operand to ->* must be a pointer to class compatible with the right hand operand, but is 'int *'}}
115
116 int A::*pai = 0;
117 D d, *pd = &d;
118 (void)(d.*pai);
119 (void)(pd->*pai);
120 F f, *ptrf = &f;
121 (void)(f.*pai); // expected-error {{ambiguous conversion from derived class 'F' to base class 'A'}}
122 (void)(ptrf->*pai); // expected-error {{ambiguous conversion from derived class 'F' to base class 'A'}}
123 H h, *ptrh = &h;
124 (void)(h.*pai); // expected-error {{cannot cast 'H' to its private base class 'A'}}
125 (void)(ptrh->*pai); // expected-error {{cannot cast 'H' to its private base class 'A'}}
126
127 (void)(hm.*i); // expected-error {{pointer-to-member}}
128 (void)(phm->*i); // expected-error {{pointer-to-member}}
129
130 // Okay
131 Incomplete *inc;
132 int Incomplete::*pii = 0;
133 (void)(inc->*pii);
134 }
135
136 struct OverloadsPtrMem
137 {
138 int operator ->*(const char *);
139 };
140
i()141 void i() {
142 OverloadsPtrMem m;
143 int foo = m->*"Awesome!";
144 }
145
146 namespace pr5985 {
147 struct c {
148 void h();
fpr5985::c149 void f() {
150 void (c::*p)();
151 p = &h; // expected-error {{must explicitly qualify}}
152 p = &this->h; // expected-error {{cannot create a non-constant pointer to member function}}
153 p = &(*this).h; // expected-error {{cannot create a non-constant pointer to member function}}
154 }
155 };
156 }
157
158 namespace pr6783 {
159 struct Base {};
160 struct X; // expected-note {{forward declaration}}
161
test1(int Base::* p2m,X * object)162 int test1(int Base::* p2m, X* object)
163 {
164 return object->*p2m; // expected-error {{left hand operand to ->*}}
165 }
166 }
167
168 namespace PR7176 {
169 namespace base
170 {
171 struct Process
172 { };
173 struct Continuous : Process
174 {
175 bool cond();
176 };
177 }
178
179 typedef bool( base::Process::*Condition )();
180
m()181 void m()
182 { (void)(Condition) &base::Continuous::cond; }
183 }
184
185 namespace rdar8358512 {
186 // We can't call this with an overload set because we're not allowed
187 // to look into overload sets unless the parameter has some kind of
188 // function type.
189 template <class F> void bind(F f); // expected-note 12 {{candidate template ignored}}
190 template <class F, class T> void bindmem(F (T::*f)()); // expected-note 4 {{candidate template ignored}}
191 template <class F> void bindfn(F (*f)()); // expected-note 4 {{candidate template ignored}}
192
193 struct A {
194 void nonstat();
195 void nonstat(int);
196
197 void mixed();
198 static void mixed(int);
199
200 static void stat();
201 static void stat(int);
202
203 template <typename T> struct Test0 {
testrdar8358512::A::Test0204 void test() {
205 bind(&nonstat); // expected-error {{no matching function for call}}
206 bind(&A::nonstat); // expected-error {{no matching function for call}}
207
208 bind(&mixed); // expected-error {{no matching function for call}}
209 bind(&A::mixed); // expected-error {{no matching function for call}}
210
211 bind(&stat); // expected-error {{no matching function for call}}
212 bind(&A::stat); // expected-error {{no matching function for call}}
213 }
214 };
215
216 template <typename T> struct Test1 {
testrdar8358512::A::Test1217 void test() {
218 bindmem(&nonstat); // expected-error {{no matching function for call}}
219 bindmem(&A::nonstat);
220
221 bindmem(&mixed); // expected-error {{no matching function for call}}
222 bindmem(&A::mixed);
223
224 bindmem(&stat); // expected-error {{no matching function for call}}
225 bindmem(&A::stat); // expected-error {{no matching function for call}}
226 }
227 };
228
229 template <typename T> struct Test2 {
testrdar8358512::A::Test2230 void test() {
231 bindfn(&nonstat); // expected-error {{no matching function for call}}
232 bindfn(&A::nonstat); // expected-error {{no matching function for call}}
233
234 bindfn(&mixed); // expected-error {{no matching function for call}}
235 bindfn(&A::mixed); // expected-error {{no matching function for call}}
236
237 bindfn(&stat);
238 bindfn(&A::stat);
239 }
240 };
241 };
242
243 template <class T> class B {
244 void nonstat();
245 void nonstat(int);
246
247 void mixed();
248 static void mixed(int);
249
250 static void stat();
251 static void stat(int);
252
253 // None of these can be diagnosed yet, because the arguments are
254 // still dependent.
test0a()255 void test0a() {
256 bind(&nonstat);
257 bind(&B::nonstat);
258
259 bind(&mixed);
260 bind(&B::mixed);
261
262 bind(&stat);
263 bind(&B::stat);
264 }
265
test0b()266 void test0b() {
267 bind(&nonstat); // expected-error {{no matching function for call}}
268 bind(&B::nonstat); // expected-error {{no matching function for call}}
269
270 bind(&mixed); // expected-error {{no matching function for call}}
271 bind(&B::mixed); // expected-error {{no matching function for call}}
272
273 bind(&stat); // expected-error {{no matching function for call}}
274 bind(&B::stat); // expected-error {{no matching function for call}}
275 }
276 };
277
278 template void B<int>::test0b(); // expected-note {{in instantiation}}
279 }
280
281 namespace PR9973 {
282 template<class R, class T> struct dm
283 {
284 typedef R T::*F;
285 F f_;
callPR9973::dm286 template<class U> int & call(U u)
287 { return u->*f_; } // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}} expected-error {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
288
operator ()PR9973::dm289 template<class U> int operator()(U u)
290 { call(u); } // expected-note{{in instantiation of}}
291 };
292
293 template<class R, class T>
294 dm<R, T> mem_fn(R T::*) ;
295
296 struct test
297 { int nullary_v(); };
298
f()299 void f()
300 {
301 test* t;
302 mem_fn(&test::nullary_v)(t); // expected-note{{in instantiation of}}
303 }
304 }
305
306 namespace test8 {
307 struct A { int foo; };
test1()308 int test1() {
309 // Verify that we perform (and check) an lvalue conversion on the operands here.
310 return (*((A**) 0)) // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}}
311 ->**(int A::**) 0; // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}}
312 }
313
test2()314 int test2() {
315 // Verify that we perform (and check) an lvalue conversion on the operands here.
316 // TODO: the .* should itself warn about being a dereference of null.
317 return (*((A*) 0))
318 .**(int A::**) 0; // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}}
319 }
320 }
321