test/CXX/over/over.over/p2-resolve-single-template-id.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-bool-conversion %s
   2
   3 typedef __typeof__(((int*)0)-((int*)0)) ptrdiff_t;
   4
   5 namespace DontResolveTooEarly_WaitForOverloadResolution
   6 {
   7   template <class T> T* f(int); // #1
   8   template <class T, class U> T& f(U); // #2
   9
  10   void g() {
  11     int *ip = f<int>(1);        // calls #1
  12   }
  13
  14   template <class T>
  15     T* f2(int);
  16   template <class T, class U>
  17     T& f2(U);
  18
  19   void g2() {
  20     int*ip = (f2<int>)(1); // ok
  21   }
  22
  23 } // End namespace
  24
  25 namespace DontAllowUnresolvedOverloadedExpressionInAnUnusedExpression
  26 {
  27   void one() { }
  28   template<class T> void oneT() { }
  29
  30   void two() { } // expected-note 2 {{possible target for call}}
  31   void two(int) { } // expected-note 2 {{possible target for call}}
  32   template<class T> void twoT() { }  // expected-note 2 {{possible target for call}}
  33   template<class T> void twoT(T) { }  // expected-note 2 {{possible target for call}}
  34
  35   void check()
  36   {
  37     one; // expected-warning {{expression result unused}}
  38     two; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
  39     oneT<int>; // expected-warning {{expression result unused}}
  40     twoT<int>; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
  41   }
  42
  43   // check the template function case
  44   template<class T> void check()
  45   {
  46     one; // expected-warning {{expression result unused}}
  47     two; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
  48     oneT<int>; // expected-warning {{expression result unused}}
  49     twoT<int>; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
  50
  51   }
  52
  53 }
  54
  55   template<typename T>
  56     void twoT() { }
  57   template<typename T, typename U>
  58     void twoT(T) { }
  59
  60
  61   void two() { }; //expected-note 5{{candidate}}
  62   void two(int) { }; //expected-note 5{{candidate}}
  63
  64
  65
  66   void one() { }
  67   template<class T>
  68     void oneT() { }
  69
  70   template<class T>
  71   void cant_resolve() { } //expected-note 3{{candidate}}
  72
  73   template<class T> void cant_resolve(T) { }//expected-note 3{{candidate}}
  74
  75
  76 int main()
  77 {
  78
  79   { static_cast<void>(one); }
  80   { (void)(one); }
  81   { static_cast<void>(oneT<int>); }
  82   { (void)(oneT<int>); }
  83
  84   { static_cast<void>(two); } // expected-error {{address of overloaded function 'two' cannot be static_cast to type 'void'}}
  85   { (void)(two); } // expected-error {{address of overloaded function 'two' cannot be cast to type 'void'}}
  86   { static_cast<void>(twoT<int>); }
  87   { (void)(twoT<int>); }
  88
  89
  90   { ptrdiff_t x = reinterpret_cast<ptrdiff_t>(oneT<int>); }
  91   { (void) reinterpret_cast<int (*)(char, double)>(oneT<int>); }
  92   { (void) reinterpret_cast<ptrdiff_t>(one); }
  93   { (void) reinterpret_cast<int (*)(char, double)>(one); }
  94
  95   { ptrdiff_t x = reinterpret_cast<ptrdiff_t>(twoT<int>); }
  96   { (void) reinterpret_cast<int (*)(char, double)>(twoT<int>); }
  97   { (void) reinterpret_cast<void (*)(int)>(two); } //expected-error {{reinterpret_cast}}
  98   { (void) static_cast<void (*)(int)>(two); } //ok
  99
 100   { (void) reinterpret_cast<int>(two); } //expected-error {{reinterpret_cast}}
 101   { (void) reinterpret_cast<int (*)(char, double)>(two); } //expected-error {{reinterpret_cast}}
 102
 103   { bool b = (twoT<int>); }
 104   { bool b = (twoT<int, int>); }
 105
 106   { bool b = &twoT<int>; //&foo<int>; }
 107     b = &(twoT<int>); }
 108
 109   { ptrdiff_t x = (ptrdiff_t) &twoT<int>;
 110       x = (ptrdiff_t) &twoT<int>; }
 111
 112   { ptrdiff_t x = (ptrdiff_t) twoT<int>;
 113       x = (ptrdiff_t) twoT<int>; }
 114
 115
 116   { ptrdiff_t x = (ptrdiff_t) &twoT<int,int>;
 117   x = (ptrdiff_t) &twoT<int>; }
 118
 119   { oneT<int>;   &oneT<int>; } //expected-warning 2{{expression result unused}}
 120   { static_cast<void>(cant_resolve<int>); } // expected-error {{address of overload}}
 121   { bool b = cant_resolve<int>; } // expected-error {{address of overload}}
 122   { (void) cant_resolve<int>; } // expected-error {{address of overload}}
 123
 124 }
 125
 126 namespace member_pointers {
 127   struct S {
 128     template <typename T> bool f(T) { return false; } // expected-note 4 {{possible target for call}}
 129     template <typename T> static bool g(T) { return false; }
 130
 131     template <typename T> bool h(T) { return false; }  // expected-note 3 {{possible target for call}}
 132     template <int N> static bool h(int) { return false; } // expected-note 3 {{possible target for call}}
 133   };
 134
 135   void test(S s) {
 136     if (S::f<char>) return; // expected-error {{call to non-static member function without an object argument}}
 137     if (S::f<int>) return; // expected-error {{call to non-static member function without an object argument}}
 138     if (&S::f<char>) return;
 139     if (&S::f<int>) return;
 140     if (s.f<char>) return; // expected-error {{reference to non-static member function must be called}}
 141     if (s.f<int>) return; // expected-error {{reference to non-static member function must be called}}
 142     if (&s.f<char>) return; // expected-error {{cannot create a non-constant pointer to member function}}
 143     if (&s.f<int>) return; // expected-error {{cannot create a non-constant pointer to member function}}
 144
 145     if (S::g<char>) return;
 146     if (S::g<int>) return;
 147     if (&S::g<char>) return;
 148     if (&S::g<int>) return;
 149     if (s.g<char>) return;
 150     if (s.g<int>) return;
 151     if (&s.g<char>) return;
 152     if (&s.g<int>) return;
 153
 154     if (S::h<42>) return;
 155     if (S::h<int>) return; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
 156     if (&S::h<42>) return;
 157     if (&S::h<int>) return;
 158     if (s.h<42>) return;
 159     if (s.h<int>) return; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
 160     if (&s.h<42>) return;
 161     if (&s.h<int>) return; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
 162
 163     { bool b = S::f<char>; } // expected-error {{call to non-static member function without an object argument}}
 164     { bool b = S::f<int>; } // expected-error {{call to non-static member function without an object argument}}
 165     { bool b = &S::f<char>; }
 166     { bool b = &S::f<int>; }
 167     // These next two errors are terrible.
 168     { bool b = s.f<char>; } // expected-error {{reference to non-static member function must be called}}
 169     { bool b = s.f<int>; } // expected-error {{reference to non-static member function must be called}}
 170     { bool b = &s.f<char>; } // expected-error {{cannot create a non-constant pointer to member function}}
 171     { bool b = &s.f<int>; } // expected-error {{cannot create a non-constant pointer to member function}}
 172
 173     { bool b = S::g<char>; }
 174     { bool b = S::g<int>; }
 175     { bool b = &S::g<char>; }
 176     { bool b = &S::g<int>; }
 177     { bool b = s.g<char>; }
 178     { bool b = s.g<int>; }
 179     { bool b = &s.g<char>; }
 180     { bool b = &s.g<int>; }
 181
 182     { bool b = S::h<42>; }
 183     { bool b = S::h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}}
 184     { bool b = &S::h<42>; }
 185     { bool b = &S::h<int>; }
 186     { bool b = s.h<42>; }
 187     { bool b = s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}}
 188     { bool b = &s.h<42>; }
 189     { bool b = &s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}}
 190   }
 191 }