1 // RUN: %clang_cc1 -std=c++98 -verify -fsyntax-only %s -Wno-c++11-extensions -Wno-c++1y-extensions -DPRECXX11
2 // RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-c++1y-extensions %s
3 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s -DCPP1Y
4 
5 #define CONST const
6 
7 #ifdef PRECXX11
8 #define static_assert(expr, msg) typedef int static_assert[(expr) ? 1 : -1];
9 #endif
10 
11 class A {
12   template<typename T> CONST T wrong;           // expected-error {{member 'wrong' declared as a template}}
13   template<typename T> CONST T wrong_init = 5;      // expected-error {{member 'wrong_init' declared as a template}}
14   template<typename T, typename T0> static CONST T right = T(100);
15   template<typename T> static CONST T right<T,int> = 5;
16   template<typename T> CONST int right<int,T>;  // expected-error {{member 'right' declared as a template}}
17   template<typename T> CONST float right<float,T> = 5;  // expected-error {{member 'right' declared as a template}}
18   template<> static CONST int right<int,int> = 7;       // expected-error {{explicit specialization of 'right' in class scope}}
19   template<> static CONST float right<float,int>;       // expected-error {{explicit specialization of 'right' in class scope}}
20   template static CONST int right<int,int>;     // expected-error {{template specialization requires 'template<>'}} \
21                                                 // expected-error {{explicit specialization of 'right' in class scope}}
22 };
23 
24 namespace out_of_line {
25   class B0 {
26     template<typename T, typename T0> static CONST T right = T(100);
27     template<typename T> static CONST T right<T,int> = T(5);
28   };
29   template<> CONST int B0::right<int,int> = 7;
30   template CONST int B0::right<int,int>;
31   template<> CONST int B0::right<int,float>;
32   template CONST int B0::right<int,float>;
33 
34   class B1 {
35     template<typename T, typename T0> static CONST T right;
36     template<typename T> static CONST T right<T,int>;
37   };
38   template<typename T, typename T0> CONST T B1::right = T(100);
39   template<typename T> CONST T B1::right<T,int> = T(5);
40 
41   class B2 {
42     template<typename T, typename T0> static CONST T right = T(100);  // expected-note {{previous initialization is here}}
43     template<typename T> static CONST T right<T,int> = T(5);          // expected-note {{previous initialization is here}}
44   };
45   template<typename T, typename T0> CONST T B2::right = T(100);   // expected-error {{static data member 'right' already has an initializer}}
46   template<typename T> CONST T B2::right<T,int> = T(5);           // expected-error {{static data member 'right' already has an initializer}}
47 
48   class B3 {
49     template<typename T, typename T0> static CONST T right = T(100);
50     template<typename T> static CONST T right<T,int> = T(5);
51   };
52   template<typename T, typename T0> CONST T B3::right;
53   template<typename T> CONST T B3::right<T,int>;
54 
55   class B4 {
56     template<typename T, typename T0> static CONST T a;
57     template<typename T> static CONST T a<T,int> = T(100);
58     template<typename T, typename T0> static CONST T b = T(100);
59     template<typename T> static CONST T b<T,int>;
60   };
61   template<typename T, typename T0> CONST T B4::a; // expected-error {{default initialization of an object of const type 'const int'}}
62   template<typename T> CONST T B4::a<T,int>;
63   template CONST int B4::a<int,char>; // expected-note {{in instantiation of}}
64   template CONST int B4::a<int,int>;
65 
66   template<typename T, typename T0> CONST T B4::b;
67   template<typename T> CONST T B4::b<T,int>; // expected-error {{default initialization of an object of const type 'const int'}}
68   template CONST int B4::b<int,char>;
69   template CONST int B4::b<int,int>; // expected-note {{in instantiation of}}
70 }
71 
72 namespace non_const_init {
73   class A {
74     template<typename T> static T wrong_inst_undefined = T(10); // expected-note {{refers here}}
75     template<typename T> static T wrong_inst_defined = T(10); // expected-error {{non-const static data member must be initialized out of line}}
76     template<typename T> static T wrong_inst_out_of_line;
77   };
78 
79   template const int A::wrong_inst_undefined<const int>; // expected-error {{undefined}}
80 
81   template<typename T> T A::wrong_inst_defined;
82   template const int A::wrong_inst_defined<const int>;
83   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}}
84 
85   template<typename T> T A::wrong_inst_out_of_line = T(10);
86   template int A::wrong_inst_out_of_line<int>;
87 
88   class B {
89     template<typename T> static T wrong_inst; // expected-note {{refers here}}
90     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}}
91 
92     template<typename T> static T wrong_inst_fixed;
93     template<typename T> static T wrong_inst_fixed<T*>;
94   };
95   template int B::wrong_inst<int>; // expected-error {{undefined}}
96   // FIXME: It'd be better to produce the 'explicit instantiation of undefined
97   // template' diagnostic here, not the 'must be initialized out of line'
98   // diagnostic.
99   template int B::wrong_inst<int*>; // expected-note {{in instantiation of static data member 'non_const_init::B::wrong_inst<int *>' requested here}}
100   template const int B::wrong_inst<const int*>; // expected-error {{undefined}}
101   template<typename T> T B::wrong_inst_fixed = T(100);
102   template int B::wrong_inst_fixed<int>;
103 
104   class C {
105     template<typename T> static CONST T right_inst = T(10); // expected-note {{here}}
106     template<typename T> static CONST T right_inst<T*> = T(100); // expected-note {{here}}
107   };
108   template CONST int C::right_inst<int>; // expected-error {{undefined variable template}}
109   template CONST int C::right_inst<int*>; // expected-error {{undefined variable template}}
110 
111   namespace pointers {
112 
113     struct C0 {
114       template<typename U> static U Data;
115       template<typename U> static CONST U Data<U*> = U(); // expected-note {{here}}
116 
117       template<typename U> static U Data2;
118       template<typename U> static CONST U Data2<U*> = U();
119     };
120     const int c0_test = C0::Data<int*>;
121     static_assert(c0_test == 0, "");
122     template const int C0::Data<int*>; // expected-error {{undefined}}
123 
124     template<typename U> const U C0::Data2<U*>;
125     template const int C0::Data2<int*>;
126 
127     struct C1a {
128       template<typename U> static U Data;
129       template<typename U> static U* Data<U*>;   // Okay, with out-of-line definition
130     };
131     template<typename T> T* C1a::Data<T*> = new T();
132     template int* C1a::Data<int*>;
133 
134     struct C1b {
135       template<typename U> static U Data;
136       template<typename U> static CONST U* Data<U*>;   // Okay, with out-of-line definition
137     };
138     template<typename T> CONST T* C1b::Data<T*> = (T*)(0);
139     template CONST int* C1b::Data<int*>;
140 
141     struct C2a {
142       template<typename U> static int Data;
143       template<typename U> static U* Data<U*> = new U();   // expected-error {{non-const static data member must be initialized out of line}}
144     };
145     template int* C2a::Data<int*>; // expected-note {{in instantiation of static data member 'non_const_init::pointers::C2a::Data<int *>' requested here}}
146 
147     struct C2b {
148       template<typename U> static int Data;
149       template<typename U> static U *const Data<U*> = (U*)(0); // expected-error {{static data member of type 'int *const'}}
150     };
151     template<typename U> U *const C2b::Data<U*>;
152     template int *const C2b::Data<int*>; // expected-note {{in instantiation of static data member 'non_const_init::pointers::C2b::Data<int *>' requested here}}
153   }
154 }
155 
156 #ifndef PRECXX11
157 namespace constexpred {
158   class A {
159     template<typename T> constexpr T wrong;           // expected-error {{member 'wrong' declared as a template}} \
160                                                       // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
161     template<typename T> constexpr T wrong_init = 5;      // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}}
162     template<typename T, typename T0> static constexpr T right = T(100);
163     template<typename T> static constexpr T right<T,int> = 5;
164     template<typename T> constexpr int right<int,T>;  // expected-error {{member 'right' declared as a template}} \
165                                                       // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
166     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?}}
167     template<> static constexpr int right<int,int> = 7;       // expected-error {{explicit specialization of 'right' in class scope}}
168     template<> static constexpr float right<float,int>;       // expected-error {{explicit specialization of 'right' in class scope}}
169     template static constexpr int right<int,int>;     // expected-error {{template specialization requires 'template<>'}} \
170                                                   // expected-error {{explicit specialization of 'right' in class scope}}
171   };
172 }
173 #endif
174 
175 namespace in_class_template {
176 
177   template<typename T>
178   class D0 {
179     template<typename U> static U Data; // expected-note {{here}}
180     template<typename U> static CONST U Data<U*> = U();
181   };
182   template CONST int D0<float>::Data<int*>;
183   template int D0<float>::Data<int>; // expected-error {{undefined}}
184   template<typename T> template<typename U> const U D0<T>::Data<U*>;
185 
186   template<typename T>
187   class D1 {
188     template<typename U> static U Data;
189     template<typename U> static U* Data<U*>;
190   };
191   template<typename T>
192   template<typename U> U* D1<T>::Data<U*> = (U*)(0);
193   template int* D1<float>::Data<int*>; // expected-note {{previous}}
194   template int* D1<float>::Data<int*>; // expected-error {{duplicate explicit instantiation}}
195 
196   template<typename T>
197   class D2 {
198     template<typename U> static U Data;
199     template<typename U> static U* Data<U*>;
200   };
201   template<>
202   template<typename U> U* D2<float>::Data<U*> = (U*)(0) + 1;
203   template int* D2<float>::Data<int*>; // expected-note {{previous}}
204   template int* D2<float>::Data<int*>; // expected-error {{duplicate explicit instantiation}}
205 
206   template<typename T>
207   struct D3 {
208     template<typename U> static CONST U Data = U(100); // expected-note {{here}}
209   };
210   static_assert(D3<float>::Data<int> == 100, "");
211   template const char D3<float>::Data<char>; // expected-error {{undefined}}
212 
213   namespace bug_files {
214     template<typename T>
215     class D0a {
216       template<typename U> static U Data;
217       template<typename U> static CONST U Data<U*> = U(10);  // expected-note {{previous declaration is here}}
218     };
219     template<>
220     template<typename U> U D0a<float>::Data<U*> = U(100);  // expected-error {{redefinition of 'Data'}}
221 
222     // FIXME: We should accept this, and the corresponding case for class
223     // templates.
224     //
225     // [temp.class.spec.mfunc]/2: If the primary member template is explicitly
226     // specialized for a given specialization of the enclosing class template,
227     // the partial specializations of the member template are ignored
228     template<typename T>
229     class D1 {
230       template<typename U> static U Data;
231       template<typename U> static CONST U Data<U*> = U(10);  // expected-note {{previous declaration is here}}
232     };
233     template<>
234     template<typename U> U D1<float>::Data = U(10);
235     template<>
236     template<typename U> U D1<float>::Data<U*> = U(100);  // expected-error{{redefinition of 'Data'}}
237   }
238 
239   namespace definition_after_outer_instantiation {
240     template<typename A> struct S {
241       template<typename B> static const int V1;
242       template<typename B> static const int V2;
243     };
244     template struct S<int>;
245     template<typename A> template<typename B> const int S<A>::V1 = 123;
246     template<typename A> template<typename B> const int S<A>::V2<B*> = 456;
247 
248     static_assert(S<int>::V1<int> == 123, "");
249 
250     // FIXME: The first and third case below possibly should be accepted. We're
251     // not picking up partial specializations added after the primary template
252     // is instantiated. This is kind of implied by [temp.class.spec.mfunc]/2,
253     // and matches our behavior for member class templates, but it's not clear
254     // that this is intentional. See PR17294 and core-24030.
255     static_assert(S<int>::V2<int*> == 456, ""); // FIXME expected-error {{}}
256     static_assert(S<int>::V2<int&> == 789, ""); // expected-error {{}}
257 
258     template<typename A> template<typename B> const int S<A>::V2<B&> = 789;
259     static_assert(S<int>::V2<int&> == 789, ""); // FIXME expected-error {{}}
260 
261     // All is OK if the partial specialization is declared before the implicit
262     // instantiation of the class template specialization.
263     static_assert(S<char>::V1<int> == 123, "");
264     static_assert(S<char>::V2<int*> == 456, "");
265     static_assert(S<char>::V2<int&> == 789, "");
266   }
267 
268   namespace incomplete_array {
269     template<typename T> extern T var[];
270     template<typename T> T var[] = { 1, 2, 3 };
271     template<> char var<char>[] = "hello";
272     template<typename T> char var<T*>[] = "pointer";
273 
274     static_assert(sizeof(var<int>) == 12, "");
275     static_assert(sizeof(var<char>) == 6, "");
276     static_assert(sizeof(var<void*>) == 8, "");
277 
278     template<typename...> struct tuple;
279 
280     template<typename T> struct A {
281       template<typename U> static T x[];
282       template<typename U> static T y[];
283 
284       template<typename...U> static T y<tuple<U...> >[];
285     };
286 
287     int *use_before_definition = A<int>::x<char>;
288     template<typename T> template<typename U> T A<T>::x[sizeof(U)];
289     static_assert(sizeof(A<int>::x<char>) == 4, "");
290 
291     template<typename T> template<typename...U> T A<T>::y<tuple<U...> >[] = { U()... };
292     static_assert(sizeof(A<int>::y<tuple<char, char, char> >) == 12, "");
293   }
294 
295   namespace bad_reference {
296     struct S {
297       template<typename T> static int A; // expected-note 4{{here}}
298     };
299 
f()300     template<typename T> void f() {
301       typename T::template A<int> a; // expected-error {{template name refers to non-type template 'S::A'}}
302     }
g()303     template<typename T> void g() {
304       T::template A<int>::B = 0; // expected-error {{template name refers to non-type template 'S::A'}}
305     }
h()306     template<typename T> void h() {
307       class T::template A<int> c; // expected-error {{template name refers to non-type template 'S::A'}}
308     }
309 
310     template<typename T>
311     struct X : T::template A<int> {}; // expected-error {{template name refers to non-type template 'S::A'}}
312 
313     template void f<S>(); // expected-note {{in instantiation of}}
314     template void g<S>(); // expected-note {{in instantiation of}}
315     template void h<S>(); // expected-note {{in instantiation of}}
316     template struct X<S>; // expected-note {{in instantiation of}}
317   }
318 }
319 
320 namespace in_nested_classes {
321   // TODO:
322 }
323 
324 namespace bitfield {
325 struct S {
326   template <int I>
327   static int f : I; // expected-error {{static member 'f' cannot be a bit-field}}
328 };
329 }
330 
331 namespace b20896909 {
332   // This used to crash.
333   template<typename T> struct helper {};
334   template<typename T> class A {
335     template <typename> static helper<typename T::error> x;  // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
336   };
test()337   void test() {
338     A<int> ai;  // expected-note {{in instantiation of}}
339   }
340 }
341 namespace member_access_is_ok {
342 #ifdef CPP1Y
343   namespace ns1 {
344     struct A {
345       template<class T, T N> constexpr static T Var = N;
346     };
347     static_assert(A{}.Var<int,5> == 5,"");
348   } // end ns1
349 #endif // CPP1Y
350 
351 namespace ns2 {
352   template<class T> struct A {
353     template<class U, T N, U M> static T&& Var;
354   };
355   template<class T> template<class U, T N, U M> T&& A<T>::Var = T(N + M);
356   int *AV = &A<int>().Var<char, 5, 'A'>;
357 
358 } //end ns2
359 } // end ns member_access_is_ok
360 
361 #ifdef CPP1Y
362 namespace PR24473 {
363 struct Value
364 {
365     template<class T>
366     static constexpr T value = 0;
367 };
368 
369 template<typename TValue>
370 struct Something
371 {
fooPR24473::Something372     void foo() {
373         static_assert(TValue::template value<int> == 0, ""); // error
374     }
375 };
376 
main()377 int main() {
378     Something<Value>{}.foo();
379     return 0;
380 }
381 
382 } // end ns PR24473
383 #endif // CPP1Y
384 
385