1 // RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify %s 2 // RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify -std=c++98 %s 3 // RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify -std=c++11 %s 4 5 int* f(int) { return 0; } 6 float* f(float) { return 0; } 7 void f(); 8 9 void test_f(int iv, float fv) { 10 float* fp = f(fv); 11 int* ip = f(iv); 12 } 13 14 int* g(int, float, int); // expected-note {{candidate function}} 15 float* g(int, int, int); // expected-note {{candidate function}} 16 double* g(int, float, float); // expected-note {{candidate function}} 17 char* g(int, float, ...); // expected-note {{candidate function}} 18 void g(); 19 20 void test_g(int iv, float fv) { 21 int* ip1 = g(iv, fv, 0); 22 float* fp1 = g(iv, iv, 0); 23 double* dp1 = g(iv, fv, fv); 24 char* cp1 = g(0, 0); 25 char* cp2 = g(0, 0, 0, iv, fv); 26 27 double* dp2 = g(0, fv, 1.5); // expected-error {{call to 'g' is ambiguous}} 28 } 29 30 double* h(double f); 31 int* h(int); 32 33 void test_h(float fv, unsigned char cv) { 34 double* dp = h(fv); 35 int* ip = h(cv); 36 } 37 38 int* i(int); 39 double* i(long); 40 41 void test_i(short sv, int iv, long lv, unsigned char ucv) { 42 int* ip1 = i(sv); 43 int* ip2 = i(iv); 44 int* ip3 = i(ucv); 45 double* dp1 = i(lv); 46 } 47 48 int* j(void*); 49 double* j(bool); 50 51 void test_j(int* ip) { 52 int* ip1 = j(ip); 53 } 54 55 int* k(char*); 56 double* k(bool); 57 58 void test_k() { 59 int* ip1 = k("foo"); 60 #if __cplusplus <= 199711L 61 // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}} 62 #else 63 // expected-error@-4 {{cannot initialize a variable of type 'int *' with an rvalue of type 'double *'}} 64 #endif 65 66 int* ip2 = k(("foo")); 67 #if __cplusplus <= 199711L 68 // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}} 69 #else 70 // expected-error@-4 {{cannot initialize a variable of type 'int *' with an rvalue of type 'double *'}} 71 #endif 72 double* dp1 = k(L"foo"); 73 } 74 75 int* l(wchar_t*); 76 double* l(bool); 77 78 void test_l() { 79 int* ip1 = l(L"foo"); 80 #if __cplusplus <= 199711L 81 // expected-warning@-2 {{conversion from string literal to 'wchar_t *' is deprecated}} 82 #else 83 // expected-error@-4 {{cannot initialize a variable of type 'int *' with an rvalue of type 'double *'}} 84 #endif 85 double* dp1 = l("foo"); 86 } 87 88 int* m(const char*); 89 double* m(char*); 90 91 void test_m() { 92 int* ip = m("foo"); 93 } 94 95 int* n(char*); 96 double* n(void*); 97 class E; 98 99 void test_n(E* e) { 100 char ca[7]; 101 int* ip1 = n(ca); 102 int* ip2 = n("foo"); 103 #if __cplusplus <= 199711L 104 // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}} 105 #else 106 // expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'char *'}} 107 #endif 108 float fa[7]; 109 double* dp1 = n(fa); 110 111 double* dp2 = n(e); 112 } 113 114 enum PromotesToInt { 115 PromotesToIntValue = -1 116 }; 117 118 enum PromotesToUnsignedInt { 119 PromotesToUnsignedIntValue = __INT_MAX__ * 2U 120 }; 121 122 int* o(int); 123 double* o(unsigned int); 124 float* o(long); 125 126 void test_o() { 127 int* ip1 = o(PromotesToIntValue); 128 double* dp1 = o(PromotesToUnsignedIntValue); 129 } 130 131 int* p(int); 132 double* p(double); 133 134 void test_p() { 135 int* ip = p((short)1); 136 double* dp = p(1.0f); 137 } 138 139 struct Bits { 140 signed short int_bitfield : 5; 141 unsigned int uint_bitfield : 8; 142 }; 143 144 int* bitfields(int, int); 145 float* bitfields(unsigned int, int); 146 147 void test_bitfield(Bits bits, int x) { 148 int* ip = bitfields(bits.int_bitfield, 0); 149 float* fp = bitfields(bits.uint_bitfield, 0u); 150 } 151 152 int* multiparm(long, int, long); // expected-note {{candidate function}} 153 float* multiparm(int, int, int); // expected-note {{candidate function}} 154 double* multiparm(int, int, short); // expected-note {{candidate function}} 155 156 void test_multiparm(long lv, short sv, int iv) { 157 int* ip1 = multiparm(lv, iv, lv); 158 int* ip2 = multiparm(lv, sv, lv); 159 float* fp1 = multiparm(iv, iv, iv); 160 float* fp2 = multiparm(sv, iv, iv); 161 double* dp1 = multiparm(sv, sv, sv); 162 double* dp2 = multiparm(iv, sv, sv); 163 multiparm(sv, sv, lv); // expected-error {{call to 'multiparm' is ambiguous}} 164 } 165 166 // Test overloading based on qualification vs. no qualification 167 // conversion. 168 int* quals1(int const * p); 169 char* quals1(int * p); 170 171 int* quals2(int const * const * pp); 172 char* quals2(int * * pp); 173 174 int* quals3(int const * * const * ppp); 175 char* quals3(int *** ppp); 176 177 void test_quals(int * p, int * * pp, int * * * ppp) { 178 char* q1 = quals1(p); 179 char* q2 = quals2(pp); 180 char* q3 = quals3(ppp); 181 } 182 183 // Test overloading based on qualification ranking (C++ 13.3.2)p3. 184 int* quals_rank1(int const * p); 185 float* quals_rank1(int const volatile *p); 186 char* quals_rank1(char*); 187 double* quals_rank1(const char*); 188 189 int* quals_rank2(int const * const * pp); 190 float* quals_rank2(int * const * pp); 191 192 void quals_rank3(int const * const * const volatile * p); // expected-note{{candidate function}} 193 void quals_rank3(int const * const volatile * const * p); // expected-note{{candidate function}} 194 195 void quals_rank3(int const *); // expected-note{{candidate function}} 196 void quals_rank3(int volatile *); // expected-note{{candidate function}} 197 198 void test_quals_ranking(int * p, int volatile *pq, int * * pp, int * * * ppp) { 199 int* q1 = quals_rank1(p); 200 float* q2 = quals_rank1(pq); 201 double* q3 = quals_rank1("string literal"); 202 char a[17]; 203 const char* ap = a; 204 char* q4 = quals_rank1(a); 205 double* q5 = quals_rank1(ap); 206 207 float* q6 = quals_rank2(pp); 208 209 quals_rank3(ppp); // expected-error {{call to 'quals_rank3' is ambiguous}} 210 211 quals_rank3(p); // expected-error {{call to 'quals_rank3' is ambiguous}} 212 quals_rank3(pq); 213 } 214 215 // Test overloading based on derived-to-base conversions 216 class A { }; 217 class B : public A { }; 218 class C : public B { }; 219 class D : public C { }; 220 221 int* derived1(A*); 222 char* derived1(const A*); 223 float* derived1(void*); 224 225 int* derived2(A*); 226 float* derived2(B*); 227 228 int* derived3(A*); 229 float* derived3(const B*); 230 char* derived3(C*); 231 232 void test_derived(B* b, B const* bc, C* c, const C* cc, void* v, D* d) { 233 int* d1 = derived1(b); 234 char* d2 = derived1(bc); 235 int* d3 = derived1(c); 236 char* d4 = derived1(cc); 237 float* d5 = derived1(v); 238 239 float* d6 = derived2(b); 240 float* d7 = derived2(c); 241 242 char* d8 = derived3(d); 243 } 244 245 void derived4(C*); // expected-note{{candidate function not viable: cannot convert from base class pointer 'A *' to derived class pointer 'C *' for 1st argument}} 246 247 void test_base(A* a) { 248 derived4(a); // expected-error{{no matching function for call to 'derived4}} 249 } 250 251 // Test overloading of references. 252 // (FIXME: tests binding to determine candidate sets, not overload 253 // resolution per se). 254 int* intref(int&); 255 float* intref(const int&); 256 257 void intref_test() { 258 float* ir1 = intref(5); 259 float* ir2 = intref(5.5); // expected-warning{{implicit conversion from 'double' to 'int' changes value from 5.5 to 5}} 260 } 261 262 void derived5(C&); // expected-note{{candidate function not viable: cannot bind base class object of type 'A' to derived class reference 'C &' for 1st argument}} 263 264 void test_base(A& a) { 265 derived5(a); // expected-error{{no matching function for call to 'derived5}} 266 } 267 268 // Test reference binding vs. standard conversions. 269 int& bind_vs_conv(const double&); 270 float& bind_vs_conv(int); 271 272 void bind_vs_conv_test() 273 { 274 int& i1 = bind_vs_conv(1.0f); 275 float& f1 = bind_vs_conv((short)1); 276 } 277 278 // Test that cv-qualifiers get subsumed in the reference binding. 279 struct X { }; 280 struct Y { }; 281 struct Z : X, Y { }; 282 283 int& cvqual_subsume(X&); // expected-note{{candidate function}} 284 float& cvqual_subsume(const Y&); // expected-note{{candidate function}} 285 286 int& cvqual_subsume2(X&); // expected-note{{candidate function}} 287 float& cvqual_subsume2(volatile Y&); // expected-note{{candidate function}} 288 289 void cvqual_subsume_test(Z z) { 290 cvqual_subsume(z); // expected-error{{call to 'cvqual_subsume' is ambiguous}} 291 cvqual_subsume2(z); // expected-error{{call to 'cvqual_subsume2' is ambiguous}} 292 } 293 294 // Test overloading with cv-qualification differences in reference 295 // binding. 296 int& cvqual_diff(X&); 297 float& cvqual_diff(const X&); 298 299 void cvqual_diff_test(X x, Z z) { 300 int& i1 = cvqual_diff(x); 301 int& i2 = cvqual_diff(z); 302 } 303 304 // Test overloading with derived-to-base differences in reference 305 // binding. 306 struct Z2 : Z { }; 307 308 int& db_rebind(X&); 309 long& db_rebind(Y&); 310 float& db_rebind(Z&); 311 312 void db_rebind_test(Z2 z2) { 313 float& f1 = db_rebind(z2); 314 } 315 316 class string { }; 317 class opt : public string { }; 318 319 struct SR { 320 SR(const string&); 321 }; 322 323 void f(SR) { } 324 325 void g(opt o) { 326 f(o); 327 } 328 329 330 namespace PR5756 { 331 int &a(void*, int); 332 float &a(void*, float); 333 void b() { 334 int &ir = a(0,0); 335 (void)ir; 336 } 337 } 338 339 // Tests the exact text used to note the candidates 340 namespace test1 { 341 template <class T> void foo(T t, unsigned N); // expected-note {{candidate function [with T = int] not viable: no known conversion from 'const char [6]' to 'unsigned int' for 2nd argument}} 342 void foo(int n, char N); // expected-note {{candidate function not viable: no known conversion from 'const char [6]' to 'char' for 2nd argument}} 343 void foo(int n, const char *s, int t); // expected-note {{candidate function not viable: requires 3 arguments, but 2 were provided}} 344 void foo(int n, const char *s, int t, ...); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}} 345 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}} 346 347 // PR 11857 348 void foo(int n); // expected-note {{candidate function not viable: requires single argument 'n', but 2 arguments were provided}} 349 void foo(unsigned n = 10); // expected-note {{candidate function not viable: allows at most single argument 'n', but 2 arguments were provided}} 350 void bar(int n, int u = 0); // expected-note {{candidate function not viable: requires at least argument 'n', but no arguments were provided}} 351 void baz(int n = 0, int u = 0); // expected-note {{candidate function not viable: requires at most 2 arguments, but 3 were provided}} 352 353 void test() { 354 foo(4, "hello"); //expected-error {{no matching function for call to 'foo'}} 355 bar(); //expected-error {{no matching function for call to 'bar'}} 356 baz(3, 4, 5); // expected-error {{no matching function for call to 'baz'}} 357 } 358 } 359 360 // PR 6014 361 namespace test2 { 362 struct QFixed { 363 QFixed(int i); 364 QFixed(long i); 365 }; 366 367 bool operator==(const QFixed &f, int i); 368 369 class qrgb666 { 370 inline operator unsigned int () const; 371 372 inline bool operator==(const qrgb666 &v) const; 373 inline bool operator!=(const qrgb666 &v) const { return !(*this == v); } 374 }; 375 } 376 377 // PR 6117 378 namespace IncompleteConversion { 379 struct Complete {}; 380 struct Incomplete; 381 382 void completeFunction(Complete *); // expected-note 2 {{cannot convert argument of incomplete type}} 383 void completeFunction(Complete &); // expected-note 2 {{cannot convert argument of incomplete type}} 384 385 void testTypeConversion(Incomplete *P) { 386 completeFunction(P); // expected-error {{no matching function for call to 'completeFunction'}} 387 completeFunction(*P); // expected-error {{no matching function for call to 'completeFunction'}} 388 } 389 390 void incompletePointerFunction(Incomplete *); // expected-note {{candidate function not viable: cannot convert argument of incomplete type 'IncompleteConversion::Incomplete' to 'IncompleteConversion::Incomplete *' for 1st argument; take the address of the argument with &}} 391 void incompleteReferenceFunction(Incomplete &); // expected-note {{candidate function not viable: cannot convert argument of incomplete type 'IncompleteConversion::Incomplete *' to 'IncompleteConversion::Incomplete &' for 1st argument; dereference the argument with *}} 392 393 void testPointerReferenceConversion(Incomplete &reference, Incomplete *pointer) { 394 incompletePointerFunction(reference); // expected-error {{no matching function for call to 'incompletePointerFunction'}} 395 incompleteReferenceFunction(pointer); // expected-error {{no matching function for call to 'incompleteReferenceFunction'}} 396 } 397 } 398 399 namespace DerivedToBaseVsVoid { 400 struct A { }; 401 struct B : A { }; 402 403 float &f(void *); 404 int &f(const A*); 405 406 void g(B *b) { 407 int &ir = f(b); 408 } 409 } 410 411 // PR 6398 + PR 6421 412 namespace test4 { 413 class A; 414 class B { 415 static void foo(); // expected-note {{not viable}} 416 static void foo(int*); // expected-note {{not viable}} 417 static void foo(long*); // expected-note {{not viable}} 418 419 void bar(A *a) { 420 foo(a); // expected-error {{no matching function for call}} 421 } 422 }; 423 } 424 425 namespace DerivedToBase { 426 struct A { }; 427 struct B : A { }; 428 struct C : B { }; 429 430 int &f0(const A&); 431 float &f0(B); 432 433 void g() { 434 float &fr = f0(C()); 435 } 436 } 437 438 namespace PR6483 { 439 struct X0 { 440 operator const unsigned int & () const; 441 }; 442 443 struct X1 { 444 operator unsigned int & () const; 445 }; 446 447 void f0(const bool &); 448 void f1(bool &); // expected-note 2{{not viable}} 449 450 void g(X0 x0, X1 x1) { 451 f0(x0); 452 f1(x0); // expected-error{{no matching function for call}} 453 f0(x1); 454 f1(x1); // expected-error{{no matching function for call}} 455 } 456 } 457 458 namespace PR6078 { 459 struct A { 460 A(short); // expected-note{{candidate constructor}} 461 A(long); // expected-note{{candidate constructor}} 462 }; 463 struct S { 464 typedef void ft(A); 465 operator ft*(); 466 }; 467 468 void f() { 469 S()(0); // expected-error{{conversion from 'int' to 'PR6078::A' is ambiguous}} 470 } 471 } 472 473 namespace PR6177 { 474 struct String { String(char const*); }; 475 476 void f(bool const volatile&); 477 int &f(String); 478 479 void g() { int &r = f(""); } 480 } 481 482 namespace PR7095 { 483 struct X { }; 484 485 struct Y { 486 operator const X*(); 487 488 private: 489 operator X*(); 490 }; 491 492 void f(const X *); 493 void g(Y y) { f(y); } 494 } 495 496 namespace PR7224 { 497 class A {}; 498 class B : public A {}; 499 500 int &foo(A *const d); 501 float &foo(const A *const d); 502 503 void bar() 504 { 505 B *const d = 0; 506 B const *const d2 = 0; 507 int &ir = foo(d); 508 float &fr = foo(d2); 509 } 510 } 511 512 namespace NontrivialSubsequence { 513 struct X0; 514 515 class A { 516 operator X0 *(); 517 public: 518 operator const X0 *(); 519 }; 520 521 A a; 522 void foo( void const * ); 523 524 void g() { 525 foo(a); 526 } 527 } 528 529 // rdar://rdar8499524 530 namespace rdar8499524 { 531 struct W {}; 532 struct S { 533 S(...); 534 }; 535 536 void g(const S&); 537 void f() { 538 g(W()); 539 } 540 } 541 542 namespace rdar9173984 { 543 template <typename T, unsigned long N> int &f(const T (&)[N]); 544 template <typename T> float &f(const T *); 545 546 void test() { 547 int arr[2] = {0, 0}; 548 int *arrp = arr; 549 int &ir = f(arr); 550 float &fr = f(arrp); 551 } 552 } 553 554 namespace PR9507 { 555 void f(int * const&); // expected-note{{candidate function}} 556 void f(int const(&)[1]); // expected-note{{candidate function}} 557 558 int main() { 559 int n[1]; 560 f(n); // expected-error{{call to 'f' is ambiguous}} 561 } 562 } 563 564 namespace rdar9803316 { 565 void foo(float); 566 int &foo(int); 567 568 void bar() { 569 int &ir = (&foo)(0); 570 } 571 } 572 573 namespace IncompleteArg { 574 // Ensure that overload resolution attempts to complete argument types when 575 // performing ADL. 576 template<typename T> struct S { 577 friend int f(const S&); 578 }; 579 extern S<int> s; 580 int k = f(s); 581 582 template<typename T> struct Op { 583 friend bool operator==(const Op &, const Op &); 584 }; 585 extern Op<char> op; 586 bool b = op == op; 587 588 // ... and not in other cases! Nothing here requires U<int()> to be complete. 589 // (Note that instantiating U<int()> will fail.) 590 template<typename T> struct U { 591 T t; 592 }; 593 struct Consumer { 594 template<typename T> 595 int operator()(const U<T> &); 596 }; 597 template<typename T> U<T> &make(); 598 Consumer c; 599 int n = sizeof(c(make<int()>())); 600 } 601 602 namespace PR12142 { 603 void fun(int (*x)[10]); // expected-note{{candidate function not viable: 1st argument ('const int (*)[10]') would lose const qualifier}} 604 void g() { fun((const int(*)[10])0); } // expected-error{{no matching function for call to 'fun'}} 605 } 606 607 // DR1152: Take 'volatile' into account when handling reference bindings in 608 // overload resolution. 609 namespace PR12931 { 610 void f(const int &, ...); 611 void f(const volatile int &, int); 612 void g() { f(0, 0); } 613 } 614 615 void test5() { 616 struct { 617 typedef void F1(int); 618 typedef void F2(double); 619 operator F1*(); // expected-note{{conversion candidate}} 620 operator F2*(); // expected-note{{conversion candidate}} 621 } callable; 622 callable(); // expected-error{{no matching function for call}} 623 } 624 625 namespace PR20218 { 626 void f(void (*const &)()); // expected-note 2{{candidate}} 627 void f(void (&&)()) = delete; // expected-note 2{{candidate}} 628 #if __cplusplus <= 199711L 629 // expected-warning@-2 {{rvalue references are a C++11 extension}} 630 // expected-warning@-3 {{deleted function definitions are a C++11 extension}} 631 #endif 632 void g(void (&&)()) = delete; // expected-note 2{{candidate}} 633 #if __cplusplus <= 199711L 634 // expected-warning@-2 {{rvalue references are a C++11 extension}} 635 // expected-warning@-3 {{deleted function definitions are a C++11 extension}} 636 #endif 637 void g(void (*const &)()); // expected-note 2{{candidate}} 638 639 void x(); 640 typedef void (&fr)(); 641 struct Y { operator fr(); } y; 642 643 void h() { 644 f(x); // expected-error {{ambiguous}} 645 g(x); // expected-error {{ambiguous}} 646 f(y); // expected-error {{ambiguous}} 647 g(y); // expected-error {{ambiguous}} 648 } 649 } 650
