262 lines · cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s2 3template<typename T>4struct X0 {5 template<typename U> T f0(U);6 template<typename U> U& f1(T*, U); // expected-error{{pointer to a reference}} \7 // expected-note{{candidate}}8};9 10X0<int> x0i;11X0<void> x0v;12X0<int&> x0ir; // expected-note{{instantiation}}13 14void test_X0(int *ip, double *dp) {15 X0<int> xi;16 int i1 = xi.f0(ip);17 double *&dpr = xi.f1(ip, dp);18 xi.f1(dp, dp); // expected-error{{no matching}}19 20 X0<void> xv;21 double *&dpr2 = xv.f1(ip, dp);22}23 24template<typename T>25struct X1 {26 template<typename U>27 struct Inner0 {28 U x; 29 T y; // expected-error{{void}}30 };31 32 template<typename U>33 struct Inner1 {34 U x; // expected-error{{void}}35 T y;36 };37 38 template<typename U>39 struct Inner2 {40 struct SuperInner {41 U z; // expected-error{{void}}42 };43 };44 45 template<typename U>46 struct Inner3 {47 void f0(T t, U u) { // expected-note{{passing argument to parameter 't' here}}48 (void)(t + u); // expected-error{{invalid operands}}49 }50 51 template<typename V>52 V f1(T t, U u, V) {53 return t + u; // expected-error{{cannot initialize return object}}54 }55 };56 57 template<typename U>58 struct Inner4;59};60 61template<typename T>62template<typename U>63struct X1<T>::Inner4 {64 template<typename V>65 V f2(T t, U u, V);66 67 static U value;68};69 70template<typename T>71template<typename U>72U X1<T>::Inner4<U>::value; // expected-error{{reference variable}}73 74template<typename T>75template<typename U>76template<typename V>77V X1<T>::Inner4<U>::f2(T t, U u, V) {78 return t + u; // expected-error{{cannot initialize return object}}79}80 81void test_X1(int *ip, int i, double *dp) {82 X1<void>::Inner0<int> *xvip; // okay83 X1<void>::Inner0<int> xvi; // expected-note{{instantiation}}84 85 X1<int>::Inner1<void> *xivp; // okay86 X1<int>::Inner1<void> xiv; // expected-note{{instantiation}}87 88 X1<int>::Inner2<void>::SuperInner *xisivp; // okay89 X1<int>::Inner2<void>::SuperInner xisiv; // expected-note{{instantiation}}90 91 X1<int*>::Inner3<int> id3;92 id3.f0(ip, i);93 id3.f0(dp, i); // expected-error{{cannot initialize a parameter of type 'int *' with an lvalue of type 'double *'}}94 id3.f1(ip, i, ip);95 id3.f1(ip, i, dp); // expected-note{{instantiation}}96 97 X1<int*>::Inner3<double*> id3b;98 id3b.f0(ip, dp); // expected-note{{instantiation}}99 100 X1<int*>::Inner4<int> id4;101 id4.f2(ip, i, dp); // expected-note{{instantiation}}102 103 X1<int*>::Inner4<int>::value = 17;104 i = X1<int*>::Inner4<int&>::value; // expected-note{{instantiation}}105}106 107 108template<typename T>109struct X2 {110 template<T *Ptr> // expected-error{{pointer to a reference}}111 struct Inner;112 113 template<T Value> // expected-error{{cannot have type 'float'}}114 struct Inner2;115};116 117X2<int&> x2a; // expected-note{{instantiation}}118X2<float> x2b; // expected-note{{instantiation}}119 120namespace N0 {121 template<typename T>122 struct X0 { };123 124 struct X1 {125 template<typename T> void f(X0<T>& vals) { g(vals); }126 template<typename T> void g(X0<T>& vals) { }127 };128 129 void test(X1 x1, X0<int> x0i, X0<long> x0l) {130 x1.f(x0i);131 x1.f(x0l);132 } 133}134 135namespace PR6239 {136 template <typename T> 137 struct X0 { 138 class type {139 typedef T E; 140 template <E e> // subsitute T for E and bug goes away141 struct sfinae { }; 142 143 template <class U> 144 typename sfinae<&U::operator=>::type test(int); 145 };146 };147 148 template <typename T> 149 struct X1 { 150 typedef T E; 151 template <E e> // subsitute T for E and bug goes away152 struct sfinae { }; 153 154 template <class U> 155 typename sfinae<&U::operator=>::type test(int); 156 };157 158}159 160namespace PR7587 {161 template<typename> class X0;162 template<typename> struct X1;163 template<typename> class X2;164 165 template<typename T> class X3166 {167 template<168 template<typename> class TT,169 typename U = typename X1<T>::type170 > 171 struct Inner {172 typedef X2<TT<typename X1<T>::type> > Type;173 };174 175 const typename Inner<X0>::Type minCoeff() const;176 };177 178 template<typename T> class X3<T*>179 {180 template<181 template<typename> class TT,182 typename U = typename X1<T>::type183 > 184 struct Inner {185 typedef X2<TT<typename X1<T>::type> > Type;186 };187 188 const typename Inner<X0>::Type minCoeff() const;189 };190 191}192 193namespace PR7669 {194 template<class> struct X {195 template<class> struct Y {196 template<int,class> struct Z;197 template<int Dummy> struct Z<Dummy,int> {};198 };199 };200 201 void a()202 {203 X<int>::Y<int>::Z<0,int>();204 }205}206 207namespace PR8489 {208 template <typename CT>209 class C {210 template<typename FT>211 void F() {} // expected-note{{FT}}212 };213 void f() {214 C<int> c;215 c.F(); // expected-error{{no matching member function}}216 }217}218 219namespace rdar8986308 {220 template <bool> struct __static_assert_test;221 template <> struct __static_assert_test<true> {};222 template <unsigned> struct __static_assert_check {};223 224 namespace std {225 226 template <class _Tp, class _Up>227 struct __has_rebind228 {229 private:230 struct __two {char _; char __;};231 template <class _Xp> static __two __test(...);232 template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);233 public:234 static const bool value = sizeof(__test<_Tp>(0)) == 1;235 };236 237 }238 239 template <class T> struct B1 {};240 241 template <class T>242 struct B243 {244 template <class U> struct rebind {typedef B1<U> other;};245 };246 247 template <class T, class U> struct D1 {};248 249 template <class T, class U>250 struct D251 {252 template <class V> struct rebind {typedef D1<V, U> other;};253 };254 255 int main()256 {257 typedef __static_assert_check<sizeof(__static_assert_test<((std::__has_rebind<B<int>, double>::value))>)> __t64;258 typedef __static_assert_check<sizeof(__static_assert_test<((std::__has_rebind<D<char, int>, double>::value))>)> __t64;259 }260 261}262