Clang Project

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