1// RUN: %clang_cc1 -fsyntax-only -verify %s
2int f(double); // expected-note{{candidate function}}
3int f(int); // expected-note{{candidate function}}
4
5int (*pfd)(double) = f; // selects f(double)
6int (*pfd2)(double) = &f; // selects f(double)
7int (*pfd3)(double) = ((&((f)))); // selects f(double)
8int (*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.
12int (*pfe)(...) = &f;    // expected-error{{address of overloaded function 'f' does not match required type 'int (...)'}}
13int (&rfi)(int) = f;     // selects f(int)
14int (&rfd)(double) = f;  // selects f(double)
15
16void g(int (*fp)(int));   // expected-note{{candidate function}}
17void g(int (*fp)(float));
18void g(int (*fp)(double)); // expected-note{{candidate function}}
19
20int g1(int);
21int g1(char);
22
23int g2(int);
24int g2(double);
25
26template<typename T> T g3(T);
27int g3(int);
28int g3(char);
29
30void g_test() {
31  g(g1);
32  g(g2); // expected-error{{call to 'g' is ambiguous}}
33  g(g3);
34}
35
36template<typename T> T h1(T);
37template<typename R, typename A1> R h1(A1);
38int h1(char);
39
40void ha(int (*fp)(int));
41void hb(int (*fp)(double));
42
43void h_test() {
44  ha(h1);
45  hb(h1);
46}
47
48struct A { };
49void f(void (*)(A *));
50
51struct B
52{
53  void g() { f(d); }
54  void d(void *);
55  static void d(A *);
56};
57
58struct 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
102namespace 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
117namespace 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
127namespace 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
137namespace 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
149namespace 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
178namespace 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-re {{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const': different qualifiers (none vs const)}}
224    X = &Qualifiers::V; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile': different qualifiers (none vs volatile)}}
225    X = &Qualifiers::R; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} restrict': different qualifiers (none vs restrict)}}
226    X = &Qualifiers::CV; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile': different qualifiers (none vs const and volatile)}}
227    X = &Qualifiers::CR; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const restrict': different qualifiers (none vs const and restrict)}}
228    X = &Qualifiers::VR; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile restrict': different qualifiers (none vs volatile and restrict)}}
229    X = &Qualifiers::CVR; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} 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-re{{cannot initialize a variable of type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' with an rvalue of type 'void (test1::Dummy::*)(){{( __attribute__\(\(thiscall\)\))?}}': different classes ('test1::Qualifiers' vs 'test1::Dummy')}}
237}
238
239template <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