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 {};
10class H : A {}; // expected-note 2{{implicitly declared private here}}
11
12int A::*pdi1;
13int (::A::*pdi2);
14int (A::*pfi)(int);
15void (*A::*ppfie)() throw(); // expected-error {{exception specifications are not allowed beyond a single level of indirection}}
16
17int 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}}
19int C::*pci; // expected-error {{'pci' does not point into a class}}
20void A::*pdv; // expected-error {{'pdv' declared as a member pointer to void}}
21int& A::*pdr; // expected-error {{'pdr' declared as a member pointer to a reference}}
22
23void 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
55struct TheBase
56{
57  void d();
58};
59
60struct HasMembers : TheBase
61{
62  int i;
63  void f();
64
65  void g();
66  void g(int);
67  static void g(double);
68};
69
70namespace Fake
71{
72  int i;
73  void f();
74}
75
76void 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
94struct Incomplete;
95
96void 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
136struct OverloadsPtrMem
137{
138  int operator ->*(const char *);
139};
140
141void i() {
142  OverloadsPtrMem m;
143  int foo = m->*"Awesome!";
144}
145
146namespace pr5985 {
147  struct c {
148    void h();
149    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
158namespace pr6783 {
159  struct Base {};
160  struct X; // expected-note {{forward declaration}}
161
162  int test1(int Base::* p2m, X* object)
163  {
164    return object->*p2m; // expected-error {{left hand operand to ->*}}
165  }
166}
167
168namespace 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
181  void m()
182  { (void)(Condition) &base::Continuous::cond; }
183}
184
185namespace 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 {
204      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 {
217      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 {
230      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.
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
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
281namespace PR9973 {
282  template<class R, class T> struct dm
283  {
284    typedef R T::*F;
285    F f_;
286    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
289    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
299  void f()
300  {
301    test* t;
302    mem_fn(&test::nullary_v)(t); // expected-note{{in instantiation of}}
303  }
304}
305
306namespace test8 {
307  struct A { int foo; };
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
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