diff options
Diffstat (limited to 'test/SemaCXX/cxx1y-variable-templates_in_class.cpp')
| -rw-r--r-- | test/SemaCXX/cxx1y-variable-templates_in_class.cpp | 299 |
1 files changed, 299 insertions, 0 deletions
diff --git a/test/SemaCXX/cxx1y-variable-templates_in_class.cpp b/test/SemaCXX/cxx1y-variable-templates_in_class.cpp new file mode 100644 index 0000000..94d0f16 --- /dev/null +++ b/test/SemaCXX/cxx1y-variable-templates_in_class.cpp @@ -0,0 +1,299 @@ +// RUN: %clang_cc1 -verify -fsyntax-only %s -Wno-c++11-extensions -Wno-c++1y-extensions -DPRECXX11 +// RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-c++1y-extensions %s +// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s + +#define CONST const + +#ifdef PRECXX11 +#define static_assert(expr, msg) typedef int static_assert[(expr) ? 1 : -1]; +#endif + +class A { + template<typename T> CONST T wrong; // expected-error {{member 'wrong' declared as a template}} + template<typename T> CONST T wrong_init = 5; // expected-error {{member 'wrong_init' declared as a template}} + template<typename T, typename T0> static CONST T right = T(100); + template<typename T> static CONST T right<T,int> = 5; + template<typename T> CONST int right<int,T>; // expected-error {{member 'right' declared as a template}} + template<typename T> CONST float right<float,T> = 5; // expected-error {{member 'right' declared as a template}} + template<> static CONST int right<int,int> = 7; // expected-error {{explicit specialization of 'right' in class scope}} + template<> static CONST float right<float,int>; // expected-error {{explicit specialization of 'right' in class scope}} + template static CONST int right<int,int>; // expected-error {{template specialization requires 'template<>'}} \ + // expected-error {{explicit specialization of 'right' in class scope}} +}; + +namespace out_of_line { + class B0 { + template<typename T, typename T0> static CONST T right = T(100); + template<typename T> static CONST T right<T,int> = T(5); + }; + template<> CONST int B0::right<int,int> = 7; + template CONST int B0::right<int,int>; + template<> CONST int B0::right<int,float>; + template CONST int B0::right<int,float>; + + class B1 { + template<typename T, typename T0> static CONST T right; + template<typename T> static CONST T right<T,int>; + }; + template<typename T, typename T0> CONST T B1::right = T(100); + template<typename T> CONST T B1::right<T,int> = T(5); + + class B2 { + template<typename T, typename T0> static CONST T right = T(100); // expected-note {{previous definition is here}} + template<typename T> static CONST T right<T,int> = T(5); // expected-note {{previous definition is here}} + }; + template<typename T, typename T0> CONST T B2::right = T(100); // expected-error {{redefinition of 'right'}} + template<typename T> CONST T B2::right<T,int> = T(5); // expected-error {{redefinition of 'right'}} + + class B3 { + template<typename T, typename T0> static CONST T right = T(100); + template<typename T> static CONST T right<T,int> = T(5); + }; + template<typename T, typename T0> CONST T B3::right; + template<typename T> CONST T B3::right<T,int>; + + class B4 { + template<typename T, typename T0> static CONST T a; + template<typename T> static CONST T a<T,int> = T(100); + template<typename T, typename T0> static CONST T b = T(100); + template<typename T> static CONST T b<T,int>; + }; + template<typename T, typename T0> CONST T B4::a; // expected-error {{default initialization of an object of const type 'const int'}} + template<typename T> CONST T B4::a<T,int>; + template CONST int B4::a<int,char>; // expected-note {{in instantiation of}} + template CONST int B4::a<int,int>; + + template<typename T, typename T0> CONST T B4::b; + template<typename T> CONST T B4::b<T,int>; // expected-error {{default initialization of an object of const type 'const int'}} + template CONST int B4::b<int,char>; + template CONST int B4::b<int,int>; // expected-note {{in instantiation of}} +} + +namespace non_const_init { + class A { + template<typename T> static T wrong_inst_undefined = T(10); // expected-note {{refers here}} + template<typename T> static T wrong_inst_defined = T(10); // expected-error {{non-const static data member must be initialized out of line}} + template<typename T> static T wrong_inst_out_of_line; + }; + + template const int A::wrong_inst_undefined<const int>; // expected-error {{undefined}} + + template<typename T> T A::wrong_inst_defined; + template const int A::wrong_inst_defined<const int>; + template int A::wrong_inst_defined<int>; // expected-note {{in instantiation of static data member 'non_const_init::A::wrong_inst_defined<int>' requested here}} + + template<typename T> T A::wrong_inst_out_of_line = T(10); + template int A::wrong_inst_out_of_line<int>; + + class B { + template<typename T> static T wrong_inst; // expected-note {{refers here}} + template<typename T> static T wrong_inst<T*> = T(100); // expected-error {{non-const static data member must be initialized out of line}} expected-note {{refers here}} + + template<typename T> static T wrong_inst_fixed; + template<typename T> static T wrong_inst_fixed<T*>; + }; + template int B::wrong_inst<int>; // expected-error {{undefined}} + // FIXME: It'd be better to produce the 'explicit instantiation of undefined + // template' diagnostic here, not the 'must be initialized out of line' + // diagnostic. + template int B::wrong_inst<int*>; // expected-note {{in instantiation of static data member 'non_const_init::B::wrong_inst<int *>' requested here}} + template const int B::wrong_inst<const int*>; // expected-error {{undefined}} + template<typename T> T B::wrong_inst_fixed = T(100); + template int B::wrong_inst_fixed<int>; + + class C { + template<typename T> static CONST T right_inst = T(10); // expected-note {{here}} + template<typename T> static CONST T right_inst<T*> = T(100); // expected-note {{here}} + }; + template CONST int C::right_inst<int>; // expected-error {{undefined variable template}} + template CONST int C::right_inst<int*>; // expected-error {{undefined variable template}} + + namespace pointers { + + struct C0 { + template<typename U> static U Data; + template<typename U> static CONST U Data<U*> = U(); // expected-note {{here}} + + template<typename U> static U Data2; + template<typename U> static CONST U Data2<U*> = U(); + }; + const int c0_test = C0::Data<int*>; + static_assert(c0_test == 0, ""); + template const int C0::Data<int*>; // expected-error {{undefined}} + + template<typename U> const U C0::Data2<U*>; + template const int C0::Data2<int*>; + + struct C1a { + template<typename U> static U Data; + template<typename U> static U* Data<U*>; // Okay, with out-of-line definition + }; + template<typename T> T* C1a::Data<T*> = new T(); + template int* C1a::Data<int*>; + + struct C1b { + template<typename U> static U Data; + template<typename U> static CONST U* Data<U*>; // Okay, with out-of-line definition + }; + template<typename T> CONST T* C1b::Data<T*> = (T*)(0); + template CONST int* C1b::Data<int*>; + + struct C2a { + template<typename U> static int Data; + template<typename U> static U* Data<U*> = new U(); // expected-error {{non-const static data member must be initialized out of line}} + }; + template int* C2a::Data<int*>; // expected-note {{in instantiation of static data member 'non_const_init::pointers::C2a::Data<int *>' requested here}} + + struct C2b { + template<typename U> static int Data; + template<typename U> static U *const Data<U*> = (U*)(0); // expected-error {{static data member of type 'int *const'}} + }; + template<typename U> U *const C2b::Data<U*>; + template int *const C2b::Data<int*>; // expected-note {{in instantiation of static data member 'non_const_init::pointers::C2b::Data<int *>' requested here}} + } +} + +#ifndef PRECXX11 +namespace constexpred { + class A { + template<typename T> constexpr T wrong; // expected-error {{member 'wrong' declared as a template}} \ + // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}} + template<typename T> constexpr T wrong_init = 5; // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}} + template<typename T, typename T0> static constexpr T right = T(100); + template<typename T> static constexpr T right<T,int> = 5; + template<typename T> constexpr int right<int,T>; // expected-error {{member 'right' declared as a template}} \ + // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}} + template<typename T> constexpr float right<float,T> = 5; // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}} + template<> static constexpr int right<int,int> = 7; // expected-error {{explicit specialization of 'right' in class scope}} + template<> static constexpr float right<float,int>; // expected-error {{explicit specialization of 'right' in class scope}} + template static constexpr int right<int,int>; // expected-error {{template specialization requires 'template<>'}} \ + // expected-error {{explicit specialization of 'right' in class scope}} + }; +} +#endif + +namespace in_class_template { + + template<typename T> + class D0 { + template<typename U> static U Data; // expected-note {{here}} + template<typename U> static CONST U Data<U*> = U(); + }; + template CONST int D0<float>::Data<int*>; + template int D0<float>::Data<int>; // expected-error {{undefined}} + template<typename T> template<typename U> const U D0<T>::Data<U*>; + + template<typename T> + class D1 { + template<typename U> static U Data; + template<typename U> static U* Data<U*>; + }; + template<typename T> + template<typename U> U* D1<T>::Data<U*> = (U*)(0); + template int* D1<float>::Data<int*>; // expected-note {{previous}} + template int* D1<float>::Data<int*>; // expected-error {{duplicate explicit instantiation}} + + template<typename T> + class D2 { + template<typename U> static U Data; + template<typename U> static U* Data<U*>; + }; + template<> + template<typename U> U* D2<float>::Data<U*> = (U*)(0) + 1; + template int* D2<float>::Data<int*>; // expected-note {{previous}} + template int* D2<float>::Data<int*>; // expected-error {{duplicate explicit instantiation}} + + template<typename T> + struct D3 { + template<typename U> static CONST U Data = U(100); // expected-note {{here}} + }; + static_assert(D3<float>::Data<int> == 100, ""); + template const char D3<float>::Data<char>; // expected-error {{undefined}} + + namespace bug_files { + template<typename T> + class D0a { + template<typename U> static U Data; + template<typename U> static CONST U Data<U*> = U(10); // expected-note {{previous definition is here}} + }; + template<> + template<typename U> U D0a<float>::Data<U*> = U(100); // expected-error {{redefinition of 'Data'}} + + // FIXME: We should accept this, and the corresponding case for class + // templates. + // + // [temp.class.spec.mfunc]/2: If the primary member template is explicitly + // specialized for a given specialization of the enclosing class template, + // the partial specializations of the member template are ignored + template<typename T> + class D1 { + template<typename U> static U Data; + template<typename U> static CONST U Data<U*> = U(10); // expected-note {{previous definition is here}} + }; + template<> + template<typename U> U D1<float>::Data = U(10); + template<> + template<typename U> U D1<float>::Data<U*> = U(100); // expected-error{{redefinition of 'Data'}} + } + + namespace definition_after_outer_instantiation { + template<typename A> struct S { + template<typename B> static const int V1; + template<typename B> static const int V2; + }; + template struct S<int>; + template<typename A> template<typename B> const int S<A>::V1 = 123; + template<typename A> template<typename B> const int S<A>::V2<B*> = 456; + + static_assert(S<int>::V1<int> == 123, ""); + + // FIXME: The first and third case below possibly should be accepted. We're + // not picking up partial specializations added after the primary template + // is instantiated. This is kind of implied by [temp.class.spec.mfunc]/2, + // and matches our behavior for member class templates, but it's not clear + // that this is intentional. See PR17294 and core-24030. + static_assert(S<int>::V2<int*> == 456, ""); // FIXME expected-error {{}} + static_assert(S<int>::V2<int&> == 789, ""); // expected-error {{}} + + template<typename A> template<typename B> const int S<A>::V2<B&> = 789; + static_assert(S<int>::V2<int&> == 789, ""); // FIXME expected-error {{}} + + // All is OK if the partial specialization is declared before the implicit + // instantiation of the class template specialization. + static_assert(S<char>::V1<int> == 123, ""); + static_assert(S<char>::V2<int*> == 456, ""); + static_assert(S<char>::V2<int&> == 789, ""); + } + + namespace incomplete_array { + template<typename T> extern T var[]; + template<typename T> T var[] = { 1, 2, 3 }; + template<> char var<char>[] = "hello"; + template<typename T> char var<T*>[] = "pointer"; + + static_assert(sizeof(var<int>) == 12, ""); + static_assert(sizeof(var<char>) == 6, ""); + static_assert(sizeof(var<void*>) == 8, ""); + + template<typename...> struct tuple; + + template<typename T> struct A { + template<typename U> static T x[]; + template<typename U> static T y[]; + + template<typename...U> static T y<tuple<U...> >[]; + }; + + int *use_before_definition = A<int>::x<char>; + template<typename T> template<typename U> T A<T>::x[sizeof(U)]; + static_assert(sizeof(A<int>::x<char>) == 4, ""); + + template<typename T> template<typename...U> T A<T>::y<tuple<U...> >[] = { U()... }; + static_assert(sizeof(A<int>::y<tuple<char, char, char> >) == 12, ""); + } +} + +namespace in_nested_classes { + // TODO: +} + |
