blob: 8be2f6c65f4d924543d650a8744a0aed72eb5b81 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x %s
//#include <typeinfo>
void one() { }
void two() { } // expected-note 3{{candidate}}
void two(int) { } // expected-note 3{{candidate}}
template<class T> void twoT() { } // expected-note 4{{candidate}}
template<class T> void twoT(int) { } // expected-note 4{{candidate}}
template<class T> void oneT() { }
template<class T, class U> void oneT(U) { }
/*
The target can be
an object or reference being initialized (8.5, 8.5.3),
the left side of an assignment (5.17),
a parameter of a function (5.2.2),
a parameter of a user-defined operator (13.5),
the return value of a function, operator function, or conversion (6.6.3),
an explicit type conversion (5.2.3, 5.2.9, 5.4), or
a non-type template-parameter (14.3.2)
*/
//#include <typeinfo>
template<void (*p)(int)> struct test { };
int main()
{
one; // expected-warning {{expression result unused}}
two; // expected-error {{address of overloaded}}
oneT<int>; // expected-warning {{expression result unused}}
twoT<int>; // expected-error {{address of overloaded}}
typeid(oneT<int>); //expected-error {{you need to include <typeinfo>}}
sizeof(oneT<int>); // expected-warning {{expression result unused}}
sizeof(twoT<int>); //expected-error {{cannot resolve overloaded function from context}}
decltype(oneT<int>)* fun = 0;
*one; // expected-warning {{expression result unused}}
*oneT<int>; // expected-warning {{expression result unused}}
*two; //expected-error {{cannot resolve overloaded function from context}}
*twoT<int>; //expected-error {{cannot resolve overloaded function from context}}
!oneT<int>; // expected-warning {{expression result unused}}
+oneT<int>; // expected-warning {{expression result unused}}
-oneT<int>; //expected-error {{invalid argument type}}
oneT<int> == 0; // expected-warning {{expression result unused}}
0 == oneT<int>; // expected-warning {{expression result unused}}
0 != oneT<int>; // expected-warning {{expression result unused}}
(false ? one : oneT<int>); // expected-warning {{expression result unused}}
void (*p1)(int); p1 = oneT<int>;
int i = (int) (false ? (void (*)(int))twoT<int> : oneT<int>); //expected-error {{incompatible operand}}
(twoT<int>) == oneT<int>; //expected-error {{invalid operands to binary expression}}
bool b = oneT<int>;
void (*p)() = oneT<int>;
test<oneT<int>> ti;
void (*u)(int) = oneT<int>;
b = (void (*)()) twoT<int>;
one < one; //expected-warning {{self-comparison always evaluates to false}} \
//expected-warning {{expression result unused}}
oneT<int> < oneT<int>; //expected-warning {{self-comparison always evaluates to false}} \
//expected-warning {{expression result unused}}
two < two; //expected-error {{invalid operands to binary expression}}
twoT<int> < twoT<int>; //expected-error {{invalid operands to binary expression}}
oneT<int> == 0; // expected-warning {{expression result unused}}
}
|
