1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
| // RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu %s
// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu -std=c++11 %s
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -triple=x86_64-linux-gnu %s -DCPP11ONLY
// C++11 [temp.arg.nontype]p1:
//
// A template-argument for a non-type, non-template template-parameter shall
// be one of:
// -- an integral constant expression; or
// -- the name of a non-type template-parameter ; or
#ifndef CPP11ONLY
namespace non_type_tmpl_param {
template <int N> struct X0 { X0(); };
template <int N> X0<N>::X0() { }
template <int* N> struct X1 { X1(); };
template <int* N> X1<N>::X1() { }
template <int& N> struct X3 { X3(); };
template <int& N> X3<N>::X3() { }
template <int (*F)(int)> struct X4 { X4(); };
template <int (*F)(int)> X4<F>::X4() { }
template <typename T, int (T::* M)(int)> struct X5 { X5(); };
template <typename T, int (T::* M)(int)> X5<T, M>::X5() { }
}
// -- a constant expression that designates the address of an object with
// static storage duration and external or internal linkage or a function
// with external or internal linkage, including function templates and
// function template-ids, but excluting non-static class members, expressed
// (ignoring parentheses) as & id-expression, except that the & may be
// omitted if the name refers to a function or array and shall be omitted
// if the corresopnding template-parameter is a reference; or
namespace addr_of_obj_or_func {
template <int* p> struct X0 { }; // expected-note 5{{here}}
#if __cplusplus >= 201103L
// expected-note@-2 2{{template parameter is declared here}}
#endif
template <int (*fp)(int)> struct X1 { };
template <int &p> struct X2 { }; // expected-note 4{{here}}
template <const int &p> struct X2k { }; // expected-note {{here}}
template <int (&fp)(int)> struct X3 { }; // expected-note 4{{here}}
int i = 42;
#if __cplusplus >= 201103L
// expected-note@-2 {{declared here}}
#endif
int iarr[10];
int f(int i);
const int ki = 9;
#if __cplusplus <= 199711L
// expected-note@-2 5{{non-type template argument refers to object here}}
#endif
__thread int ti = 100; // expected-note {{here}}
#if __cplusplus <= 199711L
// expected-note@-2 {{here}}
#endif
static int f_internal(int);
#if __cplusplus <= 199711L
// expected-note@-2 4{{non-type template argument refers to function here}}
#endif
template <typename T> T f_tmpl(T t);
struct S { union { int NonStaticMember; }; };
void test() {
X0<i> x0a;
#if __cplusplus <= 199711L
// expected-error@-2 {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
#else
// expected-error@-4 {{non-type template argument of type 'int' is not a constant expression}}
// expected-note@-5 {{read of non-const variable 'i' is not allowed in a constant expression}}
#endif
X0<&i> x0a_addr;
X0<iarr> x0b;
X0<&iarr> x0b_addr; // expected-error {{cannot be converted to a value of type 'int *'}}
X0<ki> x0c; // expected-error {{must have its address taken}}
#if __cplusplus <= 199711L
// expected-warning@-2 {{internal linkage is a C++11 extension}}
#endif
X0<&ki> x0c_addr; // expected-error {{cannot be converted to a value of type 'int *'}}
#if __cplusplus <= 199711L
// expected-warning@-2 {{internal linkage is a C++11 extension}}
#endif
X0<&ti> x0d_addr;
#if __cplusplus <= 199711L
// expected-error@-2 {{non-type template argument refers to thread-local object}}
#else
// expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
#endif
X1<f> x1a;
X1<&f> x1a_addr;
X1<f_tmpl> x1b;
X1<&f_tmpl> x1b_addr;
X1<f_tmpl<int> > x1c;
X1<&f_tmpl<int> > x1c_addr;
X1<f_internal> x1d;
#if __cplusplus <= 199711L
// expected-warning@-2 {{internal linkage is a C++11 extension}}
#endif
X1<&f_internal> x1d_addr;
#if __cplusplus <= 199711L
// expected-warning@-2 {{internal linkage is a C++11 extension}}
#endif
X2<i> x2a;
X2<&i> x2a_addr; // expected-error {{address taken}}
X2<iarr> x2b; // expected-error {{cannot bind to template argument of type 'int [10]'}}
X2<&iarr> x2b_addr; // expected-error {{address taken}}
X2<ki> x2c; // expected-error {{ignores qualifiers}}
#if __cplusplus <= 199711L
// expected-warning@-2 {{internal linkage is a C++11 extension}}
#endif
X2k<ki> x2kc;
#if __cplusplus <= 199711L
// expected-warning@-2 {{internal linkage is a C++11 extension}}
#endif
X2k<&ki> x2kc_addr; // expected-error {{address taken}}
#if __cplusplus <= 199711L
// expected-warning@-2 {{internal linkage is a C++11 extension}}
#endif
X2<ti> x2d_addr; // expected-error {{refers to thread-local object}}
X3<f> x3a;
X3<&f> x3a_addr; // expected-error {{address taken}}
X3<f_tmpl> x3b;
X3<&f_tmpl> x3b_addr; // expected-error {{address taken}}
X3<f_tmpl<int> > x3c;
X3<&f_tmpl<int> > x3c_addr; // expected-error {{address taken}}
X3<f_internal> x3d;
#if __cplusplus <= 199711L
// expected-warning@-2 {{internal linkage is a C++11 extension}}
#endif
X3<&f_internal> x3d_addr; // expected-error {{address taken}}
#if __cplusplus <= 199711L
// expected-warning@-2 {{internal linkage is a C++11 extension}}
#endif
int n;
#if __cplusplus <= 199711L
// expected-note@-2 {{non-type template argument refers to object here}}
#else
// expected-note@-4 {{declared here}}
#endif
X0<&n> x0_no_linkage;
#if __cplusplus <= 199711L
// expected-error@-2 {{non-type template argument refers to object 'n' that does not have linkage}}
#else
// expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
// expected-note@-5 {{pointer to 'n' is not a constant expression}}
#endif
struct Local { static int f() {} }; // expected-note {{here}}
X1<&Local::f> x1_no_linkage; // expected-error {{non-type template argument refers to function 'f' that does not have linkage}}
X0<&S::NonStaticMember> x0_non_static; // expected-error {{non-static data member}}
}
}
// -- a constant expression that evaluates to a null pointer value (4.10); or
// -- a constant expression that evaluates to a null member pointer value
// (4.11); or
// -- a pointer to member expressed as described in 5.3.1.
namespace bad_args {
template <int* N> struct X0 { }; // expected-note 2{{template parameter is declared here}}
int i = 42;
X0<&i + 2> x0a; // expected-error{{non-type template argument does not refer to any declaration}}
int* iptr = &i;
#if __cplusplus >= 201103L
// expected-note@-2 {{declared here}}
#endif
X0<iptr> x0b;
#if __cplusplus <= 199711L
// expected-error@-2 {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
#else
// expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
// expected-note@-5 {{read of non-constexpr variable 'iptr' is not allowed in a constant expression}}
#endif
}
#endif // CPP11ONLY
namespace default_args {
#ifdef CPP11ONLY
namespace lambdas {
template<int I = ([] { return 5; }())> //expected-error {{constant expression}}
int f();
}
#endif // CPP11ONLY
}
|