1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2
3 namespace std {
4 class type_info {};
5 }
6
one()7 void one() { }
two()8 void two() { } // expected-note 4{{possible target for call}}
two(int)9 void two(int) { } // expected-note 4{{possible target for call}}
10
twoT()11 template<class T> void twoT() { } // expected-note 5{{possible target for call}}
twoT(int)12 template<class T> void twoT(int) { } // expected-note 5{{possible target for call}}
13
oneT()14 template<class T> void oneT() { }
oneT(U)15 template<class T, class U> void oneT(U) { }
16 /*
17 The target can be
18 an object or reference being initialized (8.5, 8.5.3),
19 the left side of an assignment (5.17),
20 a parameter of a function (5.2.2),
21 a parameter of a user-defined operator (13.5),
22 the return value of a function, operator function, or conversion (6.6.3),
23 an explicit type conversion (5.2.3, 5.2.9, 5.4), or
24 a non-type template-parameter (14.3.2)
25 */
26 //#include <typeinfo>
27 template<void (*p)(int)> struct test { };
28
main()29 int main()
30 {
31 one; // expected-warning {{expression result unused}}
32 two; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
33 oneT<int>; // expected-warning {{expression result unused}}
34 twoT<int>; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
35 typeid(oneT<int>); // expected-warning{{expression result unused}}
36 sizeof(oneT<int>); // expected-error {{invalid application of 'sizeof' to a function type}}
37 sizeof(twoT<int>); //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
38 decltype(oneT<int>)* fun = 0;
39
40 *one; // expected-warning {{expression result unused}}
41 *oneT<int>; // expected-warning {{expression result unused}}
42 *two; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{indirection requires pointer operand}}
43 *twoT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
44 !oneT<int>; // expected-warning {{expression result unused}} expected-warning {{address of function 'oneT<int>' will always evaluate to 'true'}} expected-note {{prefix with the address-of operator to silence this warning}}
45 +oneT<int>; // expected-warning {{expression result unused}}
46 -oneT<int>; //expected-error {{invalid argument type}}
47 oneT<int> == 0; // expected-warning {{equality comparison result unused}} \
48 // expected-note {{use '=' to turn this equality comparison into an assignment}} \
49 // expected-warning {{comparison of function 'oneT<int>' equal to a null pointer is always false}} \
50 // expected-note {{prefix with the address-of operator to silence this warning}}
51 0 == oneT<int>; // expected-warning {{equality comparison result unused}} \
52 // expected-warning {{comparison of function 'oneT<int>' equal to a null pointer is always false}} \
53 // expected-note {{prefix with the address-of operator to silence this warning}}
54 0 != oneT<int>; // expected-warning {{inequality comparison result unused}} \
55 // expected-warning {{comparison of function 'oneT<int>' not equal to a null pointer is always true}} \
56 // expected-note {{prefix with the address-of operator to silence this warning}}
57 (false ? one : oneT<int>); // expected-warning {{expression result unused}}
58 void (*p1)(int); p1 = oneT<int>;
59
60 int i = (int) (false ? (void (*)(int))twoT<int> : oneT<int>); //expected-error {{incompatible operand}}
61 (twoT<int>) == oneT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} {{cannot resolve overloaded function 'twoT' from context}}
62 bool b = oneT<int>; // expected-warning {{address of function 'oneT<int>' will always evaluate to 'true'}} expected-note {{prefix with the address-of operator to silence this warning}}
63 void (*p)() = oneT<int>;
64 test<oneT<int> > ti;
65 void (*u)(int) = oneT<int>;
66
67 b = (void (*)()) twoT<int>;
68
69 one < one; // expected-warning {{self-comparison always evaluates to false}} \
70 // expected-warning {{relational comparison result unused}} \
71 // expected-warning {{ordered comparison of function pointers}}
72
73 oneT<int> < oneT<int>; // expected-warning {{self-comparison always evaluates to false}} \
74 // expected-warning {{relational comparison result unused}} \
75 // expected-warning {{ordered comparison of function pointers}}
76
77 two < two; //expected-error 2 {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{invalid operands to binary expression ('void' and 'void')}}
78 twoT<int> < twoT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} {{cannot resolve overloaded function 'twoT' from context}}
79 oneT<int> == 0; // expected-warning {{equality comparison result unused}} \
80 // expected-note {{use '=' to turn this equality comparison into an assignment}} \
81 // expected-warning {{comparison of function 'oneT<int>' equal to a null pointer is always false}} \
82 // expected-note {{prefix with the address-of operator to silence this warning}}
83
84 }
85
86 struct rdar9108698 {
87 template<typename> void f(); // expected-note{{possible target for call}}
88 };
89
test_rdar9108698(rdar9108698 x)90 void test_rdar9108698(rdar9108698 x) {
91 x.f<int>; // expected-error{{reference to non-static member function must be called}}
92 }
93
94 namespace GCC_PR67898 {
95 void f(int);
96 void f(float);
97 template<typename T, T F, T G, bool b = F == G> struct X {
98 static_assert(b, "");
99 };
test1()100 template<typename T> void test1() { X<void(T), f, f>(); }
test2()101 template<typename T> void test2() { X<void(*)(T), f, f>(); }
102 template void test1<int>();
103 template void test2<int>();
104 }
105