1 // RUN: %clang_cc1 -std=c++11 -verify %s
2 
3 namespace UseBeforeDefinition {
4   struct A {
5     template<typename T> static constexpr T get() { return T(); }
6     // ok, not a constant expression.
7     int n = get<int>();
8   };
9 
10   // ok, constant expression.
11   constexpr int j = A::get<int>();
12 
13   template<typename T> constexpr int consume(T);
14   // ok, not a constant expression.
15   const int k = consume(0); // expected-note {{here}}
16 
17   template<typename T> constexpr int consume(T) { return 0; }
18   // ok, constant expression.
19   constexpr int l = consume(0);
20 
21   constexpr int m = k; // expected-error {{constant expression}} expected-note {{initializer of 'k'}}
22 }
23 
24 namespace IntegralConst {
25   template<typename T> constexpr T f(T n) { return n; }
26   enum E {
27     v = f(0), w = f(1) // ok
28   };
29   static_assert(w == 1, "");
30 
31   char arr[f('x')]; // ok
32   static_assert(sizeof(arr) == 'x', "");
33 }
34 
35 namespace ConvertedConst {
36   template<typename T> constexpr T f(T n) { return n; }
37   int f() {
38     switch (f()) {
39       case f(4): return 0;
40     }
41     return 1;
42   }
43 }
44 
45 namespace OverloadResolution {
46   template<typename T> constexpr T f(T t) { return t; }
47 
48   template<int n> struct S { };
49 
50   template<typename T> auto g(T t) -> S<f(sizeof(T))> &;
51   char &f(...);
52 
53   template<typename T> auto h(T t[f(sizeof(T))]) -> decltype(&*t) {
54     return t;
55   }
56 
57   S<4> &k = g(0);
58   int *p, *q = h(p);
59 }
60 
61 namespace DataMember {
62   template<typename T> struct S { static const int k; };
63   const int n = S<int>::k; // expected-note {{here}}
64   template<typename T> const int S<T>::k = 0;
65   constexpr int m = S<int>::k; // ok
66   constexpr int o = n; // expected-error {{constant expression}} expected-note {{initializer of 'n'}}
67 }
68 
69 namespace Reference {
70   const int k = 5;
71   template<typename T> struct S {
72     static volatile int &r;
73   };
74   template<typename T> volatile int &S<T>::r = const_cast<volatile int&>(k);
75   constexpr int n = const_cast<int&>(S<int>::r);
76   static_assert(n == 5, "");
77 }
78 
79 namespace Unevaluated {
80   // We follow the current proposed resolution of core issue 1581: a constexpr
81   // function template specialization requires a definition if:
82   //  * it is odr-used, or would be odr-used except that it appears within the
83   //    definition of a template, or
84   //  * it is used within a braced-init-list, where it may be necessary for
85   //    detecting narrowing conversions.
86   //
87   // We apply this both for instantiating constexpr function template
88   // specializations and for implicitly defining defaulted constexpr special
89   // member functions.
90   //
91   // FIXME: None of this is required by the C++ standard yet. The rules in this
92   //        area are subject to change.
93   namespace NotConstexpr {
94     template<typename T> struct S {
95       S() : n(0) {}
96       S(const S&) : n(T::error) {}
97       int n;
98     };
99     struct U : S<int> {};
100     decltype(U(U())) u;
101   }
102   namespace Constexpr {
103     template<typename T> struct S {
104       constexpr S() : n(0) {}
105       constexpr S(const S&) : n(T::error) {}
106       int n;
107     };
108     struct U : S<int> {};
109     decltype(U(U())) u;
110   }
111   namespace ConstexprList {
112     template<int N> struct S {
113       constexpr S() : n(0) {
114         static_assert(N >= 0, "");
115       }
116       constexpr operator int() const { return 0; }
117       int n;
118     };
119     struct U : S<0> {};
120     // ok, trigger instantiation within a list
121     decltype(char{U()}) t0;
122     decltype(new char{S<1>()}) t1; // expected-warning {{side effects}}
123     decltype((char){S<2>()}) t2;
124     decltype(+(char[1]){{S<3>()}}) t3;
125     // do not trigger instantiation outside a list
126     decltype(char(S<-1>())) u1;
127     decltype(new char(S<-2>())) u2; // expected-warning {{side effects}}
128     decltype((char)(S<-3>())) u3;
129   }
130 
131   namespace PR11851_Comment0 {
132     template<int x> constexpr int f() { return x; }
133     template<int i> void ovf(int (&x)[f<i>()]);
134     void f() { int x[10]; ovf<10>(x); }
135   }
136 
137   namespace PR11851_Comment1 {
138     template<typename T>
139     constexpr bool Integral() {
140       return true;
141     }
142     template<typename T, bool Int = Integral<T>()>
143     struct safe_make_unsigned {
144       typedef T type;
145     };
146     template<typename T>
147     using Make_unsigned = typename safe_make_unsigned<T>::type;
148     template <typename T>
149     struct get_distance_type {
150       using type = int;
151     };
152     template<typename R>
153     auto size(R) -> Make_unsigned<typename get_distance_type<R>::type>;
154     auto check() -> decltype(size(0));
155   }
156 
157   namespace PR11851_Comment6 {
158     template<int> struct foo {};
159     template<class> constexpr int bar() { return 0; }
160     template<class T> foo<bar<T>()> foobar();
161     auto foobar_ = foobar<int>();
162   }
163 
164   namespace PR11851_Comment9 {
165     struct S1 {
166       constexpr S1() {}
167       constexpr operator int() const { return 0; }
168     };
169     int k1 = sizeof(short{S1(S1())});
170 
171     struct S2 {
172       constexpr S2() {}
173       constexpr operator int() const { return 123456; }
174     };
175     int k2 = sizeof(short{S2(S2())}); // expected-error {{cannot be narrowed}} expected-note {{insert an explicit cast to silence this issue}}
176   }
177 
178   namespace PR12288 {
179     template <typename> constexpr bool foo() { return true; }
180     template <bool> struct bar {};
181     template <typename T> bar<foo<T>()> baz() { return bar<foo<T>()>(); }
182     int main() { baz<int>(); }
183   }
184 
185   namespace PR13423 {
186     template<bool, typename> struct enable_if {};
187     template<typename T> struct enable_if<true, T> { using type = T; };
188 
189     template<typename T> struct F {
190       template<typename U>
191       static constexpr bool f() { return sizeof(T) < U::size; }
192 
193       template<typename U>
194       static typename enable_if<f<U>(), void>::type g() {} // expected-note {{requirement 'f<Unevaluated::PR13423::U>()' was not satisfied}}
195     };
196 
197     struct U { static constexpr int size = 2; };
198 
199     void h() { F<char>::g<U>(); }
200     void i() { F<int>::g<U>(); } // expected-error {{no matching function}}
201   }
202 
203   namespace PR14203 {
204     struct duration { constexpr duration() {} };
205 
206     template <typename>
207     void sleep_for() {
208       constexpr duration max = duration();
209     }
210   }
211 
212   // For variables, we instantiate when they are used in a context in which
213   // evaluation could be required (odr-used, used in a template whose
214   // instantiations would odr-use, or used in list initialization), if they
215   // can be used as a constant (const integral or constexpr).
216   namespace Variables {
217     template<int N> struct A {
218       static const int k;
219       static int n;
220     };
221     template<const int *N> struct B {};
222     template <int N> constexpr int A<N>::k = *(int[N]){N}; // expected-error 1+{{negative}} expected-note 1+{{not valid in a constant expression}} expected-note 1+{{declared here}}
223     // expected-error@-1 1+{{must be initialized by a constant expression}}
224 
225     template<int N> int A<N>::n = *(int[N]){0};
226 
227     template <typename> void f() {
228       (void)A<-1>::n; // ok
229       (void)A<-1>::k; // expected-note {{instantiation of }}
230       B<&A<-2>::n> b1; // ok
231       B<&A<-2>::k> b2; // expected-note {{instantiation of }}
232     };
233 
234     decltype(A<-3>::k) d1 = 0; // ok
235     decltype(char{A<-4>::k}) d2 = 0;                    // expected-note 1+{{instantiation of }} expected-error {{narrow}} expected-note {{cast}}
236     decltype(char{A<1>::k}) d3 = 0;                     // expected-note 1+{{instantiation of }} expected-error {{narrow}} expected-note {{cast}}
237     decltype(char{A<1 + (unsigned char)-1>::k}) d4 = 0; // expected-error {{narrow}} expected-note {{cast}}  expected-note {{instantiation of}}
238   }
239 }
240 
241 namespace NoInstantiationWhenSelectingOverload {
242   // Check that we don't instantiate conversion functions when we're checking
243   // for the existence of an implicit conversion sequence, only when a function
244   // is actually chosen by overload resolution.
245   struct S {
246     template<typename T> constexpr S(T) : n(T::error) {} // expected-error {{no members}}
247     int n;
248   };
249 
250   constexpr int f(S) { return 0; }
251   constexpr int f(int) { return 0; }
252 
253   void g() { f(0); }
254   void h() { (void)sizeof(char{f(0)}); }
255   void i() { (void)sizeof(char{f("oops")}); } // expected-note {{instantiation of}}
256 }
257 
258 namespace PR20090 {
259   template <typename T> constexpr T fact(T n) {
260     return n == 0 ? 1 : [=] { return n * fact(n - 1); }();
261   }
262   static_assert(fact(0) == 1, "");
263 }
264