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