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 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 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 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 135 void i() { 136 OverloadsPtrMem m; 137 int foo = m->*"Awesome!"; 138 } 139 140 namespace 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 152 namespace 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 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 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 { 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 275 namespace 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 300 namespace 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
