overload-call.cpp revision a9bff30776888977f580c9cac212fd1583ee963e
1// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s 2int* f(int) { return 0; } 3float* f(float) { return 0; } 4void f(); 5 6void test_f(int iv, float fv) { 7 float* fp = f(fv); 8 int* ip = f(iv); 9} 10 11int* g(int, float, int); // expected-note {{ candidate function }} 12float* g(int, int, int); // expected-note {{ candidate function }} 13double* g(int, float, float); // expected-note {{ candidate function }} 14char* g(int, float, ...); // expected-note {{ candidate function }} 15void g(); 16 17void test_g(int iv, float fv) { 18 int* ip1 = g(iv, fv, 0); 19 float* fp1 = g(iv, iv, 0); 20 double* dp1 = g(iv, fv, fv); 21 char* cp1 = g(0, 0); 22 char* cp2 = g(0, 0, 0, iv, fv); 23 24 double* dp2 = g(0, fv, 1.5); // expected-error {{ call to 'g' is ambiguous; candidates are: }} 25} 26 27double* h(double f); 28int* h(int); 29 30void test_h(float fv, unsigned char cv) { 31 double* dp = h(fv); 32 int* ip = h(cv); 33} 34 35int* i(int); 36double* i(long); 37 38void test_i(short sv, int iv, long lv, unsigned char ucv) { 39 int* ip1 = i(sv); 40 int* ip2 = i(iv); 41 int* ip3 = i(ucv); 42 double* dp1 = i(lv); 43} 44 45int* j(void*); 46double* j(bool); 47 48void test_j(int* ip) { 49 int* ip1 = j(ip); 50} 51 52int* k(char*); 53double* k(bool); 54 55void test_k() { 56 int* ip1 = k("foo"); // expected-warning{{conversion from string literal to 'char *' is deprecated}} 57 double* dp1 = k(L"foo"); 58} 59 60int* l(wchar_t*); 61double* l(bool); 62 63void test_l() { 64 int* ip1 = l(L"foo"); // expected-warning{{conversion from string literal to 'wchar_t *' is deprecated}} 65 double* dp1 = l("foo"); 66} 67 68int* m(const char*); 69double* m(char*); 70 71void test_m() { 72 int* ip = m("foo"); 73} 74 75int* n(char*); 76double* n(void*); 77class E; 78 79void test_n(E* e) { 80 char ca[7]; 81 int* ip1 = n(ca); 82 int* ip2 = n("foo"); // expected-warning{{conversion from string literal to 'char *' is deprecated}} 83 84 float fa[7]; 85 double* dp1 = n(fa); 86 87 double* dp2 = n(e); 88} 89 90enum PromotesToInt { 91 PromotesToIntValue = -1 92}; 93 94enum PromotesToUnsignedInt { 95 PromotesToUnsignedIntValue = __INT_MAX__ * 2U 96}; 97 98int* o(int); 99double* o(unsigned int); 100float* o(long); 101 102void test_o() { 103 int* ip1 = o(PromotesToIntValue); 104 double* dp1 = o(PromotesToUnsignedIntValue); 105} 106 107int* p(int); 108double* p(double); 109 110void test_p() { 111 int* ip = p((short)1); 112 double* dp = p(1.0f); 113} 114 115struct Bits { 116 signed short int_bitfield : 5; 117 unsigned int uint_bitfield : 8; 118}; 119 120int* bitfields(int, int); 121float* bitfields(unsigned int, int); 122 123void test_bitfield(Bits bits, int x) { 124 int* ip = bitfields(bits.int_bitfield, 0); 125 float* fp = bitfields(bits.uint_bitfield, 0u); 126} 127 128int* multiparm(long, int, long); // expected-note {{ candidate function }} 129float* multiparm(int, int, int); // expected-note {{ candidate function }} 130double* multiparm(int, int, short); // expected-note {{ candidate function }} 131 132void test_multiparm(long lv, short sv, int iv) { 133 int* ip1 = multiparm(lv, iv, lv); 134 int* ip2 = multiparm(lv, sv, lv); 135 float* fp1 = multiparm(iv, iv, iv); 136 float* fp2 = multiparm(sv, iv, iv); 137 double* dp1 = multiparm(sv, sv, sv); 138 double* dp2 = multiparm(iv, sv, sv); 139 multiparm(sv, sv, lv); // expected-error {{ call to 'multiparm' is ambiguous; candidates are: }} 140} 141 142// Test overloading based on qualification vs. no qualification 143// conversion. 144int* quals1(int const * p); 145char* quals1(int * p); 146 147int* quals2(int const * const * pp); 148char* quals2(int * * pp); 149 150int* quals3(int const * * const * ppp); 151char* quals3(int *** ppp); 152 153void test_quals(int * p, int * * pp, int * * * ppp) { 154 char* q1 = quals1(p); 155 char* q2 = quals2(pp); 156 char* q3 = quals3(ppp); 157} 158 159// Test overloading based on qualification ranking (C++ 13.3.2)p3. 160int* quals_rank1(int const * p); 161float* quals_rank1(int const volatile *p); 162char* quals_rank1(char*); 163double* quals_rank1(const char*); 164 165int* quals_rank2(int const * const * pp); 166float* quals_rank2(int * const * pp); 167 168void quals_rank3(int const * const * const volatile * p); // expected-note{{candidate function}} 169void quals_rank3(int const * const volatile * const * p); // expected-note{{candidate function}} 170 171void quals_rank3(int const *); // expected-note{{candidate function}} 172void quals_rank3(int volatile *); // expected-note{{candidate function}} 173 174void test_quals_ranking(int * p, int volatile *pq, int * * pp, int * * * ppp) { 175 int* q1 = quals_rank1(p); 176 float* q2 = quals_rank1(pq); 177 double* q3 = quals_rank1("string literal"); 178 char a[17]; 179 const char* ap = a; 180 char* q4 = quals_rank1(a); 181 double* q5 = quals_rank1(ap); 182 183 float* q6 = quals_rank2(pp); 184 185 quals_rank3(ppp); // expected-error {{call to 'quals_rank3' is ambiguous; candidates are:}} 186 187 quals_rank3(p); // expected-error {{call to 'quals_rank3' is ambiguous; candidates are:}} 188 quals_rank3(pq); 189} 190 191// Test overloading based on derived-to-base conversions 192class A { }; 193class B : public A { }; 194class C : public B { }; 195class D : public C { }; 196 197int* derived1(A*); 198char* derived1(const A*); 199float* derived1(void*); 200 201int* derived2(A*); 202float* derived2(B*); 203 204int* derived3(A*); 205float* derived3(const B*); 206char* derived3(C*); 207 208void test_derived(B* b, B const* bc, C* c, const C* cc, void* v, D* d) { 209 int* d1 = derived1(b); 210 char* d2 = derived1(bc); 211 int* d3 = derived1(c); 212 char* d4 = derived1(cc); 213 float* d5 = derived1(v); 214 215 float* d6 = derived2(b); 216 float* d7 = derived2(c); 217 218 char* d8 = derived3(d); 219} 220 221// Test overloading of references. 222// (FIXME: tests binding to determine candidate sets, not overload 223// resolution per se). 224int* intref(int&); 225float* intref(const int&); 226 227void intref_test() { 228 float* ir1 = intref(5); 229 float* ir2 = intref(5.5); 230} 231 232// Test reference binding vs. standard conversions. 233int& bind_vs_conv(const double&); 234float& bind_vs_conv(int); 235 236void bind_vs_conv_test() 237{ 238 int& i1 = bind_vs_conv(1.0f); 239 float& f1 = bind_vs_conv((short)1); 240} 241 242// Test that cv-qualifiers get subsumed in the reference binding. 243struct X { }; 244struct Y { }; 245struct Z : X, Y { }; 246 247int& cvqual_subsume(X&); // expected-note{{candidate function}} 248float& cvqual_subsume(const Y&); // expected-note{{candidate function}} 249 250int& cvqual_subsume2(const X&); 251float& cvqual_subsume2(const volatile Y&); 252 253Z get_Z(); 254 255void cvqual_subsume_test(Z z) { 256 cvqual_subsume(z); // expected-error{{call to 'cvqual_subsume' is ambiguous; candidates are:}} 257 int& x = cvqual_subsume2(get_Z()); // okay: only binds to the first one 258} 259 260// Test overloading with cv-qualification differences in reference 261// binding. 262int& cvqual_diff(X&); 263float& cvqual_diff(const X&); 264 265void cvqual_diff_test(X x, Z z) { 266 int& i1 = cvqual_diff(x); 267 int& i2 = cvqual_diff(z); 268} 269 270// Test overloading with derived-to-base differences in reference 271// binding. 272struct Z2 : Z { }; 273 274int& db_rebind(X&); 275long& db_rebind(Y&); 276float& db_rebind(Z&); 277 278void db_rebind_test(Z2 z2) { 279 float& f1 = db_rebind(z2); 280} 281 282class string { }; 283class opt : public string { }; 284 285struct SR { 286 SR(const string&); 287}; 288 289void f(SR) { } 290 291void g(opt o) { 292 f(o); 293} 294 295 296namespace PR5756 { 297 int &a(void*, int); 298 float &a(void*, float); 299 void b() { 300 int &ir = a(0,0); 301 (void)ir; 302 } 303} 304 305// Tests the exact text used to note the candidates 306namespace test1 { 307 template <class T> void foo(T t, unsigned N); // expected-note {{candidate function [with T = int] not viable: no known conversion from 'char const [6]' to 'unsigned int' for 2nd argument}} 308 void foo(int n, char N); // expected-note {{candidate function not viable: no known conversion from 'char const [6]' to 'char' for 2nd argument}} 309 void foo(int n); // expected-note {{candidate function not viable: requires 1 argument, but 2 were provided}} 310 void foo(unsigned n = 10); // expected-note {{candidate function not viable: requires at most 1 argument, but 2 were provided}} 311 void foo(int n, const char *s, int t); // expected-note {{candidate function not viable: requires 3 arguments, but 2 were provided}} 312 void foo(int n, const char *s, int t, ...); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}} 313 void foo(int n, const char *s, int t, int u = 0); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}} 314 315 void test() { 316 foo(4, "hello"); //expected-error {{no matching function for call to 'foo'}} 317 } 318} 319 320// PR 6014 321namespace test2 { 322 struct QFixed { 323 QFixed(int i); 324 QFixed(long i); 325 }; 326 327 bool operator==(const QFixed &f, int i); 328 329 class qrgb666 { 330 inline operator unsigned int () const; 331 332 inline bool operator==(const qrgb666 &v) const; 333 inline bool operator!=(const qrgb666 &v) const { return !(*this == v); } 334 }; 335} 336 337// PR 6117 338namespace test3 { 339 struct Base {}; 340 struct Incomplete; 341 342 void foo(Base *); // expected-note 2 {{cannot convert argument of incomplete type}} 343 void foo(Base &); // expected-note 2 {{cannot convert argument of incomplete type}} 344 345 void test(Incomplete *P) { 346 foo(P); // expected-error {{no matching function for call to 'foo'}} 347 foo(*P); // expected-error {{no matching function for call to 'foo'}} 348 } 349} 350 351namespace DerivedToBaseVsVoid { 352 struct A { }; 353 struct B : A { }; 354 355 float &f(void *); 356 int &f(const A*); 357 358 void g(B *b) { 359 int &ir = f(b); 360 } 361} 362 363// PR 6398 + PR 6421 364namespace test4 { 365 class A; 366 class B { 367 static void foo(); // expected-note {{not viable}} 368 static void foo(int*); // expected-note {{not viable}} 369 static void foo(long*); // expected-note {{not viable}} 370 371 void bar(A *a) { 372 foo(a); // expected-error {{no matching function for call}} 373 } 374 }; 375} 376 377namespace DerivedToBase { 378 struct A { }; 379 struct B : A { }; 380 struct C : B { }; 381 382 int &f0(const A&); 383 float &f0(B); 384 385 void g() { 386 float &fr = f0(C()); 387 } 388} 389