690 lines · cpp
1// RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify %s2// RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify -std=c++98 %s3// RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify -std=c++11 %s4 5int* f(int) { return 0; }6float* f(float) { return 0; }7void f();8 9void test_f(int iv, float fv) {10 float* fp = f(fv);11 int* ip = f(iv);12}13 14int* g(int, float, int); // expected-note {{candidate function}}15float* g(int, int, int);16double* g(int, float, float); // expected-note {{candidate function}}17char* g(int, float, ...);18void g();19 20void 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 30double* h(double f);31int* h(int);32 33void test_h(float fv, unsigned char cv) {34 double* dp = h(fv);35 int* ip = h(cv);36}37 38int* i(int);39double* i(long);40 41void 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 48int* j(void*);49double* j(bool);50 51void test_j(int* ip) {52 int* ip1 = j(ip);53}54 55int* k(char*);56double* k(bool);57 58void test_k() {59 int* ip1 = k("foo");60#if __cplusplus <= 199711L61 // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}62#else63 // expected-error@-4 {{cannot initialize a variable of type 'int *' with an rvalue of type 'double *'}}64#endif65 66 int* ip2 = k(("foo"));67#if __cplusplus <= 199711L68 // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}69#else70 // expected-error@-4 {{cannot initialize a variable of type 'int *' with an rvalue of type 'double *'}}71#endif72 double* dp1 = k(L"foo");73}74 75int* l(wchar_t*);76double* l(bool);77 78void test_l() {79 int* ip1 = l(L"foo");80#if __cplusplus <= 199711L81 // expected-warning@-2 {{conversion from string literal to 'wchar_t *' is deprecated}}82#else83 // expected-error@-4 {{cannot initialize a variable of type 'int *' with an rvalue of type 'double *'}}84#endif85 double* dp1 = l("foo");86}87 88int* m(const char*);89double* m(char*);90 91void test_m() {92 int* ip = m("foo");93}94 95int* n(char*);96double* n(void*);97class E;98 99void test_n(E* e) {100 char ca[7];101 int* ip1 = n(ca);102 int* ip2 = n("foo");103#if __cplusplus <= 199711L104 // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}105#else106 // expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'char *'}}107#endif108 float fa[7];109 double* dp1 = n(fa);110 111 double* dp2 = n(e);112}113 114enum PromotesToInt {115 PromotesToIntValue = -1116};117 118enum PromotesToUnsignedInt {119 PromotesToUnsignedIntValue = __INT_MAX__ * 2U120};121 122int* o(int);123double* o(unsigned int);124float* o(long);125 126void test_o() {127 int* ip1 = o(PromotesToIntValue);128 double* dp1 = o(PromotesToUnsignedIntValue);129}130 131int* p(int);132double* p(double);133 134void test_p() {135 int* ip = p((short)1);136 double* dp = p(1.0f);137}138 139struct Bits {140 signed short int_bitfield : 5;141 unsigned int uint_bitfield : 8;142};143 144int* bitfields(int, int);145float* bitfields(unsigned int, int);146 147void test_bitfield(Bits bits, int x) {148 int* ip = bitfields(bits.int_bitfield, 0);149 float* fp = bitfields(bits.uint_bitfield, 0u);150}151 152int* multiparm(long, int, long); // expected-note {{candidate function}}153float* multiparm(int, int, int); // expected-note {{candidate function}}154double* multiparm(int, int, short); // expected-note {{candidate function}}155 156void 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 qualification167// conversion.168int* quals1(int const * p);169char* quals1(int * p);170 171int* quals2(int const * const * pp);172char* quals2(int * * pp);173 174int* quals3(int const * * const * ppp);175char* quals3(int *** ppp);176 177void 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.184int* quals_rank1(int const * p);185float* quals_rank1(int const volatile *p);186char* quals_rank1(char*);187double* quals_rank1(const char*);188 189int* quals_rank2(int const * const * pp);190float* quals_rank2(int * const * pp);191 192void quals_rank3(int const * const * const volatile * p); // expected-note{{candidate function}}193void quals_rank3(int const * const volatile * const * p); // expected-note{{candidate function}}194 195void quals_rank3(int const *); // expected-note{{candidate function}}196void quals_rank3(int volatile *); // expected-note{{candidate function}}197 198void 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 conversions216class A { };217class B : public A { };218class C : public B { };219class D : public C { };220 221int* derived1(A*);222char* derived1(const A*);223float* derived1(void*);224 225int* derived2(A*);226float* derived2(B*);227 228int* derived3(A*);229float* derived3(const B*);230char* derived3(C*);231 232void 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 245void derived4(C*); // expected-note{{candidate function not viable: cannot convert from base class pointer 'A *' to derived class pointer 'C *' for 1st argument}}246 247void 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).254int* intref(int&);255float* intref(const int&);256 257void 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 262void 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 264void 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.269int& bind_vs_conv(const double&);270float& bind_vs_conv(int);271 272void 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.279struct X { };280struct Y { };281struct Z : X, Y { };282 283int& cvqual_subsume(X&); // expected-note{{candidate function}}284float& cvqual_subsume(const Y&); // expected-note{{candidate function}}285 286int& cvqual_subsume2(X&); // expected-note{{candidate function}}287float& cvqual_subsume2(volatile Y&); // expected-note{{candidate function}}288 289void 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 reference295// binding.296int& cvqual_diff(X&);297float& cvqual_diff(const X&);298 299void 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 reference305// binding.306struct Z2 : Z { };307 308int& db_rebind(X&);309long& db_rebind(Y&);310float& db_rebind(Z&);311 312void db_rebind_test(Z2 z2) {313 float& f1 = db_rebind(z2);314}315 316class string { };317class opt : public string { };318 319struct SR {320 SR(const string&);321};322 323void f(SR) { }324 325void g(opt o) {326 f(o);327}328 329 330namespace 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 candidates340namespace test1 {341template <class T>342void foo(T t, unsigned N); // expected-note {{candidate function template not viable: no known conversion from 'const char[6]' to 'unsigned int' for 2nd argument}}343void foo(int n, char N); // expected-note {{candidate function not viable: no known conversion from 'const char[6]' to 'char' for 2nd argument}}344void foo(int n, const char *s, int t); // expected-note {{candidate function not viable: requires 3 arguments, but 2 were provided}}345void foo(int n, const char *s, int t, ...); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}}346void 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}}347 348// PR 11857349void foo(int n); // expected-note {{candidate function not viable: requires single argument 'n', but 2 arguments were provided}}350void foo(unsigned n = 10); // expected-note {{candidate function not viable: allows at most single argument 'n', but 2 arguments were provided}}351void bar(int n, int u = 0); // expected-note {{candidate function not viable: requires at least argument 'n', but no arguments were provided}}352void baz(int n = 0, int u = 0); // expected-note {{candidate function not viable: requires at most 2 arguments, but 3 were provided}}353 354void test() {355 foo(4, "hello"); //expected-error {{no matching function for call to 'foo'}}356 bar(); //expected-error {{no matching function for call to 'bar'}}357 baz(3, 4, 5); // expected-error {{no matching function for call to 'baz'}}358 }359}360 361// PR 6014362namespace test2 {363 struct QFixed {364 QFixed(int i);365 QFixed(long i);366 };367 368 bool operator==(const QFixed &f, int i);369 370 class qrgb666 {371 inline operator unsigned int () const;372 373 inline bool operator==(const qrgb666 &v) const;374 inline bool operator!=(const qrgb666 &v) const { return !(*this == v); }375 };376}377 378// PR 6117379namespace IncompleteConversion {380 struct Complete {};381 struct Incomplete;382 383 void completeFunction(Complete *); // expected-note 2 {{cannot convert argument of incomplete type}}384 void completeFunction(Complete &); // expected-note 2 {{cannot convert argument of incomplete type}}385 386 void testTypeConversion(Incomplete *P) {387 completeFunction(P); // expected-error {{no matching function for call to 'completeFunction'}}388 completeFunction(*P); // expected-error {{no matching function for call to 'completeFunction'}}389 }390 391 void incompletePointerFunction(Incomplete *); // expected-note {{candidate function not viable: cannot convert argument of incomplete type 'Incomplete' to 'Incomplete *' for 1st argument; take the address of the argument with &}}392 void incompleteReferenceFunction(Incomplete &); // expected-note {{candidate function not viable: cannot convert argument of incomplete type 'Incomplete *' to 'Incomplete &' for 1st argument; dereference the argument with *}}393 394 void testPointerReferenceConversion(Incomplete &reference, Incomplete *pointer) {395 incompletePointerFunction(reference); // expected-error {{no matching function for call to 'incompletePointerFunction'}}396 incompleteReferenceFunction(pointer); // expected-error {{no matching function for call to 'incompleteReferenceFunction'}}397 }398}399 400namespace DerivedToBaseVsVoid {401 struct A { };402 struct B : A { };403 404 float &f(void *);405 int &f(const A*);406 407 void g(B *b) {408 int &ir = f(b);409 }410}411 412// PR 6398 + PR 6421413namespace test4 {414 class A;415 class B {416 static void foo(); // expected-note {{not viable}}417 static void foo(int*); // expected-note {{not viable}}418 static void foo(long*); // expected-note {{not viable}}419 420 void bar(A *a) { 421 foo(a); // expected-error {{no matching function for call}}422 }423 };424}425 426namespace DerivedToBase {427 struct A { };428 struct B : A { };429 struct C : B { };430 431 int &f0(const A&);432 float &f0(B);433 434 void g() {435 float &fr = f0(C());436 }437}438 439namespace PR6483 {440 struct X0 {441 operator const unsigned int & () const;442 };443 444 struct X1 {445 operator unsigned int & () const;446 };447 448 void f0(const bool &);449 void f1(bool &); // expected-note 2{{not viable}}450 451 void g(X0 x0, X1 x1) {452 f0(x0);453 f1(x0); // expected-error{{no matching function for call}}454 f0(x1);455 f1(x1); // expected-error{{no matching function for call}}456 } 457}458 459namespace PR6078 {460 struct A {461 A(short); // expected-note{{candidate constructor}}462 A(long); // expected-note{{candidate constructor}}463 };464 struct S {465 typedef void ft(A);466 operator ft*();467 };468 469 void f() {470 S()(0); // expected-error{{conversion from 'int' to 'A' is ambiguous}}471 }472}473 474namespace PR6177 {475 struct String { String(char const*); };476 477 void f(bool const volatile&);478 int &f(String);479 480 void g() { int &r = f(""); }481}482 483namespace PR7095 {484 struct X { };485 486 struct Y {487 operator const X*();488 489 private:490 operator X*();491 };492 493 void f(const X *);494 void g(Y y) { f(y); }495}496 497namespace PR7224 {498 class A {};499 class B : public A {};500 501 int &foo(A *const d);502 float &foo(const A *const d);503 504 void bar()505 {506 B *const d = 0;507 B const *const d2 = 0;508 int &ir = foo(d);509 float &fr = foo(d2);510 }511}512 513namespace NontrivialSubsequence {514 struct X0;515 516 class A {517 operator X0 *();518 public:519 operator const X0 *();520 };521 522 A a;523 void foo( void const * );524 525 void g() {526 foo(a);527 }528}529 530namespace 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 542namespace 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 554namespace 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 564namespace rdar9803316 {565 void foo(float);566 int &foo(int);567 568 void bar() {569 int &ir = (&foo)(0);570 }571}572 573namespace IncompleteArg {574 // Ensure that overload resolution attempts to complete argument types when575 // 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 602namespace 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 in608// overload resolution.609namespace PR12931 {610 void f(const int &, ...);611 void f(const volatile int &, int);612 void g() { f(0, 0); }613}614 615void 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 625namespace PR20218 {626 void f(void (*const &)()); // expected-note 2{{candidate}}627 void f(void (&&)()) = delete; // expected-note 2{{candidate}}628#if __cplusplus <= 199711L629 // expected-warning@-2 {{rvalue references are a C++11 extension}}630 // expected-warning@-3 {{deleted function definitions are a C++11 extension}}631#endif632 void g(void (&&)()) = delete; // expected-note 2{{candidate}}633#if __cplusplus <= 199711L634 // expected-warning@-2 {{rvalue references are a C++11 extension}}635 // expected-warning@-3 {{deleted function definitions are a C++11 extension}}636#endif637 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 651namespace StringLiteralToCharAmbiguity {652 void f(char *, int);653 void f(const char *, unsigned);654 void g() { f("foo", 0); }655#if __cplusplus <= 199711L656 // expected-error@-2 {{call to 'f' is ambiguous}}657 // expected-note@-5 {{candidate function}}658 // expected-note@-5 {{candidate function}}659#endif660}661 662namespace ProduceNotesAfterSFINAEFailure {663 struct A {664 template<typename T, typename U = typename T::x> A(T); // expected-warning 0-1{{extension}}665 };666 void f(void*, A); // expected-note {{candidate function not viable}}667 void g() { f(1, 2); } // expected-error {{no matching function}}668}669 670namespace PR19808 {671 struct B {672 int i;673 void bar();674 };675 struct D : public B{};676 677 void f(bool);678 void f(int D::*);679 void f(void (D::*)());680 681 void Usage() {682 int B::*pmem;683 void (B::*pmf)();684 685 // These should not be ambiguous.686 f(pmem);687 f(pmf);688 }689}690