Home | History | Annotate | Download | only in SemaCXX 
      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 {{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 (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 {
    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 };
    243