diff options
Diffstat (limited to 'clang/test/SemaTemplate/instantiate-member-template.cpp')
| -rw-r--r-- | clang/test/SemaTemplate/instantiate-member-template.cpp | 261 |
1 files changed, 261 insertions, 0 deletions
diff --git a/clang/test/SemaTemplate/instantiate-member-template.cpp b/clang/test/SemaTemplate/instantiate-member-template.cpp new file mode 100644 index 0000000..4c74f5f --- /dev/null +++ b/clang/test/SemaTemplate/instantiate-member-template.cpp @@ -0,0 +1,261 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +template<typename T> +struct X0 { + template<typename U> T f0(U); + template<typename U> U& f1(T*, U); // expected-error{{pointer to a reference}} \ + // expected-note{{candidate}} +}; + +X0<int> x0i; +X0<void> x0v; +X0<int&> x0ir; // expected-note{{instantiation}} + +void test_X0(int *ip, double *dp) { + X0<int> xi; + int i1 = xi.f0(ip); + double *&dpr = xi.f1(ip, dp); + xi.f1(dp, dp); // expected-error{{no matching}} + + X0<void> xv; + double *&dpr2 = xv.f1(ip, dp); +} + +template<typename T> +struct X1 { + template<typename U> + struct Inner0 { + U x; + T y; // expected-error{{void}} + }; + + template<typename U> + struct Inner1 { + U x; // expected-error{{void}} + T y; + }; + + template<typename U> + struct Inner2 { + struct SuperInner { + U z; // expected-error{{void}} + }; + }; + + template<typename U> + struct Inner3 { + void f0(T t, U u) { // expected-note{{passing argument to parameter 't' here}} + (void)(t + u); // expected-error{{invalid operands}} + } + + template<typename V> + V f1(T t, U u, V) { + return t + u; // expected-error{{cannot initialize return object}} + } + }; + + template<typename U> + struct Inner4; +}; + +template<typename T> +template<typename U> +struct X1<T>::Inner4 { + template<typename V> + V f2(T t, U u, V); + + static U value; +}; + +template<typename T> +template<typename U> +U X1<T>::Inner4<U>::value; // expected-error{{reference variable}} + +template<typename T> +template<typename U> +template<typename V> +V X1<T>::Inner4<U>::f2(T t, U u, V) { + return t + u; // expected-error{{cannot initialize return object}} +} + +void test_X1(int *ip, int i, double *dp) { + X1<void>::Inner0<int> *xvip; // okay + X1<void>::Inner0<int> xvi; // expected-note{{instantiation}} + + X1<int>::Inner1<void> *xivp; // okay + X1<int>::Inner1<void> xiv; // expected-note{{instantiation}} + + X1<int>::Inner2<void>::SuperInner *xisivp; // okay + X1<int>::Inner2<void>::SuperInner xisiv; // expected-note{{instantiation}} + + X1<int*>::Inner3<int> id3; + id3.f0(ip, i); + id3.f0(dp, i); // expected-error{{cannot initialize a parameter of type 'int *' with an lvalue of type 'double *'}} + id3.f1(ip, i, ip); + id3.f1(ip, i, dp); // expected-note{{instantiation}} + + X1<int*>::Inner3<double*> id3b; + id3b.f0(ip, dp); // expected-note{{instantiation}} + + X1<int*>::Inner4<int> id4; + id4.f2(ip, i, dp); // expected-note{{instantiation}} + + X1<int*>::Inner4<int>::value = 17; + i = X1<int*>::Inner4<int&>::value; // expected-note{{instantiation}} +} + + +template<typename T> +struct X2 { + template<T *Ptr> // expected-error{{pointer to a reference}} + struct Inner; + + template<T Value> // expected-error{{cannot have type 'float'}} + struct Inner2; +}; + +X2<int&> x2a; // expected-note{{instantiation}} +X2<float> x2b; // expected-note{{instantiation}} + +namespace N0 { + template<typename T> + struct X0 { }; + + struct X1 { + template<typename T> void f(X0<T>& vals) { g(vals); } + template<typename T> void g(X0<T>& vals) { } + }; + + void test(X1 x1, X0<int> x0i, X0<long> x0l) { + x1.f(x0i); + x1.f(x0l); + } +} + +namespace PR6239 { + template <typename T> + struct X0 { + class type { + typedef T E; + template <E e> // subsitute T for E and bug goes away + struct sfinae { }; + + template <class U> + typename sfinae<&U::operator=>::type test(int); + }; + }; + + template <typename T> + struct X1 { + typedef T E; + template <E e> // subsitute T for E and bug goes away + struct sfinae { }; + + template <class U> + typename sfinae<&U::operator=>::type test(int); + }; + +} + +namespace PR7587 { + template<typename> class X0; + template<typename> struct X1; + template<typename> class X2; + + template<typename T> class X3 + { + template< + template<typename> class TT, + typename U = typename X1<T>::type + > + struct Inner { + typedef X2<TT<typename X1<T>::type> > Type; + }; + + const typename Inner<X0>::Type minCoeff() const; + }; + + template<typename T> class X3<T*> + { + template< + template<typename> class TT, + typename U = typename X1<T>::type + > + struct Inner { + typedef X2<TT<typename X1<T>::type> > Type; + }; + + const typename Inner<X0>::Type minCoeff() const; + }; + +} + +namespace PR7669 { + template<class> struct X { + template<class> struct Y { + template<int,class> struct Z; + template<int Dummy> struct Z<Dummy,int> {}; + }; + }; + + void a() + { + X<int>::Y<int>::Z<0,int>(); + } +} + +namespace PR8489 { + template <typename CT> + class C { + template<typename FT> + void F() {} // expected-note{{FT}} + }; + void f() { + C<int> c; + c.F(); // expected-error{{no matching member function}} + } +} + +namespace rdar8986308 { + template <bool> struct __static_assert_test; + template <> struct __static_assert_test<true> {}; + template <unsigned> struct __static_assert_check {}; + + namespace std { + + template <class _Tp, class _Up> + struct __has_rebind + { + private: + struct __two {char _; char __;}; + template <class _Xp> static __two __test(...); + template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0); + public: + static const bool value = sizeof(__test<_Tp>(0)) == 1; + }; + + } + + template <class T> struct B1 {}; + + template <class T> + struct B + { + template <class U> struct rebind {typedef B1<U> other;}; + }; + + template <class T, class U> struct D1 {}; + + template <class T, class U> + struct D + { + template <class V> struct rebind {typedef D1<V, U> other;}; + }; + + int main() + { + typedef __static_assert_check<sizeof(__static_assert_test<((std::__has_rebind<B<int>, double>::value))>)> __t64; + typedef __static_assert_check<sizeof(__static_assert_test<((std::__has_rebind<D<char, int>, double>::value))>)> __t64; + } + +} |