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