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
|
// RUN: %clang_cc1 -std=c++98 -pedantic-errors -verify=expected,cxx98 %s
// RUN: %clang_cc1 -std=c++11 -pedantic-errors -verify=expected %s
// RUN: %clang_cc1 -std=c++14 -pedantic-errors -verify=expected %s
// RUN: %clang_cc1 -std=c++17 -pedantic-errors -verify=expected %s
// RUN: %clang_cc1 -std=c++20 -pedantic-errors -verify=expected,since-cxx20 %s
// RUN: %clang_cc1 -std=c++23 -pedantic-errors -verify=expected,since-cxx20,since-cxx23 %s
// RUN: %clang_cc1 -std=c++2c -pedantic-errors -verify=expected,since-cxx20,since-cxx23,since-cxx26 %s
namespace cwg2819 { // cwg2819: 19 tentatively ready 2023-12-01
#if __cpp_constexpr >= 202306L
constexpr void* p = nullptr;
constexpr int* q = static_cast<int*>(p);
static_assert(q == nullptr);
#endif
}
namespace cwg2847 { // cwg2847: 19 review 2024-03-01
#if __cplusplus >= 202002L
template<typename>
void i();
struct A {
template<typename>
void f() requires true;
template<>
void f<int>() requires true;
// since-cxx20-error@-1 {{explicit specialization cannot have a trailing requires clause unless it declares a function template}}
friend void i<int>() requires true;
// since-cxx20-error@-1 {{friend specialization cannot have a trailing requires clause unless it declares a function template}}
};
template<typename>
struct B {
void f() requires true;
template<typename>
void g() requires true;
template<typename>
void h() requires true;
template<>
void h<int>() requires true;
// since-cxx20-error@-1 {{explicit specialization cannot have a trailing requires clause unless it declares a function template}}
friend void i<int>() requires true;
// since-cxx20-error@-1 {{friend specialization cannot have a trailing requires clause unless it declares a function template}}
};
template<>
void B<int>::f() requires true;
// since-cxx20-error@-1 {{explicit specialization cannot have a trailing requires clause unless it declares a function template}}
template<>
template<typename T>
void B<int>::g() requires true;
#endif
} // namespace cwg2847
namespace cwg2857 { // cwg2857: no
struct A {};
template <typename>
struct D;
namespace N {
struct B {};
void adl_only(A*, D<int>*); // #cwg2857-adl_only
}
void f(A* a, D<int>* d) {
adl_only(a, d);
// expected-error@-1 {{use of undeclared identifier 'adl_only'; did you mean 'N::adl_only'?}}
// expected-note@#cwg2857-adl_only {{'N::adl_only' declared here}}
}
#if __cplusplus >= 201103L
template <typename>
struct D : N::B {
// FIXME: ADL shouldn't associate it's base B and N since D is not complete here
decltype(adl_only((A*) nullptr, (D*) nullptr)) f;
};
#endif
} // namespace cwg2857
namespace cwg2858 { // cwg2858: 19 tentatively ready 2024-04-05
#if __cplusplus > 202302L
template<typename... Ts>
struct A {
// FIXME: The nested-name-specifier in the following friend declarations are declarative,
// but we don't treat them as such (yet).
friend void Ts...[0]::f();
template<typename U>
friend void Ts...[0]::g();
friend struct Ts...[0]::B;
// FIXME: The index of the pack-index-specifier is printed as a memory address in the diagnostic.
template<typename U>
friend struct Ts...[0]::C;
// expected-warning-re@-1 {{dependent nested name specifier 'Ts...[{{.*}}]::' for friend template declaration is not supported; ignoring this friend declaration}}
};
#endif
} // namespace cwg2858
namespace cwg2877 { // cwg2877: no tentatively ready 2024-05-31
#if __cplusplus >= 202002L
enum E { x };
void f() {
int E;
// FIXME: OK, names ::E
using enum E;
// since-cxx20-error@-1 {{unknown type name E}}
}
using F = E;
using enum F; // OK, designates ::E
template<class T> using EE = T;
void g() {
// FIXME: OK, designates ::E
using enum EE<E>;
// since-cxx20-error@-1 {{using enum requires an enum or typedef name}}
}
#endif
} // namespace cwg2877
namespace cwg2881 { // cwg2881: 19 tentatively ready 2024-04-19
#if __cplusplus >= 202302L
template <typename T> struct A : T {};
template <typename T> struct B : T {};
template <typename T> struct C : virtual T { C(T t) : T(t) {} };
template <typename T> struct D : virtual T { D(T t) : T(t) {} };
template <typename Ts>
struct O1 : A<Ts>, B<Ts> {
using A<Ts>::operator();
using B<Ts>::operator();
};
template <typename Ts> struct O2 : protected Ts { // expected-note {{declared protected here}}
using Ts::operator();
O2(Ts ts) : Ts(ts) {}
};
template <typename Ts> struct O3 : private Ts { // expected-note {{declared private here}}
using Ts::operator();
O3(Ts ts) : Ts(ts) {}
};
// Not ambiguous because of virtual inheritance.
template <typename Ts>
struct O4 : C<Ts>, D<Ts> {
using C<Ts>::operator();
using D<Ts>::operator();
O4(Ts t) : Ts(t), C<Ts>(t), D<Ts>(t) {}
};
// This still has a public path to the lambda, and it's also not
// ambiguous because of virtual inheritance.
template <typename Ts>
struct O5 : private C<Ts>, D<Ts> {
using C<Ts>::operator();
using D<Ts>::operator();
O5(Ts t) : Ts(t), C<Ts>(t), D<Ts>(t) {}
};
// This is only invalid if we call T's call operator.
template <typename T, typename U>
struct O6 : private T, U { // expected-note {{declared private here}}
using T::operator();
using U::operator();
O6(T t, U u) : T(t), U(u) {}
};
void f() {
int x;
auto L1 = [=](this auto&& self) { (void) &x; };
auto L2 = [&](this auto&& self) { (void) &x; };
O1<decltype(L1)>{L1, L1}(); // expected-error {{inaccessible due to ambiguity}}
O1<decltype(L2)>{L2, L2}(); // expected-error {{inaccessible due to ambiguity}}
O2{L1}(); // expected-error {{must derive publicly from the lambda}}
O3{L1}(); // expected-error {{must derive publicly from the lambda}}
O4{L1}();
O5{L1}();
O6 o{L1, L2};
o.decltype(L1)::operator()(); // expected-error {{must derive publicly from the lambda}}
o.decltype(L1)::operator()(); // No error here because we've already diagnosed this method.
o.decltype(L2)::operator()();
}
#endif
} // namespace cwg2881
namespace cwg2882 { // cwg2882: 2.7 tentatively ready 2024-05-31
struct C {
operator void() = delete;
// expected-warning@-1 {{conversion function converting 'cwg2882::C' to 'void' will never be used}}
// cxx98-error@-2 {{deleted function definitions are a C++11 extension}}
};
void f(C c) {
(void)c;
}
} // namespace cwg2882
namespace cwg2883 { // cwg2883: no tentatively ready 2024-05-31
#if __cplusplus >= 201103L
void f() {
int x;
(void)[&] {
return x;
};
}
#endif
#if __cplusplus >= 202002L
struct A {
A() = default;
A(const A &) = delete; // #cwg2883-A-copy-ctor
constexpr operator int() { return 42; }
};
void g() {
constexpr A a;
// FIXME: OK, not odr-usable from a default template argument, and not odr-used
(void)[=]<typename T, int = a> {};
// since-cxx20-error@-1 {{call to deleted constructor of 'const A'}}
// since-cxx20-note@#cwg2883-A-copy-ctor {{'A' has been explicitly marked deleted here}}
}
#endif
} // namespace cwg2883
namespace cwg2885 { // cwg2885: 16 tentatively ready 2024-05-31
#if __cplusplus >= 202002L
template <class T>
struct A {
A() requires (false) = default;
A() : t(42) {}
T t;
};
struct B : A<int> {};
static_assert(!__is_trivially_constructible(B));
#endif
} // namespace cwg2885
namespace cwg2886 { // cwg2886: 9 tentatively ready 2024-05-31
#if __cplusplus >= 201103L
struct C {
C() = default;
~C() noexcept(false) = default;
};
static_assert(noexcept(C()), "");
#endif
} // namespace cwg2886
|
