clang/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
   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
  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
  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 {
  55   void g() { f(d); }
  56   void d(void *);
  57   static void d(A *);
  58 };
  59
  60 struct 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
 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
 117   void Foo::foo() {
 118     myFunction(bar);
 119   }
 120 }
 121
 122 namespace 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
 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}}
 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>
 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
 179 namespace 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 {{incompatible function pointer types assigning to 'void (*)(int, int)' from 'void (*)(int)'}}
 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 {{incompatible function pointer types assigning to 'void (*)(double)' from 'void (*)(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 {{incompatible function pointer types assigning to 'int (*)(int)' from 'void (*)(int)'}}
 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
 240 template <typename T> class PR16561 {
 241   virtual bool f() { if (f) {} return false; } // expected-error {{reference to non-static member function must be called}}
 242 };