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
g_test()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
h_test()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 {
gB53 void g() { f(d); }
54 void d(void *);
55 static void d(A *);
56 };
57
58 struct C {
getCC59 C &getC() {
60 return makeAC; // expected-error{{reference to non-static member function must be called}}
61 }
62
63 C &makeAC();
64 const C &makeAC() const;
65
66 static void f(); // expected-note{{candidate function}}
67 static void f(int); // expected-note{{candidate function}}
68
gC69 void g() {
70 int (&fp)() = f; // expected-error{{address of overloaded function 'f' does not match required type 'int ()'}}
71 }
72 };
73
74 // PR6886
75 namespace test0 {
76 void myFunction(void (*)(void *));
77
78 class Foo {
79 void foo();
80
81 static void bar(void*);
82 static void bar();
83 };
84
foo()85 void Foo::foo() {
86 myFunction(bar);
87 }
88 }
89
90 namespace PR7971 {
91 struct S {
gPR7971::S92 void g() {
93 f(&g);
94 }
95 void f(bool (*)(int, char));
96 static bool g(int, char);
97 };
98 }
99
100 namespace PR8033 {
101 template <typename T1, typename T2> int f(T1 *, const T2 *); // expected-note {{candidate function [with T1 = const int, T2 = int]}} \
102 // expected-note{{candidate function}}
103 template <typename T1, typename T2> int f(const T1 *, T2 *); // expected-note {{candidate function [with T1 = int, T2 = const int]}} \
104 // expected-note{{candidate function}}
105 int (*p)(const int *, const int *) = f; // expected-error{{address of overloaded function 'f' is ambiguous}} \
106 // expected-error{{address of overloaded function 'f' is ambiguous}}
107
108 }
109
110 namespace PR8196 {
111 template <typename T> struct mcdata {
112 typedef int result_type;
113 };
114 template <class T>
115 typename mcdata<T>::result_type wrap_mean(mcdata<T> const&);
116 void add_property(double(*)(mcdata<double> const &)); // expected-note{{candidate function not viable: no overload of 'wrap_mean' matching}}
f()117 void f() {
118 add_property(&wrap_mean); // expected-error{{no matching function for call to 'add_property'}}
119 }
120 }
121
122 namespace PR7425 {
123 template<typename T>
foo()124 void foo()
125 {
126 }
127
128 struct B
129 {
130 template<typename T>
BPR7425::B131 B(const T&)
132 {
133 }
134 };
135
bar(const B & b)136 void bar(const B& b)
137 {
138 }
139
bar2(const B & b=foo<int>)140 void bar2(const B& b = foo<int>)
141 {
142 }
143
test(int argc,char ** argv)144 void test(int argc, char** argv)
145 {
146 bar(foo<int>);
147 bar2();
148 }
149 }
150
151 namespace test1 {
fun(int x)152 void fun(int x) {}
153
parameter_number()154 void parameter_number() {
155 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)}}
156 void (*ptr2)(int, int);
157 ptr2 = &fun; // expected-error {{assigning to 'void (*)(int, int)' from incompatible type 'void (*)(int)': different number of parameters (2 vs 1)}}
158 }
159
parameter_mismatch()160 void parameter_mismatch() {
161 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')}}
162 void (*ptr2)(double);
163 ptr2 = &fun; // expected-error {{assigning to 'void (*)(double)' from incompatible type 'void (*)(int)': type mismatch at 1st parameter ('double' vs 'int')}}
164 }
165
return_type_test()166 void return_type_test() {
167 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')}}
168 int (*ptr2)(int);
169 ptr2 = &fun; // expected-error {{assigning to 'int (*)(int)' from incompatible type 'void (*)(int)': different return type ('int' vs 'void')}}
170 }
171
foo(double x,double y)172 int foo(double x, double y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
foo(int x,int y)173 int foo(int x, int y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
foo(double x)174 int foo(double x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'double')}}
foo(float x,float y)175 double foo(float x, float y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
foo(int x,float y)176 double foo(int x, float y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
foo(float x)177 double foo(float x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'float')}}
foo(int x)178 double foo(int x) {return 0;} // expected-note {{candidate function has different return type ('int' expected but has 'double')}}
179
180 int (*ptr)(int) = &foo; // expected-error {{address of overloaded function 'foo' does not match required type 'int (int)'}}
181
182 struct Qualifiers {
Ntest1::Qualifiers183 void N() {};
Ctest1::Qualifiers184 void C() const {};
Vtest1::Qualifiers185 void V() volatile {};
Rtest1::Qualifiers186 void R() __restrict {};
CVtest1::Qualifiers187 void CV() const volatile {};
CRtest1::Qualifiers188 void CR() const __restrict {};
VRtest1::Qualifiers189 void VR() volatile __restrict {};
CVRtest1::Qualifiers190 void CVR() const volatile __restrict {};
191 };
192
193
QualifierTest()194 void QualifierTest() {
195 void (Qualifiers::*X)();
196 X = &Qualifiers::C; // expected-error {{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const': different qualifiers (none vs const)}}
197 X = &Qualifiers::V; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() volatile': different qualifiers (none vs volatile)}}
198 X = &Qualifiers::R; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() restrict': different qualifiers (none vs restrict)}}
199 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)}}
200 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)}}
201 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)}}
202 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)}}
203 }
204
205 struct Dummy {
Ntest1::Dummy206 void N() {};
207 };
208
209 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')}}
210 }
211