blob: 4a98a1b06c87a8ef0b10edf23853fcfbfb900595 (
plain) (
blame)
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
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
|
// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks %s -fcxx-exceptions
// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -fcxx-exceptions
// RUN: %clang_cc1 -std=c++14 -verify -fsyntax-only -fblocks %s -DCPP14_AND_EARLIER -fcxx-exceptions
namespace test_lambda_is_literal {
#ifdef CPP14_AND_EARLIER
//expected-error@+4{{not a literal type}}
//expected-note@+2{{not an aggregate and has no constexpr constructors}}
#endif
auto L = [] { };
constexpr int foo(decltype(L) l) { return 0; }
}
#ifndef CPP14_AND_EARLIER
namespace test_constexpr_checking {
namespace ns1 {
struct NonLit { ~NonLit(); }; //expected-note{{not literal}}
auto L = [](NonLit NL) constexpr { }; //expected-error{{not a literal type}}
} // end ns1
namespace ns2 {
auto L = [](int I) constexpr { asm("non-constexpr"); }; //expected-error{{not allowed in constexpr function}}
} // end ns1
} // end ns test_constexpr_checking
namespace test_constexpr_call {
namespace ns1 {
auto L = [](int I) { return I; };
static_assert(L(3) == 3);
} // end ns1
namespace ns2 {
auto L = [](auto a) { return a; };
static_assert(L(3) == 3);
static_assert(L(3.14) == 3.14);
}
namespace ns3 {
auto L = [](auto a) { asm("non-constexpr"); return a; }; //expected-note{{declared here}}
constexpr int I = //expected-error{{must be initialized by a constant expression}}
L(3); //expected-note{{non-constexpr function}}
}
} // end ns test_constexpr_call
namespace test_captureless_lambda {
void f() {
const char c = 'c';
auto L = [] { return c; };
constexpr char C = L();
}
void f(char c) { //expected-note{{declared here}}
auto L = [] { return c; }; //expected-error{{cannot be implicitly captured}} expected-note{{lambda expression begins here}}
int I = L();
}
}
namespace test_conversion_function_for_non_capturing_lambdas {
namespace ns1 {
auto L = [](int i) { return i; };
constexpr int (*fpi)(int) = L;
static_assert(fpi(3) == 3);
auto GL = [](auto a) { return a; };
constexpr char (*fp2)(char) = GL;
constexpr double (*fp3)(double) = GL;
constexpr const char* (*fp4)(const char*) = GL;
static_assert(fp2('3') == '3');
static_assert(fp3(3.14) == 3.14);
constexpr const char *Str = "abc";
static_assert(fp4(Str) == Str);
auto NCL = [](int i) { static int j; return j; }; //expected-note{{declared here}}
constexpr int (*fp5)(int) = NCL;
constexpr int I = //expected-error{{must be initialized by a constant expression}}
fp5(5); //expected-note{{non-constexpr function}}
namespace test_dont_always_instantiate_constexpr_templates {
auto explicit_return_type = [](auto x) -> int { return x.get(); };
decltype(explicit_return_type(0)) c; // OK
auto deduced_return_type = [](auto x) { return x.get(); }; //expected-error{{not a structure or union}}
decltype(deduced_return_type(0)) d; //expected-note{{requested here}}
} // end ns test_dont_always_instantiate_constexpr_templates
} // end ns1
} // end ns test_conversion_function_for_non_capturing_lambdas
namespace test_lambda_is_cce {
namespace ns1_simple_lambda {
namespace ns0 {
constexpr int I = [](auto a) { return a; }(10);
static_assert(I == 10);
static_assert(10 == [](auto a) { return a; }(10));
static_assert(3.14 == [](auto a) { return a; }(3.14));
} //end ns0
namespace ns1 {
constexpr auto f(int i) {
double d = 3.14;
auto L = [=](auto a) {
int Isz = sizeof(i);
return sizeof(i) + sizeof(a) + sizeof(d);
};
int I = L("abc") + L(nullptr);
return L;
}
constexpr auto L = f(3);
constexpr auto M = L("abc") + L(nullptr);
static_assert(M == sizeof(int) * 2 + sizeof(double) * 2 + sizeof(nullptr) + sizeof(const char*));
} // end ns1
namespace ns2 {
constexpr auto f(int i) {
auto L = [](auto a) { return a + a; };
return L;
}
constexpr auto L = f(3);
constexpr int I = L(6);
static_assert(I == 12);
} // end ns2
namespace contained_lambdas_call_operator_is_not_constexpr {
constexpr auto f(int i) {
double d = 3.14;
auto L = [=](auto a) { //expected-note{{declared here}}
int Isz = sizeof(i);
asm("hello");
return sizeof(i) + sizeof(a) + sizeof(d);
};
return L;
}
constexpr auto L = f(3);
constexpr auto M = // expected-error{{must be initialized by}}
L("abc"); //expected-note{{non-constexpr function}}
} // end ns contained_lambdas_call_operator_is_not_constexpr
} // end ns1_simple_lambda
namespace test_captures_1 {
namespace ns1 {
constexpr auto f(int i) {
struct S { int x; } s = { i * 2 };
auto L = [=](auto a) {
return i + s.x + a;
};
return L;
}
constexpr auto M = f(3);
static_assert(M(10) == 19);
} // end test_captures_1::ns1
namespace ns2 {
constexpr auto foo(int n) {
auto L = [i = n] (auto N) mutable {
if (!N(i)) throw "error";
return [&i] {
return ++i;
};
};
auto M = L([n](int p) { return p == n; });
M(); M();
L([n](int p) { return p == n + 2; });
return L;
}
constexpr auto L = foo(3);
} // end test_captures_1::ns2
namespace ns3 {
constexpr auto foo(int n) {
auto L = [i = n] (auto N) mutable {
if (!N(i)) throw "error";
return [&i] {
return [i]() mutable {
return ++i;
};
};
};
auto M = L([n](int p) { return p == n; });
M()(); M()();
L([n](int p) { return p == n; });
return L;
}
constexpr auto L = foo(3);
} // end test_captures_1::ns3
namespace ns2_capture_this_byval {
struct S {
int s;
constexpr S(int s) : s{s} { }
constexpr auto f(S o) {
return [*this,o] (auto a) { return s + o.s + a.s; };
}
};
constexpr auto L = S{5}.f(S{10});
static_assert(L(S{100}) == 115);
} // end test_captures_1::ns2_capture_this_byval
namespace ns2_capture_this_byref {
struct S {
int s;
constexpr S(int s) : s{s} { }
constexpr auto f() const {
return [this] { return s; };
}
};
constexpr S SObj{5};
constexpr auto L = SObj.f();
constexpr int I = L();
static_assert(I == 5);
} // end ns2_capture_this_byref
} // end test_captures_1
namespace test_capture_array {
namespace ns1 {
constexpr auto f(int I) {
int arr[] = { I, I *2, I * 3 };
auto L1 = [&] (auto a) { return arr[a]; };
int r = L1(2);
struct X { int x, y; };
return [=](auto a) { return X{arr[a],r}; };
}
constexpr auto L = f(3);
static_assert(L(0).x == 3);
static_assert(L(0).y == 9);
static_assert(L(1).x == 6);
static_assert(L(1).y == 9);
} // end ns1
} // end test_capture_array
namespace ns1_test_lvalue_type {
void f() {
volatile int n;
constexpr bool B = [&]{ return &n; }() == &n; // should be accepted
}
} // end ns1_unimplemented
} // end ns test_lambda_is_cce
#endif // ndef CPP14_AND_EARLIER
|
