761 lines · cpp
1// RUN: %clang_cc1 -std=c++98 %s -verify=expected,cxx98-14,cxx98 -fexceptions -fcxx-exceptions -pedantic-errors2// RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx11-20,cxx11-17,cxx11-14,cxx98-14,since-cxx11,cxx11 -fexceptions -fcxx-exceptions -pedantic-errors3// RUN: %clang_cc1 -std=c++14 %s -verify=expected,cxx11-20,cxx11-17,cxx11-14,since-cxx14,cxx98-14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors4// RUN: %clang_cc1 -std=c++17 %s -verify=expected,cxx11-20,cxx11-17,since-cxx14,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors5// RUN: %clang_cc1 -std=c++20 %s -verify=expected,cxx11-20,since-cxx14,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors6// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx14,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors7// RUN: %clang_cc1 -std=c++2c %s -verify=expected,since-cxx14,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors8 9__extension__ typedef __SIZE_TYPE__ size_t;10 11namespace std {12 template<typename T> struct initializer_list {13 const T *ptr;14 size_t n;15 initializer_list(const T*, size_t);16 };17} // namespace std18 19namespace cwg1305 { // cwg1305: 3.020#if __cplusplus >= 201103L21struct Incomplete; // #cwg1305-Incomplete22struct Complete {};23 24int incomplete = alignof(Incomplete(&)[]);25// since-cxx11-error@-1 {{invalid application of 'alignof' to an incomplete type 'Incomplete'}}26// since-cxx11-note@#cwg1305-Incomplete {{forward declaration of 'cwg1305::Incomplete'}}27int complete = alignof(Complete(&)[]);28#endif29} // namespace cwg130530 31namespace cwg1307 { // cwg1307: 1432#if __cplusplus >= 201103L33void f(int const (&)[2]);34void f(int const (&)[3]);35 36void caller() {37 // This should not be ambiguous, the 2nd overload is better.38 f({1, 2, 3});39}40#endif // __cplusplus >= 201103L41} // namespace cwg130742 43// cwg1308: sup 133044 45namespace cwg1310 { // cwg1310: 546 struct S {} * sp = new S::S;47 // expected-error@-1 {{qualified reference to 'S' is a constructor name rather than a type in this context}}48 void f() {49 S::S(a);50 // expected-error@-1 {{qualified reference to 'S' is a constructor name rather than a type in this context}}51 }52 struct T { int n; typedef int U; typedef T V; };53 int k = T().T::T::n;54 T::V v;55 56 struct U { int U; };57 int u = U().U::U;58 struct U::U w;59 60 struct V : T::T {61 // FIXME: This is technically ill-formed, but we consider that to be a defect.62 V() : T::T() {}63 };64 template<typename T> struct VT : T::T {65 VT() : T::T() {}66 };67 template struct VT<T>;68 69 template<template<typename> class> class TT {};70 template<typename> class TTy {};71 72 template<typename T> struct WBase {};73 template<typename T> struct W : WBase<T> { typedef int X; int n; };74 75 void w_test() {76 W<int>::W w1a;77 // expected-error@-1 {{qualified reference to 'W' is a constructor name rather than a type in this context}}78 W<int>::W::X w1ax;79 W<int>::W<int> w1b;80 // expected-error@-1 {{qualified reference to 'W' is a constructor name rather than a template name in this context}}81 W<int>::W<int>::X w1bx;82 typename W<int>::W w2a;83 // expected-error@-1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a type in this context, despite preceding 'typename' keyword}}84 // cxx98-error@-2 {{'typename' outside of a template is a C++11 extension}}85 typename W<int>::W::X w2ax;86 // cxx98-error@-1 {{'typename' outside of a template is a C++11 extension}}87 typename W<int>::W<int> w2b;88 // expected-error@-1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a template name in this context, despite preceding 'typename' keyword}}89 // cxx98-error@-2 {{'typename' outside of a template is a C++11 extension}}90 typename W<int>::W<int>::X w2bx;91 // cxx98-error@-1 {{'typename' outside of a template is a C++11 extension}}92 W<int>::template W<int> w3;93 // expected-error@-1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a template name in this context, despite preceding 'template' keyword}}94 // cxx98-error@-2 {{'template' keyword outside of a template}}95 W<int>::template W<int>::X w3x;96 // cxx98-error@-1 {{'template' keyword outside of a template}}97 typename W<int>::template W<int> w4;98 // expected-error@-1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a template name in this context, despite preceding 'template' keyword}}99 // cxx98-error@-2 {{'template' keyword outside of a template}}100 // cxx98-error@-3 {{'typename' outside of a template is a C++11 extension}}101 typename W<int>::template W<int>::X w4x;102 // cxx98-error@-1 {{'template' keyword outside of a template}}103 // cxx98-error@-2 {{'typename' outside of a template is a C++11 extension}}104 105 TT<W<int>::W> tt1;106 // expected-error@-1 {{qualified reference to 'W' is a constructor name rather than a type in this context}}107 TTy<W<int>::W> tt1a;108 // expected-error@-1 {{qualified reference to 'W' is a constructor name rather than a type in this context}}109 TT<W<int>::template W> tt2;110 // expected-error@-1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a template name in this context, despite preceding 'template' keyword}}111 // cxx98-error@-2 {{'template' keyword outside of a template}}112 TT<W<int>::WBase> tt3;113 TTy<W<int>::WBase> tt3a;114 TT<W<int>::template WBase> tt4;115 // cxx98-error@-1 {{'template' keyword outside of a template}}116 117 W<int> w;118 (void)w.W::W::n;119 (void)w.W<int>::W::n;120 (void)w.W<int>::W<int>::n;121 (void)w.W<int>::template W<int>::n;122 // cxx98-error@-1 {{'template' keyword outside of a template}}123 }124 125 template<typename W>126 void wt_test() {127 typename W::W w2a;128 // expected-error@-1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a type in this context, despite preceding 'typename' keyword}}129 // cxx98-note@#cwg1310-W-int {{in instantiation of function template specialization 'cwg1310::wt_test<cwg1310::W<int> >' requested here}}130 // since-cxx11-note@#cwg1310-W-int {{in instantiation of function template specialization 'cwg1310::wt_test<cwg1310::W<int>>' requested here}}131 typename W::template W<int> w4;132 // expected-error@-1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a template name in this context, despite preceding 'template' keyword}}133 TTy<typename W::W> tt2;134 // expected-error@-1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a type in this context, despite preceding 'typename' keyword}}135 TT<W::template W> tt3;136 // expected-error@-1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a template name in this context, despite preceding 'template' keyword}}137 }138 template<typename W>139 void wt_test_good() {140 typename W::W::X w2ax;141 typename W::template W<int>::X w4x;142 TTy<typename W::WBase> tt4;143 TT<W::template WBase> tt5;144 145 W w;146 (void)w.W::W::n;147 (void)w.W::template W<int>::n;148 (void)w.template W<int>::W::n;149 (void)w.template W<int>::template W<int>::n;150 }151 template void wt_test<W<int> >(); // #cwg1310-W-int152 template void wt_test_good<W<int> >();153} // namespace cwg1310154 155namespace cwg1315 { // cwg1315: partial156 template <int I, int J> struct A {};157 template <int I> struct A<I + 5, I * 2> {};158 // expected-error@-1 {{class template partial specialization contains a template parameter that cannot be deduced; this partial specialization will never be used}}159 // expected-note@-2 {{non-deducible template parameter 'I'}}160 template <int I> struct A<I, I> {};161 162 template <int I, int J, int K> struct B;163 template <int I, int K> struct B<I, I * 2, K> {}; // #cwg1315-B-1164 B<1, 2, 3> b1;165 166 // Multiple declarations with the same dependent expression are equivalent167 // for partial ordering purposes.168 template <int I> struct B<I, I * 2, 2> { typedef int type; };169 B<1, 2, 2>::type b2;170 171 // Multiple declarations with differing dependent expressions are unordered.172 template <int I, int K> struct B<I, I + 1, K> {}; // #cwg1315-B-2173 B<1, 2, 4> b3;174 // expected-error@-1 {{ambiguous partial specializations of 'B<1, 2, 4>'}}175 // expected-note@#cwg1315-B-1 {{partial specialization matches [with I = 1, K = 4]}}176 // expected-note@#cwg1315-B-2 {{partial specialization matches [with I = 1, K = 4]}}177 178 // FIXME: Under cwg1315, this is perhaps valid, but that is not clear: this179 // fails the "more specialized than the primary template" test because the180 // dependent type of T::value is not the same as 'int'.181 // A core issue will be opened to decide what is supposed to happen here.182 template <typename T, int I> struct C;183 template <typename T> struct C<T, T::value>;184 // expected-error@-1 {{type of specialized non-type template argument depends on a template parameter of the partial specialization}}185} // namespace cwg1315186 187namespace cwg1330 { // cwg1330: 4 c++11188 // exception-specifications are parsed in a context where the class is complete.189 struct A {190 void f() throw(T) {}191 // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}192 // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}193 struct T {};194 195#if __cplusplus >= 201103L196 void g() noexcept(&a == b) {}197 static int a;198 static constexpr int *b = &a;199#endif200 };201 202 void (A::*af1)() throw(A::T) = &A::f;203 // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}204 // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}205 void (A::*af2)() throw() = &A::f;206 // cxx98-14-error@-1 {{target exception specification is not superset of source}}207 // since-cxx17-error@-2 {{cannot initialize a variable of type 'void (A::*)() throw()' with an rvalue of type 'void (A::*)() throw(T)': different exception specifications}}208 209#if __cplusplus >= 201103L210 static_assert(noexcept(A().g()), "");211#endif212 213 // Likewise, they're instantiated separately from an enclosing class template.214 template<typename U>215 struct B {216 void f() throw(T, typename U::type) {}217 // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}218 // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}219 struct T {};220 221#if __cplusplus >= 201103L222 void g() noexcept(&a == b && U::value) {}223 static int a;224 static constexpr int *b = &a;225#endif226 };227 228 B<int> bi; // ok229 230 struct P {231 typedef int type;232 static const int value = true;233 };234 235 // FIXME: We only delay instantiation in C++11 onwards. In C++98, something236 // weird happens: instantiation of B<P> fails because it references T before237 // it's instantiated, but the diagnostic is suppressed in238 // Sema::FindInstantiatedDecl because we've already hit an error. This is239 // obviously a bad way to react to this situation; we should still producing240 // the "T has not yet been instantiated" error here, rather than giving241 // confusing errors later on.242 void (B<P>::*bpf1)() throw(B<P>::T, int) = &B<P>::f;243 // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}244 // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}245 // cxx98-error@-3 {{target exception specification is not superset of source}}246 247 void (B<P>::*bpf2)() throw(int) = &B<P>::f;248 // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}249 // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}250 // cxx98-14-error@-3 {{target exception specification is not superset of source}}251 // since-cxx17-warning@-4 {{target exception specification is not superset of source}}252 void (B<P>::*bpf3)() = &B<P>::f;253 void (B<P>::*bpf4)() throw() = &B<P>::f;254 // cxx98-14-error@-1 {{target exception specification is not superset of source}}255 // since-cxx17-error@-2 {{cannot initialize a variable of type 'void (B<P>::*)() throw()' with an rvalue of type 'void (B<P>::*)() throw(T, typename cwg1330::P::type)': different exception specifications}}256 257#if __cplusplus >= 201103L258 static_assert(noexcept(B<P>().g()), "");259 struct Q { static const int value = false; };260 static_assert(!noexcept(B<Q>().g()), "");261#endif262 263 template<typename T> int f() throw(typename T::error) { return 0; } // #cwg1330-f264 // expected-error@#cwg1330-f {{type 'int' cannot be used prior to '::' because it has no members}}265 // cxx98-note@#cwg1330-f-int {{in instantiation of function template specialization 'cwg1330::f<int>' requested here}}266 // since-cxx11-note@#cwg1330-f-int {{in instantiation of exception specification for 'f<int>' requested here}}267 // cxx98-14-error@#cwg1330-f {{type 'short' cannot be used prior to '::' because it has no members}}268 // cxx98-14-note@#cwg1330-f-short {{in instantiation of function template specialization 'cwg1330::f<short>' requested here}}269 // cxx11-14-note@#cwg1330-f {{in instantiation of exception specification for 'f<short>' requested here}}270 // since-cxx11-error@#cwg1330-f {{type 'char' cannot be used prior to '::' because it has no members}}271 // since-cxx11-note@#cwg1330-f-char {{in instantiation of exception specification for 'f<char>' requested here}}272 // since-cxx11-error@#cwg1330-f {{type 'float' cannot be used prior to '::' because it has no members}}273 // since-cxx11-note@#cwg1330-f-float {{in instantiation of exception specification for 'f<float>' requested here}}274 // since-cxx17-error@#cwg1330-f {{ISO C++17 does not allow dynamic exception specifications}}275 // since-cxx17-note@#cwg1330-f {{use 'noexcept(false)' instead}}276 277 // An exception-specification is needed even if the function is only used in278 // an unevaluated operand.279 int f1 = sizeof(f<int>()); // #cwg1330-f-int280#if __cplusplus >= 201103L281 decltype(f<char>()) f2; // #cwg1330-f-char282 bool f3 = noexcept(f<float>()); /// #cwg1330-f-float283#endif284 template int f<short>(); // #cwg1330-f-short285 // since-cxx17-error@#cwg1330-f {{type 'short' cannot be used prior to '::' because it has no members}}286 // since-cxx17-note@#cwg1330-f {{in instantiation of exception specification for 'f<short>' requested here}}287 // since-cxx17-note@#cwg1330-f-short {{in instantiation of function template specialization 'cwg1330::f<short>' requested here}}288 289 template<typename T> struct C {290 C() throw(typename T::type); // #cwg1330-C291 // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}292 // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}293 // cxx98-error@#cwg1330-C {{type 'void' cannot be used prior to '::' because it has no members}}294 // cxx98-note@#cwg1330-C-void {{in instantiation of template class 'cwg1330::C<void>' requested here}}295 // expected-error@#cwg1330-C {{type 'int' cannot be used prior to '::' because it has no members}}296 // cxx98-note@#cwg1330-C-int {{in instantiation of template class 'cwg1330::C<int>' requested here}}297 // since-cxx11-note@#cwg1330-C-int {{in instantiation of exception specification for 'C' requested here}}298 // since-cxx11-note@#cwg1330-e {{in evaluation of exception specification for 'cwg1330::E::E' needed here}}299 };300 struct D : C<void> {}; // #cwg1330-C-void301 void f(D &d) { d = d; } // ok302 303 struct E : C<int> {}; // #cwg1330-C-int304 E e; // #cwg1330-e305} // namespace cwg1330306 307// cwg1334: sup 1719308 309namespace cwg1340 { // cwg1340: 2.9310struct A;311struct B;312 313void f(B* a, A B::* p) {314 (*a).*p;315 // expected-warning@-1 {{expression result unused}}316 a->*p;317 // expected-warning@-1 {{expression result unused}}318}319} // namespace cwg1340320 321namespace cwg1341 { // cwg1341: sup P0683R1322#if __cplusplus >= 202002L323int a;324const int b = 0; // #cwg1341-b325struct S {326 int x1 : 8 = 42;327 int x2 : 8 { 42 };328 int y1 : true ? 8 : a = 42;329 int y2 : true ? 8 : b = 42;330 // since-cxx20-error@-1 {{cannot assign to variable 'b' with const-qualified type 'const int'}}331 // since-cxx20-note@#cwg1341-b {{variable 'b' declared const here}}332 int y3 : (true ? 8 : b) = 42;333 int z : 1 || new int { 0 };334};335#endif336} // namespace cwg1341337 338namespace cwg1346 { // cwg1346: 3.5339 auto a(1);340 // cxx98-error@-1 {{'auto' type specifier is a C++11 extension}}341 auto b(1, 2);342 // cxx98-error@-1 {{'auto' type specifier is a C++11 extension}}343 // expected-error@-2 {{initializer for variable 'b' with type 'auto' contains multiple expressions}}344#if __cplusplus >= 201103L345 auto c({});346 // since-cxx11-error@-1 {{cannot deduce type for variable 'c' with type 'auto' from parenthesized initializer list}}347 auto d({1});348 // since-cxx11-error@-1 {{cannot deduce type for variable 'd' with type 'auto' from parenthesized initializer list}}349 auto e({1, 2});350 // since-cxx11-error@-1 {{cannot deduce type for variable 'e' with type 'auto' from parenthesized initializer list}}351#endif352 template<typename...Ts> void f(Ts ...ts) {353 // cxx98-error@-1 {{variadic templates are a C++11 extension}}354 auto x(ts...);355 // cxx98-error@-1 {{'auto' type specifier is a C++11 extension}}356 // expected-error@-2 {{initializer for variable 'x' with type 'auto' is empty}}357 // expected-note@#cwg1346-f {{in instantiation of function template specialization 'cwg1346::f<>' requested here}}358 }359 template void f(); // #cwg1346-f360 361#if __cplusplus >= 201103L362 void init_capture() {363 [a(1)] {} ();364 // cxx11-error@-1 {{initialized lambda captures are a C++14 extension}}365 [b(1, 2)] {} ();366 // cxx11-error@-1 {{initialized lambda captures are a C++14 extension}}367 // since-cxx11-error@-2 {{initializer for lambda capture 'b' contains multiple expressions}}368 [c({})] {} ();369 // cxx11-error@-1 {{initialized lambda captures are a C++14 extension}}370 // since-cxx11-error@-2 {{cannot deduce type for lambda capture 'c' from parenthesized initializer list}}371 [d({1})] {} ();372 // cxx11-error@-1 {{initialized lambda captures are a C++14 extension}}373 // since-cxx11-error@-2 {{cannot deduce type for lambda capture 'd' from parenthesized initializer list}}374 [e({1, 2})] {} ();375 // cxx11-error@-1 {{initialized lambda captures are a C++14 extension}}376 // since-cxx11-error@-2 {{cannot deduce type for lambda capture 'e' from parenthesized initializer list}}377 }378#endif379} // namespace cwg1346380 381namespace cwg1347 { // cwg1347: 3.1382 auto x = 5, *y = &x;383 // cxx98-error@-1 {{'auto' type specifier is a C++11 extension}}384 auto z = y, *q = y;385 // cxx98-error@-1 {{'auto' type specifier is a C++11 extension}}386 // expected-error@-2 {{'auto' deduced as 'int *' in declaration of 'z' and deduced as 'int' in declaration of 'q'}}387#if __cplusplus >= 201103L388 auto a = 5, b = {1, 2};389 // since-cxx11-error@-1 {{'auto' deduced as 'int' in declaration of 'a' and deduced as 'std::initializer_list<int>' in declaration of 'b'}}390 auto (*fp)(int) -> int, i = 0;391 // since-cxx11-error@-1 {{declaration with trailing return type must be the only declaration in its group}}392#endif393} // namespace cwg1347394 395namespace cwg1350 { // cwg1350: 3.5396#if __cplusplus >= 201103L397struct NoexceptCtor {398 NoexceptCtor(int) noexcept {}399};400 401struct ThrowingNSDMI : NoexceptCtor {402 int a = []() noexcept(false) { return 0; }();403 using NoexceptCtor::NoexceptCtor;404};405 406static_assert(!__is_nothrow_constructible(ThrowingNSDMI, int), "");407 408struct ThrowingCtor {409 ThrowingCtor() noexcept(false) {}410};411 412struct ThrowingNSDM : NoexceptCtor {413 ThrowingCtor c;414 using NoexceptCtor::NoexceptCtor;415};416 417static_assert(!__is_nothrow_constructible(ThrowingNSDM, int), "");418 419struct ThrowingCtorTemplate {420 template <typename = int>421 ThrowingCtorTemplate() noexcept(false) {}422};423 424struct ThrowingNSDM2 : NoexceptCtor {425 ThrowingCtorTemplate c;426 using NoexceptCtor::NoexceptCtor;427};428 429static_assert(!__is_nothrow_constructible(ThrowingNSDM2, int), "");430 431struct D1 : NoexceptCtor, ThrowingCtor {432 using NoexceptCtor::NoexceptCtor;433};434 435static_assert(!__is_nothrow_constructible(D1, int), "");436 437struct D2 : NoexceptCtor, ThrowingCtorTemplate {438 using NoexceptCtor::NoexceptCtor;439};440 441static_assert(!__is_nothrow_constructible(D2, int), "");442 443struct ThrowingDefaultArg {444 ThrowingDefaultArg(ThrowingCtor = {}) {}445};446 447struct D3 : NoexceptCtor, ThrowingDefaultArg {448 using NoexceptCtor::NoexceptCtor;449};450 451static_assert(!__is_nothrow_constructible(D3, int), "");452 453struct ThrowingDefaultArgTemplate {454 template <typename = int>455 ThrowingDefaultArgTemplate(ThrowingCtor = {}) {}456};457 458struct D4 : NoexceptCtor, ThrowingDefaultArgTemplate {459 using NoexceptCtor::NoexceptCtor;460};461 462static_assert(!__is_nothrow_constructible(D4, int), "");463#endif464} // namespace cwg1350465 466namespace cwg1352 { // cwg1352: 3.0467struct A {468#if __cplusplus >= 201103L469 int a = sizeof(A);470#endif471 void f(int b = sizeof(A));472};473 474template <typename T>475struct B {476#if __cplusplus >= 201103L477 int a = sizeof(B) + sizeof(T);478#endif479 void f(int b = sizeof(B) + sizeof(T));480};481 482template class B<int>;483} // namespace cwg1352484 485namespace cwg1358 { // cwg1358: 3.1486#if __cplusplus >= 201103L487 struct Lit { constexpr operator int() const { return 0; } };488 struct NonLit { NonLit(); operator int(); }; // #cwg1358-NonLit489 struct NonConstexprConv { constexpr operator int() const; };490 struct Virt { virtual int f(int) const; };491 492 template<typename T, typename U, typename V> struct A : V {493 int member;494 constexpr A(U u) : member(u) {}495 constexpr T f(U u) const { return T(); }496 };497 498 constexpr A<Lit, Lit, Lit> ce = Lit();499 constexpr int k = ce.f(Lit{});500 501 // Can have a non-literal return type and parameter type.502 // Constexpr function can be implicitly virtual.503 A<NonLit, NonLit, Virt> a = NonLit();504 void g() { a.f(NonLit()); }505 506 // Constructor is still constexpr, so this is a literal type.507 static_assert(__is_literal_type(decltype(a)), "");508 509 // Constructor can call non-constexpr functions.510 A<Lit, NonConstexprConv, Lit> b = NonConstexprConv();511 512 // But the corresponding non-template cases are rejected.513 struct B : Virt {514 int member;515 constexpr B(NonLit u) : member(u) {}516 // cxx11-20-error@-1 {{constexpr constructor's 1st parameter type 'NonLit' is not a literal type}}517 // cxx11-20-note@#cwg1358-NonLit {{'NonLit' is not literal because it is not an aggregate and has no constexpr constructors other than copy or move constructors}}518 constexpr NonLit f(NonLit u) const { return NonLit(); }519 // cxx11-20-error@-1 {{constexpr function's return type 'NonLit' is not a literal type}}520 // cxx11-20-note@#cwg1358-NonLit {{'NonLit' is not literal because it is not an aggregate and has no constexpr constructors other than copy or move constructors}}521 };522#endif523} // namespace cwg1358524 525namespace cwg1359 { // cwg1359: 3.5526#if __cplusplus >= 201103L527 union A { constexpr A() = default; };528 union B { constexpr B() = default; int a; }; // #cwg1359-B529 // cxx11-17-error@-1 {{defaulted definition of default constructor cannot be marked constexpr before C++23}}530 union C { constexpr C() = default; int a, b; }; // #cwg1359-C531 // cxx11-17-error@-1 {{defaulted definition of default constructor cannot be marked constexpr}}532 struct X { constexpr X() = default; union {}; };533 // since-cxx11-error@-1 {{declaration does not declare anything}}534 struct Y { constexpr Y() = default; union { int a; }; }; // #cwg1359-Y535 // cxx11-17-error@-1 {{defaulted definition of default constructor cannot be marked constexpr}}536 537 constexpr A a = A();538 constexpr B b = B();539 // cxx11-17-error@-1 {{no matching constructor for initialization of 'B'}}540 // cxx11-17-note@#cwg1359-B {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided}}541 // cxx11-17-note@#cwg1359-B {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided}}542 constexpr C c = C();543 // cxx11-17-error@-1 {{no matching constructor for initialization of 'C'}}544 // cxx11-17-note@#cwg1359-C {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided}}545 // cxx11-17-note@#cwg1359-C {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided}}546 constexpr X x = X();547 constexpr Y y = Y();548 // cxx11-17-error@-1 {{no matching constructor for initialization of 'Y'}}549 // cxx11-17-note@#cwg1359-Y {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided}}550 // cxx11-17-note@#cwg1359-Y {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided}}551#endif552} // namespace cwg1359553 554namespace cwg1388 { // cwg1388: 4555 template<typename A, typename ...T> void f(T..., A); // #cwg1388-f556 // cxx98-error@-1 {{variadic templates are a C++11 extension}}557 template<typename ...T> void g(T..., int); // #cwg1388-g558 // cxx98-error@-1 {{variadic templates are a C++11 extension}}559 template<typename ...T, typename A> void h(T..., A); // #cwg1388-h560 // cxx98-error@-1 {{variadic templates are a C++11 extension}}561 562 void test_f() {563 f(0); // ok, trailing parameter pack deduced to empty564 f(0, 0);565 // expected-error@-1 {{no matching function for call to 'f'}}566 // expected-note@#cwg1388-f {{candidate function [with A = int, T = <>] not viable: requires 1 argument, but 2 were provided}}567 f<int>(0);568 f<int>(0, 0);569 // expected-error@-1 {{no matching function for call to 'f'}}570 // expected-note@#cwg1388-f {{candidate function [with A = int, T = <>] not viable: requires 1 argument, but 2 were provided}}571 f<int, int>(0, 0);572 f<int, int, int>(0, 0);573 // expected-error@-1 {{no matching function for call to 'f'}}574 // expected-note@#cwg1388-f {{candidate function [with A = int, T = <int, int>] not viable: requires 3 arguments, but 2 were provided}}575 576 g(0);577 g(0, 0);578 // expected-error@-1 {{no matching function for call to 'g'}}579 // expected-note@#cwg1388-g {{candidate function [with T = <>] not viable: requires 1 argument, but 2 were provided}}580 g<>(0);581 g<int>(0);582 // expected-error@-1 {{no matching function for call to 'g'}}583 // expected-note@#cwg1388-g {{candidate function [with T = <int>] not viable: requires 2 arguments, but 1 was provided}}584 g<int>(0, 0);585 586 h(0);587 h(0, 0);588 // expected-error@-1 {{no matching function for call to 'h'}}589 // expected-note@#cwg1388-h {{candidate function [with T = <>, A = int] not viable: requires 1 argument, but 2 were provided}}590 h<int>(0, 0);591 h<int, int>(0, 0);592 // expected-error@-1 {{no matching function for call to 'h'}}593 // expected-note@#cwg1388-h {{candidate template ignored: couldn't infer template argument 'A'}}594 }595 596 // A non-trailing parameter pack is still a non-deduced context, even though597 // we know exactly how many arguments correspond to it.598 template<typename T, typename U> struct pair {};599 template<typename ...T> struct tuple { typedef char type; }; //600 // cxx98-error@-1 {{variadic templates are a C++11 extension}}601 template<typename ...T, typename ...U> void f_pair_1(pair<T, U>..., int); // #cwg1388-f-1602 // cxx98-error@-1 {{variadic templates are a C++11 extension}}603 // cxx98-error@-2 {{variadic templates are a C++11 extension}}604 template<typename ...T, typename U> void f_pair_2(pair<T, char>..., U);605 // cxx98-error@-1 {{variadic templates are a C++11 extension}}606 template<typename ...T, typename ...U> void f_pair_3(pair<T, U>..., tuple<U...>); // #cwg1388-f-3607 // cxx98-error@-1 {{variadic templates are a C++11 extension}}608 // cxx98-error@-2 {{variadic templates are a C++11 extension}}609 template<typename ...T> void f_pair_4(pair<T, char>..., T...); // #cwg1388-f-4610 // cxx98-error@-1 {{variadic templates are a C++11 extension}}611 void g(pair<int, char> a, pair<long, char> b, tuple<char, char> c) {612 f_pair_1<int, long>(a, b, 0);613 // expected-error@-1 {{no matching function for call to 'f_pair_1'}}614 // expected-note@#cwg1388-f-1 {{candidate template ignored: substitution failure [with T = <int, long>]: deduced incomplete pack <(no value), (no value)> for template parameter 'U'}}615 f_pair_2<int, long>(a, b, 0);616 f_pair_3<int, long>(a, b, c);617 f_pair_3<int, long>(a, b, tuple<char>());618 // expected-error@-1 {{no matching function for call to 'f_pair_3'}}619 // expected-note@#cwg1388-f-3 {{candidate template ignored: deduced packs of different lengths for parameter 'U' (<(no value), (no value)> vs. <char>)}}620 f_pair_4<int, long>(a, b, 0, 0L);621 f_pair_4<int, long>(a, b, 0, 0L, "foo");622 // expected-error@-1 {{no matching function for call to 'f_pair_4'}}623 // expected-note@#cwg1388-f-4 {{candidate template ignored: deduced packs of different lengths for parameter 'T' (<int, long> vs. <int, long, const char *>)}}624 }625} // namespace cwg1388626 627namespace cwg1391 { // cwg1391: partial628 struct A {}; struct B : A {};629 template<typename T> struct C { C(int); typename T::error error; }; // #cwg1391-C630 // expected-error@#cwg1391-C {{type 'int' cannot be used prior to '::' because it has no members}}631 // expected-note@#cwg1391-b {{in instantiation of template class 'cwg1391::C<int>' requested here}}632 // expected-note@#cwg1391-b {{while substituting deduced template arguments into function template 'b' [with T = int]}}633 // expected-error@#cwg1391-C {{type 'double' cannot be used prior to '::' because it has no members}}634 // expected-note@#cwg1391-c {{in instantiation of template class 'cwg1391::C<double>' requested here}}635 template<typename T> struct D {};636 637 // No deduction is performed for parameters with no deducible template-parameters, therefore types do not need to match.638 template<typename T> void a(T, int T::*);639 void test_a(int A::*p) { a(A(), p); } // ok, type of second parameter does not need to match640 641 namespace dr_example_1 {642 template<typename T, typename U> void f(C<T>);643 template<typename T> void f(D<T>);644 645 void g(D<int> d) {646 f(d); // ok, first 'f' eliminated by deduction failure647 f<int>(d); // ok, first 'f' eliminated because 'U' cannot be deduced648 }649 }650 651 namespace dr_example_2 {652 template<typename T> typename C<T>::error f(int, T);653 template<typename T> T f(T, T);654 655 void g(A a) {656 f(a, a); // ok, no conversion from A to int for first parameter of first candidate657 }658 }659 660 namespace std_example {661 template<typename T> struct Z {662 typedef typename T::x xx;663 };664 template<typename T> typename Z<T>::xx f(void *, T);665 template<typename T> void f(int, T);666 struct A {} a;667 void g() { f(1, a); }668 }669 670 template<typename T> void b(C<int> ci, T *p);671 void b(...);672 void test_b() {673 b(0, 0); // ok, deduction fails prior to forming a conversion sequence and instantiating C<int>674 // FIXME: The "while substituting" note should point at the overload candidate.675 b<int>(0, 0); // #cwg1391-b676 }677 678 template<typename T> struct Id { typedef T type; };679 template<typename T> void c(T, typename Id<C<T> >::type);680 void test_c() {681 // Implicit conversion sequences for dependent types are checked later.682 c(0.0, 0); // #cwg1391-c683 }684 685 namespace partial_ordering {686 // FIXME: Second template should be considered more specialized because non-dependent parameter is ignored.687 template<typename T> int a(T, short) = delete; // #cwg1391-a-short688 // cxx98-error@-1 {{deleted function definitions are a C++11 extension}}689 template<typename T> int a(T*, char); // #cwg1391-a-char690 int test_a = a((int*)0, 0);691 // expected-error@-1 {{call to 'a' is ambiguous}} FIXME692 // expected-note@#cwg1391-a-short {{candidate function [with T = int *] has been explicitly deleted}}693 // expected-note@#cwg1391-a-char {{candidate function [with T = int]}}694 695 // FIXME: Second template should be considered more specialized:696 // deducing #1 from #2 ignores the second P/A pair, so deduction succeeds,697 // deducing #2 from #1 fails to deduce T, so deduction fails.698 template<typename T> int b(T, int) = delete; // #cwg1391-b-int699 // cxx98-error@-1 {{deleted function definitions are a C++11 extension}}700 template<typename T, typename U> int b(T*, U); // #cwg1391-b-U701 int test_b = b((int*)0, 0);702 // expected-error@-1 {{call to 'b' is ambiguous}} FIXME703 // expected-note@#cwg1391-b-int {{candidate function [with T = int *] has been explicitly deleted}}704 // expected-note@#cwg1391-b-U {{candidate function [with T = int, U = int]}}705 706 // Unintended consequences: because partial ordering does not consider707 // explicit template arguments, and deduction from a non-dependent type708 // vacuously succeeds, a non-dependent template is less specialized than709 // anything else!710 // According to CWG1391, this is ambiguous!711 template<typename T> int c(int);712 template<typename T> int c(T);713 int test_c1 = c(0); // ok714 int test_c2 = c<int>(0); // FIXME: apparently ambiguous715 }716} // namespace cwg1391717 718namespace cwg1394 { // cwg1394: 15719#if __cplusplus >= 201103L720struct Incomplete;721Incomplete f(Incomplete) = delete; // well-formed722#endif723} // namespace cwg1394724 725namespace cwg1395 { // cwg1395: 16726#if __cplusplus >= 201103L727 template <typename T, typename... U> void f(T, U...);728 template <typename T> void f(T);729 void h(int i) {730 // This is made ambiguous by cwg692, but made valid again by cwg1395.731 f(&i);732 }733#endif734} // namespace cwg1395735 736namespace cwg1397 { // cwg1397: 3.2737#if __cplusplus >= 201103L738struct A {739// cxx11-error@-1 {{default member initializer for 'p' needed within definition of enclosing class 'A' outside of member functions}}740// cxx11-note@#cwg1397-p {{in evaluation of exception specification for 'cwg1397::A::A' needed here}}741// cxx11-note@#cwg1397-p {{default member initializer declared here}}742 void *p = A{}; // #cwg1397-p743 // since-cxx14-error@-1 {{default member initializer for 'p' needed within definition of enclosing class 'A' outside of member functions}}744 // since-cxx14-note@-2 {{default member initializer declared here}}745 operator void*() const { return nullptr; }746};747#endif748} // namespace cwg1397749 750namespace cwg1399 { // cwg1399: dup 1388751 template<typename ...T> void f(T..., int, T...) {} // #cwg1399-f752 // cxx98-error@-1 {{variadic templates are a C++11 extension}}753 void g() {754 f(0);755 f<int>(0, 0, 0);756 f(0, 0, 0);757 // expected-error@-1 {{no matching function for call to 'f'}}758 // expected-note@#cwg1399-f {{candidate template ignored: deduced packs of different lengths for parameter 'T' (<> vs. <int, int>)}}759 }760} // namespace cwg1399761