test/SemaTemplate/resolve-single-template-id.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
   2
   3 namespace std {
   4   class type_info {};
   5 }
   6
   7 void one() { }
   8 void two() { } // expected-note 4{{possible target for call}}
   9 void two(int) { } // expected-note 4{{possible target for call}}
  10
  11 template<class T> void twoT() { } // expected-note 5{{possible target for call}}
  12 template<class T> void twoT(int) { } // expected-note 5{{possible target for call}}
  13
  14 template<class T> void oneT() { }
  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
  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-warning {{expression result unused}}
  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}}
  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   0 == oneT<int>;   // expected-warning {{equality comparison result unused}}
  50   0 != oneT<int>;    // expected-warning {{inequality comparison result unused}}
  51   (false ? one : oneT<int>);   // expected-warning {{expression result unused}}
  52   void (*p1)(int); p1 = oneT<int>;
  53
  54   int i = (int) (false ? (void (*)(int))twoT<int> : oneT<int>); //expected-error {{incompatible operand}}
  55   (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}}
  56   bool b = oneT<int>;
  57   void (*p)() = oneT<int>;
  58   test<oneT<int> > ti;
  59   void (*u)(int) = oneT<int>;
  60
  61   b = (void (*)()) twoT<int>;
  62
  63   one < one; //expected-warning {{self-comparison always evaluates to false}} \
  64              //expected-warning {{expression result unused}}
  65
  66   oneT<int> < oneT<int>;  //expected-warning {{self-comparison always evaluates to false}} \
  67                           //expected-warning {{expression result unused}}
  68
  69   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')}}
  70   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}}
  71   oneT<int> == 0;   // expected-warning {{equality comparison result unused}} \
  72                     // expected-note {{use '=' to turn this equality comparison into an assignment}}
  73
  74 }
  75
  76 struct rdar9108698 {
  77   template<typename> void f();
  78 };
  79
  80 void test_rdar9108698(rdar9108698 x) {
  81   x.f<int>; // expected-error{{reference to non-static member function must be called}}
  82 }