clang/test/SemaCXX/overload-call.cpp

   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);
  16 double* g(int, float, float); // expected-note {{candidate function}}
  17 char* g(int, float, ...);
  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>
 342 void 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}}
 343 void foo(int n, char N);                          // expected-note {{candidate function not viable: no known conversion from 'const char[6]' to 'char' for 2nd argument}}
 344 void foo(int n, const char *s, int t);            // expected-note {{candidate function not viable: requires 3 arguments, but 2 were provided}}
 345 void foo(int n, const char *s, int t, ...);       // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}}
 346 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}}
 347
 348 // PR 11857
 349 void foo(int n);                // expected-note {{candidate function not viable: requires single argument 'n', but 2 arguments were provided}}
 350 void foo(unsigned n = 10);      // expected-note {{candidate function not viable: allows at most single argument 'n', but 2 arguments were provided}}
 351 void bar(int n, int u = 0);     // expected-note {{candidate function not viable: requires at least argument 'n', but no arguments were provided}}
 352 void baz(int n = 0, int u = 0); // expected-note {{candidate function not viable: requires at most 2 arguments, but 3 were provided}}
 353
 354 void 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 6014
 362 namespace 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 6117
 379 namespace 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
 400 namespace 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 6421
 413 namespace 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
 426 namespace 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
 439 namespace 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
 459 namespace 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
 474 namespace 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
 483 namespace 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
 497 namespace 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
 513 namespace 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
 530 // rdar://rdar8499524
 531 namespace rdar8499524 {
 532   struct W {};
 533   struct S {
 534       S(...);
 535   };
 536
 537   void g(const S&);
 538   void f() {
 539     g(W());
 540   }
 541 }
 542
 543 namespace rdar9173984 {
 544   template <typename T, unsigned long N> int &f(const T (&)[N]);
 545   template <typename T> float &f(const T *);
 546
 547   void test() {
 548     int arr[2] = {0, 0};
 549     int *arrp = arr;
 550     int &ir = f(arr);
 551     float &fr = f(arrp);
 552   }
 553 }
 554
 555 namespace PR9507 {
 556   void f(int * const&); // expected-note{{candidate function}}
 557   void f(int const(&)[1]); // expected-note{{candidate function}}
 558
 559   int main() {
 560     int n[1];
 561     f(n); // expected-error{{call to 'f' is ambiguous}}
 562   }
 563 }
 564
 565 namespace rdar9803316 {
 566   void foo(float);
 567   int &foo(int);
 568
 569   void bar() {
 570     int &ir = (&foo)(0);
 571   }
 572 }
 573
 574 namespace IncompleteArg {
 575   // Ensure that overload resolution attempts to complete argument types when
 576   // performing ADL.
 577   template<typename T> struct S {
 578     friend int f(const S&);
 579   };
 580   extern S<int> s;
 581   int k = f(s);
 582
 583   template<typename T> struct Op {
 584     friend bool operator==(const Op &, const Op &);
 585   };
 586   extern Op<char> op;
 587   bool b = op == op;
 588
 589   // ... and not in other cases! Nothing here requires U<int()> to be complete.
 590   // (Note that instantiating U<int()> will fail.)
 591   template<typename T> struct U {
 592     T t;
 593   };
 594   struct Consumer {
 595     template<typename T>
 596     int operator()(const U<T> &);
 597   };
 598   template<typename T> U<T> &make();
 599   Consumer c;
 600   int n = sizeof(c(make<int()>()));
 601 }
 602
 603 namespace PR12142 {
 604   void fun(int (*x)[10]); // expected-note{{candidate function not viable: 1st argument ('const int (*)[10]') would lose const qualifier}}
 605   void g() { fun((const int(*)[10])0); } // expected-error{{no matching function for call to 'fun'}}
 606 }
 607
 608 // DR1152: Take 'volatile' into account when handling reference bindings in
 609 //         overload resolution.
 610 namespace PR12931 {
 611   void f(const int &, ...);
 612   void f(const volatile int &, int);
 613   void g() { f(0, 0); }
 614 }
 615
 616 void test5() {
 617   struct {
 618     typedef void F1(int);
 619     typedef void F2(double);
 620     operator F1*();  // expected-note{{conversion candidate}}
 621     operator F2*();  // expected-note{{conversion candidate}}
 622   } callable;
 623   callable();  // expected-error{{no matching function for call}}
 624 }
 625
 626 namespace PR20218 {
 627   void f(void (*const &)()); // expected-note 2{{candidate}}
 628   void f(void (&&)()) = delete; // expected-note 2{{candidate}}
 629 #if __cplusplus <= 199711L
 630   // expected-warning@-2 {{rvalue references are a C++11 extension}}
 631   // expected-warning@-3 {{deleted function definitions are a C++11 extension}}
 632 #endif
 633   void g(void (&&)()) = delete; // expected-note 2{{candidate}}
 634 #if __cplusplus <= 199711L
 635   // expected-warning@-2 {{rvalue references are a C++11 extension}}
 636   // expected-warning@-3 {{deleted function definitions are a C++11 extension}}
 637 #endif
 638   void g(void (*const &)()); // expected-note 2{{candidate}}
 639
 640   void x();
 641   typedef void (&fr)();
 642   struct Y { operator fr(); } y;
 643
 644   void h() {
 645     f(x); // expected-error {{ambiguous}}
 646     g(x); // expected-error {{ambiguous}}
 647     f(y); // expected-error {{ambiguous}}
 648     g(y); // expected-error {{ambiguous}}
 649   }
 650 }
 651
 652 namespace StringLiteralToCharAmbiguity {
 653   void f(char *, int);
 654   void f(const char *, unsigned);
 655   void g() { f("foo", 0); }
 656 #if __cplusplus <= 199711L
 657   // expected-error@-2 {{call to 'f' is ambiguous}}
 658   // expected-note@-5 {{candidate function}}
 659   // expected-note@-5 {{candidate function}}
 660 #endif
 661 }
 662
 663 namespace ProduceNotesAfterSFINAEFailure {
 664   struct A {
 665     template<typename T, typename U = typename T::x> A(T); // expected-warning 0-1{{extension}}
 666   };
 667   void f(void*, A); // expected-note {{candidate function not viable}}
 668   void g() { f(1, 2); } // expected-error {{no matching function}}
 669 }
 670
 671 namespace PR19808 {
 672   struct B {
 673     int i;
 674     void bar();
 675   };
 676   struct D : public B{};
 677
 678   void f(bool);
 679   void f(int D::*);
 680   void f(void (D::*)());
 681
 682   void Usage() {
 683     int B::*pmem;
 684     void (B::*pmf)();
 685
 686     // These should not be ambiguous.
 687     f(pmem);
 688     f(pmf);
 689   }
 690 }