1 // RUN: %clang_cc1 -fsyntax-only -verify %s 2 template<typename T> 3 class X { 4 public: 5 void f(T x); // expected-error{{argument may not have 'void' type}} 6 void g(T*); 7 8 static int h(T, T); // expected-error {{argument may not have 'void' type}} 9 }; 10 11 int identity(int x) { return x; } 12 13 void test(X<int> *xi, int *ip, X<int(int)> *xf) { 14 xi->f(17); 15 xi->g(ip); 16 xf->f(&identity); 17 xf->g(identity); 18 X<int>::h(17, 25); 19 X<int(int)>::h(identity, &identity); 20 } 21 22 void test_bad() { 23 X<void> xv; // expected-note{{in instantiation of template class 'X<void>' requested here}} 24 } 25 26 template<typename T, typename U> 27 class Overloading { 28 public: 29 int& f(T, T); // expected-note{{previous declaration is here}} 30 float& f(T, U); // expected-error{{functions that differ only in their return type cannot be overloaded}} 31 }; 32 33 void test_ovl(Overloading<int, long> *oil, int i, long l) { 34 int &ir = oil->f(i, i); 35 float &fr = oil->f(i, l); 36 } 37 38 void test_ovl_bad() { 39 Overloading<float, float> off; // expected-note{{in instantiation of template class 'Overloading<float, float>' requested here}} 40 } 41 42 template<typename T> 43 class HasDestructor { 44 public: 45 virtual ~HasDestructor() = 0; 46 }; 47 48 int i = sizeof(HasDestructor<int>); // FIXME: forces instantiation, but 49 // the code below should probably instantiate by itself. 50 int abstract_destructor[__is_abstract(HasDestructor<int>)? 1 : -1]; 51 52 53 template<typename T> 54 class Constructors { 55 public: 56 Constructors(const T&); 57 Constructors(const Constructors &other); 58 }; 59 60 void test_constructors() { 61 Constructors<int> ci1(17); 62 Constructors<int> ci2 = ci1; 63 } 64 65 66 template<typename T> 67 struct ConvertsTo { 68 operator T(); 69 }; 70 71 void test_converts_to(ConvertsTo<int> ci, ConvertsTo<int *> cip) { 72 int i = ci; 73 int *ip = cip; 74 } 75 76 // PR4660 77 template<class T> struct A0 { operator T*(); }; 78 template<class T> struct A1; 79 80 int *a(A0<int> &x0, A1<int> &x1) { 81 int *y0 = x0; 82 int *y1 = x1; // expected-error{{no viable conversion}} 83 } 84 85 struct X0Base { 86 int &f(); 87 int& g(int); 88 static double &g(double); 89 }; 90 91 template<typename T> 92 struct X0 : X0Base { 93 }; 94 95 template<typename U> 96 struct X1 : X0<U> { 97 int &f2() { 98 return X0Base::f(); 99 } 100 }; 101 102 void test_X1(X1<int> x1i) { 103 int &ir = x1i.f2(); 104 } 105 106 template<typename U> 107 struct X2 : X0Base, U { 108 int &f2() { return X0Base::f(); } 109 }; 110 111 template<typename T> 112 struct X3 { 113 void test(T x) { 114 double& d1 = X0Base::g(x); 115 } 116 }; 117 118 119 template struct X3<double>; 120 121 // Don't try to instantiate this, it's invalid. 122 namespace test1 { 123 template <class T> class A {}; 124 template <class T> class B { 125 void foo(A<test1::Undeclared> &a) // expected-error {{no member named 'Undeclared' in namespace 'test1'}} 126 {} 127 }; 128 template class B<int>; 129 } 130 131 namespace PR6947 { 132 template< class T > 133 struct X { 134 int f0( ) 135 { 136 typedef void ( X::*impl_fun_ptr )( ); 137 impl_fun_ptr pImpl = &X::template 138 f0_impl1<int>; 139 } 140 private: 141 int f1() { 142 } 143 template< class Processor> 144 void f0_impl1( ) 145 { 146 } 147 }; 148 149 char g0() { 150 X<int> pc; 151 pc.f0(); 152 } 153 154 } 155 156 namespace PR7022 { 157 template <typename > 158 struct X1 159 { 160 typedef int state_t( ); 161 state_t g ; 162 }; 163 164 template < typename U = X1<int> > struct X2 165 { 166 X2( U = U()) 167 { 168 } 169 }; 170 171 void m(void) 172 { 173 typedef X2<> X2_type; 174 X2_type c; 175 } 176 } 177 178 namespace SameSignatureAfterInstantiation { 179 template<typename T> struct S { 180 void f(T *); // expected-note {{previous}} 181 void f(const T*); // expected-error-re {{multiple overloads of 'f' instantiate to the same signature 'void (const int *){{( __attribute__\(\(thiscall\)\))?}}'}} 182 }; 183 S<const int> s; // expected-note {{instantiation}} 184 } 185
