150
+ − 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 'IncompleteConversion::Incomplete' to 'IncompleteConversion::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 'IncompleteConversion::Incomplete *' to 'IncompleteConversion::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 'PR6078::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 }