• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
4 int f(double); // expected-note{{candidate function}}
5 int f(int); // expected-note{{candidate function}}
6 
7 int (*pfd)(double) = f; // selects f(double)
8 int (*pfd2)(double) = &f; // selects f(double)
9 int (*pfd3)(double) = ((&((f)))); // selects f(double)
10 int (*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.
14 int (*pfe)(...) = &f;    // expected-error{{address of overloaded function 'f' does not match required type 'int (...)'}}
15 int (&rfi)(int) = f;     // selects f(int)
16 int (&rfd)(double) = f;  // selects f(double)
17 
18 void g(int (*fp)(int));   // expected-note{{candidate function}}
19 void g(int (*fp)(float));
20 void g(int (*fp)(double)); // expected-note{{candidate function}}
21 
22 int g1(int);
23 int g1(char);
24 
25 int g2(int);
26 int g2(double);
27 
28 template<typename T> T g3(T);
29 int g3(int);
30 int g3(char);
31 
g_test()32 void g_test() {
33   g(g1);
34   g(g2); // expected-error{{call to 'g' is ambiguous}}
35   g(g3);
36 }
37 
38 template<typename T> T h1(T);
39 template<typename R, typename A1> R h1(A1);
40 int h1(char);
41 
42 void ha(int (*fp)(int));
43 void hb(int (*fp)(double));
44 
h_test()45 void h_test() {
46   ha(h1);
47   hb(h1);
48 }
49 
50 struct A { };
51 void f(void (*)(A *));
52 
53 struct B
54 {
gB55   void g() { f(d); }
56   void d(void *);
57   static void d(A *);
58 };
59 
60 struct C {
getCC61   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 
gC72   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 
hC90   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
107 namespace 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 
foo()117   void Foo::foo() {
118     myFunction(bar);
119   }
120 }
121 
122 namespace PR7971 {
123   struct S {
gPR7971::S124     void g() {
125       f(&g);
126     }
127     void f(bool (*)(int, char));
128     static bool g(int, char);
129   };
130 }
131 
132 namespace 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 
138 namespace 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}}
f()145   void f() {
146     add_property(&wrap_mean); // expected-error{{no matching function for call to 'add_property'}}
147   }
148 }
149 
150 namespace PR7425 {
151   template<typename T>
foo()152   void foo()
153   {
154   }
155 
156   struct B
157   {
158     template<typename T>
BPR7425::B159     B(const T&)
160     {
161     }
162   };
163 
bar(const B & b)164   void bar(const B& b)
165   {
166   }
167 
bar2(const B & b=foo<int>)168   void bar2(const B& b = foo<int>)
169   {
170   }
171 
test(int argc,char ** argv)172   void test(int argc, char** argv)
173   {
174     bar(foo<int>);
175     bar2();
176   }
177 }
178 
179 namespace test1 {
fun(int x)180   void fun(int x) {}
181 
parameter_number()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 
parameter_mismatch()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 
return_type_test()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 
foo(double x,double y)200   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)201   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)202   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)203   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)204   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)205   double foo(float x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'float')}}
foo(int x)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 {
Ntest1::Qualifiers211     void N() {};
Ctest1::Qualifiers212     void C() const {};
Vtest1::Qualifiers213     void V() volatile {};
Rtest1::Qualifiers214     void R() __restrict {};
CVtest1::Qualifiers215     void CV() const volatile {};
CRtest1::Qualifiers216     void CR() const __restrict {};
VRtest1::Qualifiers217     void VR() volatile __restrict {};
CVRtest1::Qualifiers218     void CVR() const volatile __restrict {};
219   };
220 
221 
QualifierTest()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 (none 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 (none 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 (none 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 (none vs const and 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 (none vs const and 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 (none vs volatile and 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 (none vs const, volatile, and restrict)}}
231   }
232 
233   struct Dummy {
Ntest1::Dummy234     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 
240 template <typename T> class PR16561 {
f()241   virtual bool f() { if (f) {} return false; } // expected-error {{reference to non-static member function must be called}}
242 };
243