member-pointer.cpp revision 5acb0c98b363400f6ade0ae7250f0102224e806b 
1// RUN: %clang_cc1 -fsyntax-only -verify %s
2
3struct A {};
4enum B { Dummy };
5namespace C {}
6struct D : A {};
7struct E : A {};
8struct F : D, E {};
9struct G : virtual D {};
10
11int A::*pdi1;
12int (::A::*pdi2);
13int (A::*pfi)(int);
14
15int B::*pbi; // expected-error {{expected a class or namespace}}
16int C::*pci; // expected-error {{'pci' does not point into a class}}
17void A::*pdv; // expected-error {{'pdv' declared as a member pointer to void}}
18int& A::*pdr; // expected-error {{'pdr' declared as a member pointer to a reference}}
19
20void 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
52struct TheBase
53{
54  void d();
55};
56
57struct HasMembers : TheBase
58{
59  int i;
60  void f();
61
62  void g();
63  void g(int);
64  static void g(double);
65};
66
67namespace Fake
68{
69  int i;
70  void f();
71}
72
73void 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
91struct Incomplete;
92
93void 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
130struct OverloadsPtrMem
131{
132  int operator ->*(const char *);
133};
134
135void i() {
136  OverloadsPtrMem m;
137  int foo = m->*"Awesome!";
138}
139
140namespace pr5985 {
141  struct c {
142    void h();
143    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
152namespace pr6783 {
153  struct Base {};
154  struct X; // expected-note {{forward declaration}}
155
156  int test1(int Base::* p2m, X* object)
157  {
158    return object->*p2m; // expected-error {{left hand operand to ->*}}
159  }
160}
161
162namespace 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
175  void m()
176  { (void)(Condition) &base::Continuous::cond; }
177}
178
179namespace 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 {
198      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 {
211      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 {
224      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.
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
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
275namespace PR9973 {
276  template<class R, class T> struct dm
277  {
278    typedef R T::*F;
279    F f_;
280    template<class U> int & call(U u)
281    { 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'}}
282
283    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
293  void f()
294  {
295    test* t;
296    mem_fn(&test::nullary_v)(t); // expected-note{{in instantiation of}}
297  }
298}
299
300namespace test8 {
301  struct A { int foo; };
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
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