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