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
f(int)5 int* f(int) { return 0; }
f(float)6 float* f(float) { return 0; }
7 void f();
8
test_f(int iv,float fv)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
test_g(int iv,float fv)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
test_h(float fv,unsigned char cv)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
test_i(short sv,int iv,long lv,unsigned char ucv)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
test_j(int * ip)51 void test_j(int* ip) {
52 int* ip1 = j(ip);
53 }
54
55 int* k(char*);
56 double* k(bool);
57
test_k()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
test_l()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
test_m()91 void test_m() {
92 int* ip = m("foo");
93 }
94
95 int* n(char*);
96 double* n(void*);
97 class E;
98
test_n(E * e)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
test_o()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
test_p()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
test_bitfield(Bits bits,int x)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
test_multiparm(long lv,short sv,int iv)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
test_quals(int * p,int ** pp,int *** ppp)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
test_quals_ranking(int * p,int volatile * pq,int ** pp,int *** ppp)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
test_derived(B * b,B const * bc,C * c,const C * cc,void * v,D * d)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
test_base(A * a)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
intref_test()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
test_base(A & a)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
bind_vs_conv_test()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
cvqual_subsume_test(Z z)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
cvqual_diff_test(X x,Z z)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
db_rebind_test(Z2 z2)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
f(SR)323 void f(SR) { }
324
g(opt o)325 void g(opt o) {
326 f(o);
327 }
328
329
330 namespace PR5756 {
331 int &a(void*, int);
332 float &a(void*, float);
b()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
test()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;
operator !=(const qrgb666 & v) const374 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
testTypeConversion(Incomplete * P)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
testPointerReferenceConversion(Incomplete & reference,Incomplete * pointer)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
g(B * b)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
bar(A * a)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
g()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
g(X0 x0,X1 x1)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
f()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
g()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 *);
g(Y y)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
bar()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
g()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&);
f()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
test()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
main()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
bar()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}}
g()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);
g()613 void g() { f(0, 0); }
614 }
615
test5()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
h()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);
g()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}}
g()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
Usage()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 }
691