Clang Project

clang_source_code/test/SemaTemplate/resolve-single-template-id.cpp
1// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2
3namespace std {
4  class type_info {};
5}
6
7void one() { }
8void two() { } // expected-note 4{{possible target for call}}
9void two(int) { } // expected-note 4{{possible target for call}}
10
11template<class T> void twoT() { } // expected-note 5{{possible target for call}}
12template<class T> void twoT(int) { } // expected-note 5{{possible target for call}}
13
14template<class T> void oneT() { }
15template<class T, class U> void oneT(U) { }
16/*
17The 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>
27template<void (*p)(int)> struct test { };
28
29int 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
72  oneT<int> < oneT<int>;  //expected-warning {{self-comparison always evaluates to false}} \
73                          //expected-warning {{relational comparison result unused}}
74
75  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')}}
76  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}}
77  oneT<int> == 0;   // expected-warning {{equality comparison result unused}} \
78                    // expected-note {{use '=' to turn this equality comparison into an assignment}} \
79                    // expected-warning {{comparison of function 'oneT<int>' equal to a null pointer is always false}} \
80                    // expected-note {{prefix with the address-of operator to silence this warning}}
81
82}
83
84struct rdar9108698 {
85  template<typename> void f(); // expected-note{{possible target for call}}
86};
87
88void test_rdar9108698(rdar9108698 x) {
89  x.f<int>; // expected-error{{reference to non-static member function must be called}}
90}
91
CodeThinker, Enjoy your reading code