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