Home | History | Annotate | Download | only in SemaCXX 
      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 
     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 
     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 {
     53   void g() { f(d); }
     54   void d(void *);
     55   static void d(A *);
     56 };
     57 
     58 struct 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
    102 namespace 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 
    117 namespace 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 
    127 namespace 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 
    137 namespace 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 
    149 namespace 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 
    178 namespace 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 {{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const': different qualifiers (none vs const)}}
    224     X = &Qualifiers::V; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() volatile': different qualifiers (none vs volatile)}}
    225     X = &Qualifiers::R; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() restrict': different qualifiers (none vs restrict)}}
    226     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)}}
    227     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)}}
    228     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)}}
    229     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)}}
    230   }
    231 
    232   struct Dummy {
    233     void N() {};
    234   };
    235 
    236   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')}}
    237 }
    238 
    239 template <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