1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 template<typename T, T Divisor>
3 class X {
4 public:
5   static const T value = 10 / Divisor; // expected-error{{in-class initializer for static data member is not a constant expression}}
6 };
7 
8 int array1[X<int, 2>::value == 5? 1 : -1];
9 X<int, 0> xi0; // expected-note{{in instantiation of template class 'X<int, 0>' requested here}}
10 
11 
12 template<typename T>
13 class Y {
14   static const T value = 0; // expected-warning{{in-class initializer for static data member of type 'const float' is a GNU extension}}
15 };
16 
17 Y<float> fy; // expected-note{{in instantiation of template class 'Y<float>' requested here}}
18 
19 
20 // out-of-line static member variables
21 
22 template<typename T>
23 struct Z {
24   static T value;
25 };
26 
27 template<typename T>
28 T Z<T>::value; // expected-error{{no matching constructor}}
29 
30 struct DefCon {};
31 
32 struct NoDefCon {
33   NoDefCon(const NoDefCon&); // expected-note{{candidate constructor}}
34 };
35 
36 void test() {
37   DefCon &DC = Z<DefCon>::value;
38   NoDefCon &NDC = Z<NoDefCon>::value; // expected-note{{instantiation}}
39 }
40 
41 // PR5609
42 struct X1 {
43   ~X1();  // The errors won't be triggered without this dtor.
44 };
45 
46 template <typename T>
47 struct Y1 {
48   static char Helper(T);
49   static const int value = sizeof(Helper(T()));
50 };
51 
52 struct X2 {
53   virtual ~X2();
54 };
55 
56 namespace std {
57   class type_info { };
58 }
59 
60 template <typename T>
61 struct Y2 {
62   static T &Helper();
63   static const int value = sizeof(typeid(Helper()));
64 };
65 
66 template <int>
67 struct Z1 {};
68 
69 void Test() {
70   Z1<Y1<X1>::value> x;
71   int y[Y1<X1>::value];
72   Z1<Y2<X2>::value> x2;
73   int y2[Y2<X2>::value];
74 }
75 
76 // PR5672
77 template <int n>
78 struct X3 {};
79 
80 class Y3 {
81  public:
82   ~Y3();  // The error isn't triggered without this dtor.
83 
84   void Foo(X3<1>);
85 };
86 
87 template <typename T>
88 struct SizeOf {
89   static const int value = sizeof(T);
90 };
91 
92 void MyTest3() {
93    Y3().Foo(X3<SizeOf<char>::value>());
94 }
95 
96 namespace PR6449 {
97   template<typename T>
98   struct X0  {
99     static const bool var = false;
100   };
101 
102   template<typename T>
103   const bool X0<T>::var;
104 
105   template<typename T>
106   struct X1 : public X0<T> {
107     static const bool var = false;
108   };
109 
110   template<typename T>
111   const bool X1<T>::var;
112 
113   template class X0<char>;
114   template class X1<char>;
115 
116 }
117