diff options
Diffstat (limited to 'test/SemaTemplate/temp_explicit.cpp')
-rw-r--r-- | test/SemaTemplate/temp_explicit.cpp | 111 |
1 files changed, 111 insertions, 0 deletions
diff --git a/test/SemaTemplate/temp_explicit.cpp b/test/SemaTemplate/temp_explicit.cpp new file mode 100644 index 000000000000..0292964a1a76 --- /dev/null +++ b/test/SemaTemplate/temp_explicit.cpp @@ -0,0 +1,111 @@ +// RUN: clang-cc -fsyntax-only -pedantic -verify %s +// +// Tests explicit instantiation of templates. +template<typename T, typename U = T> class X0 { }; + +namespace N { + template<typename T, typename U = T> class X1 { }; +} + +// Check the syntax of explicit instantiations. +template class X0<int, float>; +template class X0<int>; // expected-note{{previous}} + +template class N::X1<int>; +template class ::N::X1<int, float>; + +using namespace N; +template class X1<float>; + +// Check for some bogus syntax that probably means that the user +// wanted to write an explicit specialization, but forgot the '<>' +// after 'template'. +template class X0<double> { }; // expected-error{{explicit specialization}} + +// Check for explicit instantiations that come after other kinds of +// instantiations or declarations. +template class X0<int, int>; // expected-error{{duplicate}} + +template<> class X0<char> { }; // expected-note{{previous}} +template class X0<char>; // expected-warning{{ignored}} + +void foo(X0<short>) { } +template class X0<short>; + +// Check that explicit instantiations actually produce definitions. We +// determine whether this happens by placing semantic errors in the +// definition of the template we're instantiating. +template<typename T> struct X2; // expected-note{{declared here}} + +template struct X2<float>; // expected-error{{undefined template}} + +template<typename T> +struct X2 { + void f0(T*); // expected-error{{pointer to a reference}} +}; + +template struct X2<int>; // okay +template struct X2<int&>; // expected-note{{in instantiation of}} + +// Check that explicit instantiations instantiate member classes. +template<typename T> struct X3 { + struct Inner { + void f(T*); // expected-error{{pointer to a reference}} + }; +}; + +void f1(X3<int&>); // okay, Inner, not instantiated + +template struct X3<int&>; // expected-note{{instantiation}} + +template<typename T> struct X4 { + struct Inner { + struct VeryInner { + void f(T*); // expected-error 2{{pointer to a reference}} + }; + }; +}; + +void f2(X4<int&>); // okay, Inner, not instantiated +void f3(X4<int&>::Inner); // okay, Inner::VeryInner, not instantiated + +template struct X4<int&>; // expected-note{{instantiation}} +template struct X4<float&>; // expected-note{{instantiation}} + +// Check explicit instantiation of member classes +namespace N2 { + +template<typename T> +struct X5 { + struct Inner1 { + void f(T&); + }; + + struct Inner2 { + struct VeryInner { + void g(T*); // expected-error 2{{pointer to a reference}} + }; + }; +}; + +} + +template struct N2::X5<void>::Inner2; + +using namespace N2; +template struct X5<int&>::Inner2; // expected-note{{instantiation}} + +void f4(X5<float&>::Inner2); +template struct X5<float&>::Inner2; // expected-note{{instantiation}} + +namespace N3 { + template struct N2::X5<int>::Inner2; +} + +struct X6 { + struct Inner { // expected-note{{here}} + void f(); + }; +}; + +template struct X6::Inner; // expected-error{{non-templated}} |