1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 int f(double); // expected-note{{candidate function}}
3 int f(int); // expected-note{{candidate function}}
4 
5 int (*pfd)(double) = f; // selects f(double)
6 int (*pfd2)(double) = &f; // selects f(double)
7 int (*pfd3)(double) = ((&((f)))); // selects f(double)
8 int (*pfi)(int) = &f;    // selects f(int)
9 // FIXME: This error message is not very good. We need to keep better
10 // track of what went wrong when the implicit conversion failed to
11 // give a better error message here.
12 int (*pfe)(...) = &f;    // expected-error{{address of overloaded function 'f' does not match required type 'int (...)'}}
13 int (&rfi)(int) = f;     // selects f(int)
14 int (&rfd)(double) = f;  // selects f(double)
15 
16 void g(int (*fp)(int));   // expected-note{{candidate function}}
17 void g(int (*fp)(float));
18 void g(int (*fp)(double)); // expected-note{{candidate function}}
19 
20 int g1(int);
21 int g1(char);
22 
23 int g2(int);
24 int g2(double);
25 
26 template<typename T> T g3(T);
27 int g3(int);
28 int g3(char);
29 
30 void g_test() {
31   g(g1);
32   g(g2); // expected-error{{call to 'g' is ambiguous}}
33   g(g3);
34 }
35 
36 template<typename T> T h1(T);
37 template<typename R, typename A1> R h1(A1);
38 int h1(char);
39 
40 void ha(int (*fp)(int));
41 void hb(int (*fp)(double));
42 
43 void h_test() {
44   ha(h1);
45   hb(h1);
46 }
47 
48 struct A { };
49 void f(void (*)(A *));
50 
51 struct B
52 {
53   void g() { f(d); }
54   void d(void *);
55   static void d(A *);
56 };
57 
58 struct C {
59   C &getC() {
60     return makeAC; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}}
61   }
62 
63   // FIXME: filter by const so we can unambiguously suggest '()' & point to just the one candidate, probably
64   C &makeAC(); // expected-note{{possible target for call}}
65   const C &makeAC() const; // expected-note{{possible target for call}}
66 
67   static void f(); // expected-note{{candidate function}}
68   static void f(int); // expected-note{{candidate function}}
69 
70   void g() {
71     int (&fp)() = f; // expected-error{{address of overloaded function 'f' does not match required type 'int ()'}}
72   }
73 
74   template<typename T>
75   void q1(int); // expected-note{{possible target for call}}
76   template<typename T>
77   void q2(T t = T()); // expected-note{{possible target for call}}
78   template<typename T>
79   void q3(); // expected-note{{possible target for call}}
80   template<typename T1, typename T2>
81   void q4(); // expected-note{{possible target for call}}
82   template<typename T1 = int> // expected-warning{{default template arguments for a function template are a C++11 extension}}
83   void q5(); // expected-note{{possible target for call}}
84 
85   void h() {
86     // Do not suggest '()' since an int argument is required
87     q1<int>; // expected-error-re{{reference to non-static member function must be called$}}
88     // Suggest '()' since there's a default value for the only argument & the
89     // type argument is already provided
90     q2<int>; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}}
91     // Suggest '()' since no arguments are required & the type argument is
92     // already provided
93     q3<int>; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}}
94     // Do not suggest '()' since another type argument is required
95     q4<int>; // expected-error-re{{reference to non-static member function must be called$}}
96     // Suggest '()' since the type parameter has a default value
97     q5; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}}
98   }
99 };
100 
101 // PR6886
102 namespace test0 {
103   void myFunction(void (*)(void *));
104 
105   class Foo {
106     void foo();
107 
108     static void bar(void*);
109     static void bar();
110   };
111 
112   void Foo::foo() {
113     myFunction(bar);
114   }
115 }
116 
117 namespace PR7971 {
118   struct S {
119     void g() {
120       f(&g);
121     }
122     void f(bool (*)(int, char));
123     static bool g(int, char);
124   };
125 }
126 
127 namespace PR8033 {
128   template <typename T1, typename T2> int f(T1 *, const T2 *); // expected-note {{candidate function [with T1 = const int, T2 = int]}} \
129   // expected-note{{candidate function}}
130   template <typename T1, typename T2> int f(const T1 *, T2 *); // expected-note {{candidate function [with T1 = int, T2 = const int]}} \
131   // expected-note{{candidate function}}
132   int (*p)(const int *, const int *) = f; // expected-error{{address of overloaded function 'f' is ambiguous}} \
133   // expected-error{{address of overloaded function 'f' is ambiguous}}
134 
135 }
136 
137 namespace PR8196 {
138   template <typename T> struct mcdata {
139     typedef int result_type;
140   };
141   template <class T>
142     typename mcdata<T>::result_type wrap_mean(mcdata<T> const&);
143   void add_property(double(*)(mcdata<double> const &)); // expected-note{{candidate function not viable: no overload of 'wrap_mean' matching}}
144   void f() {
145     add_property(&wrap_mean); // expected-error{{no matching function for call to 'add_property'}}
146   }
147 }
148 
149 namespace PR7425 {
150   template<typename T>
151   void foo()
152   {
153   }
154 
155   struct B
156   {
157     template<typename T>
158     B(const T&)
159     {
160     }
161   };
162 
163   void bar(const B& b)
164   {
165   }
166 
167   void bar2(const B& b = foo<int>)
168   {
169   }
170 
171   void test(int argc, char** argv)
172   {
173     bar(foo<int>);
174     bar2();
175   }
176 }
177 
178 namespace test1 {
179   void fun(int x) {}
180 
181   void parameter_number() {
182     void (*ptr1)(int, int) = &fun; // expected-error {{cannot initialize a variable of type 'void (*)(int, int)' with an rvalue of type 'void (*)(int)': different number of parameters (2 vs 1)}}
183     void (*ptr2)(int, int);
184     ptr2 = &fun;  // expected-error {{assigning to 'void (*)(int, int)' from incompatible type 'void (*)(int)': different number of parameters (2 vs 1)}}
185   }
186 
187   void parameter_mismatch() {
188     void (*ptr1)(double) = &fun; // expected-error {{cannot initialize a variable of type 'void (*)(double)' with an rvalue of type 'void (*)(int)': type mismatch at 1st parameter ('double' vs 'int')}}
189     void (*ptr2)(double);
190     ptr2 = &fun; // expected-error {{assigning to 'void (*)(double)' from incompatible type 'void (*)(int)': type mismatch at 1st parameter ('double' vs 'int')}}
191   }
192 
193   void return_type_test() {
194     int (*ptr1)(int) = &fun; // expected-error {{cannot initialize a variable of type 'int (*)(int)' with an rvalue of type 'void (*)(int)': different return type ('int' vs 'void')}}
195     int (*ptr2)(int);
196     ptr2 = &fun;  // expected-error {{assigning to 'int (*)(int)' from incompatible type 'void (*)(int)': different return type ('int' vs 'void')}}
197   }
198 
199   int foo(double x, double y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
200   int foo(int x, int y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
201   int foo(double x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'double')}}
202   double foo(float x, float y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
203   double foo(int x, float y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
204   double foo(float x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'float')}}
205   double foo(int x) {return 0;} // expected-note {{candidate function has different return type ('int' expected but has 'double')}}
206 
207   int (*ptr)(int) = &foo; // expected-error {{address of overloaded function 'foo' does not match required type 'int (int)'}}
208 
209   struct Qualifiers {
210     void N() {};
211     void C() const {};
212     void V() volatile {};
213     void R() __restrict {};
214     void CV() const volatile {};
215     void CR() const __restrict {};
216     void VR() volatile __restrict {};
217     void CVR() const volatile __restrict {};
218   };
219 
220 
221   void QualifierTest() {
222     void (Qualifiers::*X)();
223     X = &Qualifiers::C; // expected-error {{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const': different qualifiers (none vs const)}}
224     X = &Qualifiers::V; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() volatile': different qualifiers (none vs volatile)}}
225     X = &Qualifiers::R; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() restrict': different qualifiers (none vs restrict)}}
226     X = &Qualifiers::CV; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const volatile': different qualifiers (none vs const and volatile)}}
227     X = &Qualifiers::CR; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const restrict': different qualifiers (none vs const and restrict)}}
228     X = &Qualifiers::VR; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() volatile restrict': different qualifiers (none vs volatile and restrict)}}
229     X = &Qualifiers::CVR; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const volatile restrict': different qualifiers (none vs const, volatile, and restrict)}}
230   }
231 
232   struct Dummy {
233     void N() {};
234   };
235 
236   void (Qualifiers::*X)() = &Dummy::N; // expected-error{{cannot initialize a variable of type 'void (test1::Qualifiers::*)()' with an rvalue of type 'void (test1::Dummy::*)()': different classes ('test1::Qualifiers' vs 'test1::Dummy')}}
237 }
238 
239 template <typename T> class PR16561 {
240   virtual bool f() { if (f) {} return false; } // expected-error {{reference to non-static member function must be called}}
241 };
242