[clang] 76ee344 - [clang][NFC] Refactor expected directives in C++ DRs 700-1999 (#74767)
via cfe-commits
cfe-commits at lists.llvm.org
Fri Dec 8 00:11:02 PST 2023
Author: Vlad Serebrennikov
Date: 2023-12-08T12:10:57+04:00
New Revision: 76ee3447699c032237517a64a8eeead5e94faf7e
URL: https://github.com/llvm/llvm-project/commit/76ee3447699c032237517a64a8eeead5e94faf7e
DIFF: https://github.com/llvm/llvm-project/commit/76ee3447699c032237517a64a8eeead5e94faf7e.diff
LOG: [clang][NFC] Refactor expected directives in C++ DRs 700-1999 (#74767)
This patch continues the work started with ea5b1ef016d020c37f903d6c7d4f623be975dab8. See that commit and its
corresponding PR for details.
Added:
Modified:
clang/test/CXX/drs/dr10xx.cpp
clang/test/CXX/drs/dr11xx.cpp
clang/test/CXX/drs/dr12xx.cpp
clang/test/CXX/drs/dr13xx.cpp
clang/test/CXX/drs/dr14xx.cpp
clang/test/CXX/drs/dr15xx.cpp
clang/test/CXX/drs/dr16xx.cpp
clang/test/CXX/drs/dr17xx.cpp
clang/test/CXX/drs/dr18xx.cpp
clang/test/CXX/drs/dr19xx.cpp
clang/test/CXX/drs/dr412.cpp
clang/test/CXX/drs/dr7xx.cpp
clang/test/CXX/drs/dr8xx.cpp
clang/test/CXX/drs/dr9xx.cpp
Removed:
################################################################################
diff --git a/clang/test/CXX/drs/dr10xx.cpp b/clang/test/CXX/drs/dr10xx.cpp
index f30ed1cb3e4967..77c59078414c69 100644
--- a/clang/test/CXX/drs/dr10xx.cpp
+++ b/clang/test/CXX/drs/dr10xx.cpp
@@ -1,9 +1,9 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,since-cxx14 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,since-cxx14 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx14 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx14 -fexceptions -fcxx-exceptions -pedantic-errors
namespace std {
__extension__ typedef __SIZE_TYPE__ size_t;
@@ -18,30 +18,40 @@ namespace dr1004 { // dr1004: 5
template<typename> struct A {};
template<typename> struct B1 {};
template<template<typename> class> struct B2 {};
- template<typename X> void f(); // expected-note {{[with X = dr1004::A<int>]}}
- template<template<typename> class X> void f(); // expected-note {{[with X = dr1004::A]}}
- template<template<typename> class X> void g(); // expected-note {{[with X = dr1004::A]}}
- template<typename X> void g(); // expected-note {{[with X = dr1004::A<int>]}}
+ template<typename X> void f(); // #dr1004-f-1
+ template<template<typename> class X> void f(); // #dr1004-f-2
+ template<template<typename> class X> void g(); // #dr1004-g-1
+ template<typename X> void g(); // #dr1004-g-2
struct C : A<int> {
B1<A> b1a;
B2<A> b2a;
void h() {
- f<A>(); // expected-error {{ambiguous}}
- g<A>(); // expected-error {{ambiguous}}
+ f<A>();
+ // expected-error at -1 {{call to 'f' is ambiguous}}
+ // expected-note@#dr1004-f-1 {{candidate function [with X = dr1004::A<int>]}}
+ // expected-note@#dr1004-f-2 {{candidate function [with X = dr1004::A]}}
+ g<A>();
+ // expected-error at -1 {{call to 'g' is ambiguous}}
+ // expected-note@#dr1004-g-1 {{candidate function [with X = dr1004::A]}}
+ // expected-note@#dr1004-g-2 {{candidate function [with X = dr1004::A<int>]}}
}
};
// This example (from the standard) is actually ill-formed, because
// name lookup of "T::template A" names the constructor.
- template<class T, template<class> class U = T::template A> struct Third { }; // expected-error {{is a constructor name}}
- Third<A<int> > t; // expected-note {{in instantiation of default argument}}
+ template<class T, template<class> class U = T::template A> struct Third { };
+ // expected-error at -1 {{is a constructor name}}
+ // expected-note@#dr1004-t {{in instantiation of default argument}}
+ Third<A<int> > t; // #dr1004-t
}
namespace dr1042 { // dr1042: 3.5
#if __cplusplus >= 201402L
// C++14 added an attribute that we can test the semantics of.
- using foo [[deprecated]] = int; // expected-note {{'foo' has been explicitly marked deprecated here}}
- foo f = 12; // expected-warning {{'foo' is deprecated}}
+ using foo [[deprecated]] = int; // #dr1042-using
+ foo f = 12;
+ // since-cxx14-warning at -1 {{'foo' is deprecated}}
+ // since-cxx14-note@#dr1042-using {{'foo' has been explicitly marked deprecated here}}
#elif __cplusplus >= 201103L
// C++11 did not have any attributes that could be applied to an alias
// declaration, so the best we can test is that we accept an empty attribute
@@ -76,7 +86,8 @@ namespace dr1054 { // dr1054: no
// which copy-initializes a temporary from 'a'. Therefore this is
// ill-formed because A does not have a volatile copy constructor.
// (We might want to track this aspect under dr1383 instead?)
- a; // expected-warning {{assign into a variable to force a volatile load}}
+ a;
+ // expected-warning at -1 {{expression result unused; assign into a variable to force a volatile load}}
}
}
diff --git a/clang/test/CXX/drs/dr11xx.cpp b/clang/test/CXX/drs/dr11xx.cpp
index 2e35535a18c4a7..86e726ae8c7419 100644
--- a/clang/test/CXX/drs/dr11xx.cpp
+++ b/clang/test/CXX/drs/dr11xx.cpp
@@ -1,30 +1,30 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected,cxx98 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2a %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr1111 { // dr1111: 3.2
namespace example1 {
-template <typename> struct set;
+template <typename> struct set; // #dr1111-struct-set
struct X {
- template <typename T> void set(const T &value);
+ template <typename T> void set(const T &value); // #dr1111-func-set
};
void foo() {
X x;
-#pragma clang diagnostic push
-#if __cplusplus < 201103L
-#pragma clang diagnostic ignored "-Wambiguous-member-template"
-#endif
+ // FIXME: should we backport C++11 behavior?
x.set<double>(3.2);
-#pragma clang diagnostic pop
+ // cxx98-error at -1 {{lookup of 'set' in member access expression is ambiguous; using member of 'X'}}
+ // cxx98-note@#dr1111-func-set {{lookup in the object type 'X' refers here}}
+ // cxx98-note@#dr1111-struct-set {{lookup from the current scope refers here}}
}
struct Y {};
void bar() {
Y y;
- y.set<double>(3.2); // expected-error {{no member named 'set' in 'dr1111::example1::Y'}}
+ y.set<double>(3.2);
+ // expected-error at -1 {{no member named 'set' in 'dr1111::example1::Y'}}
}
} // namespace example1
@@ -46,8 +46,10 @@ void baz() {
namespace dr1113 { // dr1113: partial
namespace named {
- extern int a; // expected-note {{previous}}
- static int a; // expected-error {{static declaration of 'a' follows non-static}}
+ extern int a; // #dr1113-a
+ static int a;
+ // expected-error at -1 {{static declaration of 'a' follows non-static}}
+ // expected-note@#dr1113-a {{previous declaration is here}}
}
namespace {
extern int a;
diff --git a/clang/test/CXX/drs/dr12xx.cpp b/clang/test/CXX/drs/dr12xx.cpp
index 339712be45b388..adf7f56711c451 100644
--- a/clang/test/CXX/drs/dr12xx.cpp
+++ b/clang/test/CXX/drs/dr12xx.cpp
@@ -1,9 +1,9 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected,cxx98-14,cxx98 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx98-14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,cxx98-14,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,since-cxx17,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx17,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx17,since-cxx14,since-cxx11,since-cxx23 -fexceptions -fcxx-exceptions -pedantic-errors
// dr1200: na
@@ -40,28 +40,33 @@ struct S {
S* operator()();
int N;
int M;
-#if __cplusplus > 202002L
+#if __cplusplus >= 202302L
template <typename T>
static constexpr auto V = 0;
void f(char);
void f(int);
void mem(S s) {
- auto(s)()->M; //expected-warning {{expression result unused}}
- auto(s)()->V<int>; //expected-warning {{expression result unused}}
+ auto(s)()->M;
+ // since-cxx23-warning at -1 {{expression result unused}}
+ auto(s)()->V<int>;
+ // since-cxx23-warning at -1 {{expression result unused}}
auto(s)()->f(0);
}
#endif
};
void f(S s) {
{
-#if __cplusplus > 202002L
- auto(s)()->N; //expected-warning {{expression result unused}}
+#if __cplusplus >= 202302L
+ auto(s)()->N;
+ //since-cxx23-warning at -1 {{expression result unused}}
#endif
auto(s)()->M;
}
{
- S(s)()->N; //expected-warning {{expression result unused}}
- S(s)()->M; //expected-warning {{expression result unused}}
+ S(s)()->N;
+ // since-cxx11-warning at -1 {{expression result unused}}
+ S(s)()->M;
+ // since-cxx11-warning at -1 {{expression result unused}}
}
}
@@ -74,7 +79,8 @@ void g() {
A a(B ()->C);
A b(auto ()->C);
static_assert(sizeof(B ()->C[1] == sizeof(int)), "");
- sizeof(auto () -> C[1]); // expected-error{{function cannot return array type 'C[1]'}}
+ sizeof(auto () -> C[1]);
+ // since-cxx11-error at -1 {{function cannot return array type 'C[1]' (aka 'dr1223::BB[1]')}}
}
}
@@ -82,15 +88,18 @@ void g() {
#if __cplusplus >= 201103L
namespace dr1227 { // dr1227: 3.0
-template <class T> struct A { using X = typename T::X; }; // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
+template <class T> struct A { using X = typename T::X; };
+// since-cxx11-error at -1 {{type 'int' cannot be used prior to '::' because it has no members}}
+// since-cxx11-note@#dr1227-g {{in instantiation of template class 'dr1227::A<int>' requested here}}
+// since-cxx11-note@#dr1227-g-int {{while substituting explicitly-specified template arguments into function template 'g'}}
template <class T> typename T::X f(typename A<T>::X);
template <class T> void f(...) { }
-template <class T> auto g(typename A<T>::X) -> typename T::X; // expected-note {{in instantiation of template class 'dr1227::A<int>' requested here}}
+template <class T> auto g(typename A<T>::X) -> typename T::X; // #dr1227-g
template <class T> void g(...) { }
void h() {
f<int>(0); // OK, substituting return type causes deduction to fail
- g<int>(0); // expected-note {{while substituting explicitly-specified template arguments into function template 'g'}}
+ g<int>(0); // #dr1227-g-int
}
}
#endif
@@ -109,15 +118,21 @@ struct Derived : Base {
namespace dr1265 { // dr1265: 5
#if __cplusplus >= 201103L
- auto a = 0, b() -> int; // expected-error {{declaration with trailing return type must be the only declaration in its group}}
- auto b() -> int, d = 0; // expected-error {{declaration with trailing return type must be the only declaration in its group}}
- auto e() -> int, f() -> int; // expected-error {{declaration with trailing return type must be the only declaration in its group}}
+ auto a = 0, b() -> int;
+ // since-cxx11-error at -1 {{declaration with trailing return type must be the only declaration in its group}}
+ auto b() -> int, d = 0;
+ // since-cxx11-error at -1 {{declaration with trailing return type must be the only declaration in its group}}
+ auto e() -> int, f() -> int;
+ // since-cxx11-error at -1 {{declaration with trailing return type must be the only declaration in its group}}
#endif
#if __cplusplus >= 201402L
- auto g(), h = 0; // expected-error {{function with deduced return type must be the only declaration in its group}}
- auto i = 0, j(); // expected-error {{function with deduced return type must be the only declaration in its group}}
- auto k(), l(); // expected-error {{function with deduced return type must be the only declaration in its group}}
+ auto g(), h = 0;
+ // since-cxx14-error at -1 {{function with deduced return type must be the only declaration in its group}}
+ auto i = 0, j();
+ // since-cxx14-error at -1 {{function with deduced return type must be the only declaration in its group}}
+ auto k(), l();
+ // since-cxx14-error at -1 {{function with deduced return type must be the only declaration in its group}}
#endif
}
@@ -130,16 +145,16 @@ namespace dr1295 { // dr1295: 4
X x = {1};
- unsigned const &r1 = static_cast<X &&>(x).bitfield; // expected-error 0-1{{C++11}}
- unsigned const &r2 = static_cast<unsigned &&>(x.bitfield); // expected-error 0-1{{C++11}}
+ unsigned const &r1 = static_cast<X &&>(x).bitfield;
+ // cxx98-error at -1 {{rvalue references are a C++11 extension}}
+ unsigned const &r2 = static_cast<unsigned &&>(x.bitfield);
+ // cxx98-error at -1 {{rvalue references are a C++11 extension}}
- template<unsigned &r> struct Y {};
- Y<x.bitfield> y;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{does not refer to any declaration}} expected-note at -3 {{here}}
-#else
- // expected-error at -4 {{refers to subobject}}
-#endif
+ template<unsigned &r> struct Y {}; // #dr1295-Y
+ Y<x.bitfield> y; // #dr1295-y
+ // cxx98-14-error at -1 {{non-type template argument does not refer to any declaration}}
+ // cxx98-14-note@#dr1295-Y {{template parameter is declared here}}
+ // since-cxx17-error@#dr1295-y {{non-type template argument refers to subobject 'x.bitfield'}}
#if __cplusplus >= 201103L
const unsigned other = 0;
diff --git a/clang/test/CXX/drs/dr13xx.cpp b/clang/test/CXX/drs/dr13xx.cpp
index abee1009616025..359c04b3e0f3d4 100644
--- a/clang/test/CXX/drs/dr13xx.cpp
+++ b/clang/test/CXX/drs/dr13xx.cpp
@@ -1,7 +1,10 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected,cxx98-14,cxx98 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx11-17,cxx11-14,cxx98-14,since-cxx11,cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,cxx11-17,cxx11-14,since-cxx14,cxx98-14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,cxx11-17,since-cxx14,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx14,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx14,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2c %s -verify=expected,since-cxx14,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
__extension__ typedef __SIZE_TYPE__ size_t;
@@ -15,10 +18,12 @@ namespace std {
#if __cplusplus >= 201103L
namespace dr1305 { // dr1305: 3.0
-struct Incomplete; // expected-note {{forward declaration of 'dr1305::Incomplete'}}
+struct Incomplete; // #dr1305-Incomplete
struct Complete {};
-int incomplete = alignof(Incomplete(&)[]); // expected-error {{invalid application of 'alignof' to an incomplete type 'Incomplete'}}
+int incomplete = alignof(Incomplete(&)[]);
+// since-cxx11-error at -1 {{invalid application of 'alignof' to an incomplete type 'Incomplete'}}
+// since-cxx11-note@#dr1305-Incomplete {{forward declaration of 'dr1305::Incomplete'}}
int complete = alignof(Complete(&)[]);
}
#endif
@@ -36,9 +41,11 @@ void caller() {
} // namespace dr1307
namespace dr1310 { // dr1310: 5
- struct S {} * sp = new S::S; // expected-error {{qualified reference to 'S' is a constructor name}}
+ struct S {} * sp = new S::S;
+ // expected-error at -1 {{qualified reference to 'S' is a constructor name rather than a type in this context}}
void f() {
- S::S(a); // expected-error {{qualified reference to 'S' is a constructor name}}
+ S::S(a);
+ // expected-error at -1 {{qualified reference to 'S' is a constructor name rather than a type in this context}}
}
struct T { int n; typedef int U; typedef T V; };
int k = T().T::T::n;
@@ -64,39 +71,67 @@ namespace dr1310 { // dr1310: 5
template<typename T> struct W : WBase<T> { typedef int X; int n; };
void w_test() {
- W<int>::W w1a; // expected-error {{qualified reference to 'W' is a constructor name}}
+ W<int>::W w1a;
+ // expected-error at -1 {{qualified reference to 'W' is a constructor name rather than a type in this context}}
W<int>::W::X w1ax;
- W<int>::W<int> w1b; // expected-error {{qualified reference to 'W' is a constructor name}}
+ W<int>::W<int> w1b;
+ // expected-error at -1 {{qualified reference to 'W' is a constructor name rather than a template name in this context}}
W<int>::W<int>::X w1bx;
- typename W<int>::W w2a; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-1{{outside of a template}}
- typename W<int>::W::X w2ax; // expected-error 0-1{{outside of a template}}
- typename W<int>::W<int> w2b; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-1{{outside of a template}}
- typename W<int>::W<int>::X w2bx; // expected-error 0-1{{outside of a template}}
- W<int>::template W<int> w3; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-1{{outside of a template}}
- W<int>::template W<int>::X w3x; // expected-error 0-1{{outside of a template}}
- typename W<int>::template W<int> w4; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-2{{outside of a template}}
- typename W<int>::template W<int>::X w4x; // expected-error 0-2{{outside of a template}}
-
- TT<W<int>::W> tt1; // expected-error {{qualified reference to 'W' is a constructor name}}
- TTy<W<int>::W> tt1a; // expected-error {{qualified reference to 'W' is a constructor name}}
- TT<W<int>::template W> tt2; // expected-error {{qualified reference to 'W' is a constructor name}} expected-error 0-1{{outside of a template}}
+ typename W<int>::W w2a;
+ // expected-error at -1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a type in this context, despite preceding 'typename' keyword}}
+ // cxx98-error at -2 {{'typename' occurs outside of a template}}
+ typename W<int>::W::X w2ax;
+ // cxx98-error at -1 {{'typename' occurs outside of a template}}
+ typename W<int>::W<int> w2b;
+ // expected-error at -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}}
+ // cxx98-error at -2 {{'typename' occurs outside of a template}}
+ typename W<int>::W<int>::X w2bx;
+ // cxx98-error at -1 {{'typename' occurs outside of a template}}
+ W<int>::template W<int> w3;
+ // expected-error at -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}}
+ // cxx98-error at -2 {{'template' keyword outside of a template}}
+ W<int>::template W<int>::X w3x;
+ // cxx98-error at -1 {{'template' keyword outside of a template}}
+ typename W<int>::template W<int> w4;
+ // expected-error at -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}}
+ // cxx98-error at -2 {{'template' keyword outside of a template}}
+ // cxx98-error at -3 {{'typename' occurs outside of a template}}
+ typename W<int>::template W<int>::X w4x;
+ // cxx98-error at -1 {{'template' keyword outside of a template}}
+ // cxx98-error at -2 {{'typename' occurs outside of a template}}
+
+ TT<W<int>::W> tt1;
+ // expected-error at -1 {{qualified reference to 'W' is a constructor name rather than a type in this context}}
+ TTy<W<int>::W> tt1a;
+ // expected-error at -1 {{qualified reference to 'W' is a constructor name rather than a type in this context}}
+ TT<W<int>::template W> tt2;
+ // expected-error at -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}}
+ // cxx98-error at -2 {{'template' keyword outside of a template}}
TT<W<int>::WBase> tt3;
TTy<W<int>::WBase> tt3a;
- TT<W<int>::template WBase> tt4; // expected-error 0-1{{outside of a template}}
+ TT<W<int>::template WBase> tt4;
+ // cxx98-error at -1 {{'template' keyword outside of a template}}
W<int> w;
(void)w.W::W::n;
(void)w.W<int>::W::n;
(void)w.W<int>::W<int>::n;
- (void)w.W<int>::template W<int>::n; // expected-error 0-1{{outside of a template}}
+ (void)w.W<int>::template W<int>::n;
+ // cxx98-error at -1 {{'template' keyword outside of a template}}
}
template<typename W>
void wt_test() {
- typename W::W w2a; // expected-error {{qualified reference to 'W' is a constructor name}}
- typename W::template W<int> w4; // expected-error {{qualified reference to 'W' is a constructor name}}
- TTy<typename W::W> tt2; // expected-error {{qualified reference to 'W' is a constructor name}}
- TT<W::template W> tt3; // expected-error {{qualified reference to 'W' is a constructor name}}
+ typename W::W w2a;
+ // expected-error at -1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a type in this context, despite preceding 'typename' keyword}}
+ // cxx98-note@#dr1310-W-int {{in instantiation of function template specialization 'dr1310::wt_test<dr1310::W<int> >' requested here}}
+ // since-cxx11-note@#dr1310-W-int {{in instantiation of function template specialization 'dr1310::wt_test<dr1310::W<int>>' requested here}}
+ typename W::template W<int> w4;
+ // expected-error at -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}}
+ TTy<typename W::W> tt2;
+ // expected-error at -1 {{ISO C++ specifies that qualified reference to 'W' is a constructor name rather than a type in this context, despite preceding 'typename' keyword}}
+ TT<W::template W> tt3;
+ // expected-error at -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}}
}
template<typename W>
void wt_test_good() {
@@ -111,18 +146,19 @@ namespace dr1310 { // dr1310: 5
(void)w.template W<int>::W::n;
(void)w.template W<int>::template W<int>::n;
}
- template void wt_test<W<int> >(); // expected-note {{instantiation of}}
+ template void wt_test<W<int> >(); // #dr1310-W-int
template void wt_test_good<W<int> >();
}
namespace dr1315 { // dr1315: partial
template <int I, int J> struct A {};
- template <int I> // expected-note {{non-deducible template parameter 'I'}}
- struct A<I + 5, I * 2> {}; // expected-error {{contains a template parameter that cannot be deduced}}
+ template <int I> struct A<I + 5, I * 2> {};
+ // expected-error at -1 {{class template partial specialization contains a template parameter that cannot be deduced; this partial specialization will never be used}}
+ // expected-note at -2 {{non-deducible template parameter 'I'}}
template <int I> struct A<I, I> {};
template <int I, int J, int K> struct B;
- template <int I, int K> struct B<I, I * 2, K> {}; // expected-note {{matches}}
+ template <int I, int K> struct B<I, I * 2, K> {}; // #dr1315-B-1
B<1, 2, 3> b1;
// Multiple declarations with the same dependent expression are equivalent
@@ -131,8 +167,11 @@ namespace dr1315 { // dr1315: partial
B<1, 2, 2>::type b2;
// Multiple declarations with
diff ering dependent expressions are unordered.
- template <int I, int K> struct B<I, I + 1, K> {}; // expected-note {{matches}}
- B<1, 2, 4> b3; // expected-error {{ambiguous}}
+ template <int I, int K> struct B<I, I + 1, K> {}; // #dr1315-B-2
+ B<1, 2, 4> b3;
+ // expected-error at -1 {{ambiguous partial specializations of 'B<1, 2, 4>'}}
+ // expected-note@#dr1315-B-1 {{partial specialization matches [with I = 1, K = 4]}}
+ // expected-note@#dr1315-B-2 {{partial specialization matches [with I = 1, K = 4]}}
// FIXME: Under dr1315, this is perhaps valid, but that is not clear: this
// fails the "more specialized than the primary template" test because the
@@ -146,7 +185,9 @@ namespace dr1315 { // dr1315: partial
namespace dr1330 { // dr1330: 4 c++11
// exception-specifications are parsed in a context where the class is complete.
struct A {
- void f() throw(T) {} // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
+ void f() throw(T) {}
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
struct T {};
#if __cplusplus >= 201103L
@@ -156,8 +197,12 @@ namespace dr1330 { // dr1330: 4 c++11
#endif
};
- void (A::*af1)() throw(A::T) = &A::f; // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
- void (A::*af2)() throw() = &A::f; // expected-error-re {{{{not superset|
diff erent exception spec}}}}
+ void (A::*af1)() throw(A::T) = &A::f;
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
+ void (A::*af2)() throw() = &A::f;
+ // cxx98-14-error at -1 {{target exception specification is not superset of source}}
+ // since-cxx17-error at -2 {{cannot initialize a variable of type 'void (dr1330::A::*)() throw()' with an rvalue of type 'void (dr1330::A::*)() throw(T)':
diff erent exception specifications}}
#if __cplusplus >= 201103L
static_assert(noexcept(A().g()), "");
@@ -166,7 +211,9 @@ namespace dr1330 { // dr1330: 4 c++11
// Likewise, they're instantiated separately from an enclosing class template.
template<typename U>
struct B {
- void f() throw(T, typename U::type) {} // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
+ void f() throw(T, typename U::type) {}
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
struct T {};
#if __cplusplus >= 201103L
@@ -183,9 +230,6 @@ namespace dr1330 { // dr1330: 4 c++11
static const int value = true;
};
- void (B<P>::*bpf1)() throw(B<P>::T, int) = &B<P>::f; // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
-#if __cplusplus < 201103L
- // expected-error at -2 {{not superset}}
// FIXME: We only delay instantiation in C++11 onwards. In C++98, something
// weird happens: instantiation of B<P> fails because it references T before
// it's instantiated, but the diagnostic is suppressed in
@@ -193,20 +237,20 @@ namespace dr1330 { // dr1330: 4 c++11
// obviously a bad way to react to this situation; we should still producing
// the "T has not yet been instantiated" error here, rather than giving
// confusing errors later on.
-#endif
- void (B<P>::*bpf2)() throw(int) = &B<P>::f; // expected-error 0-1{{C++17}} expected-note 0-1{{noexcept}}
-#if __cplusplus <= 201402L
- // expected-error at -2 {{not superset}}
-#else
- // expected-warning at -4 {{not superset}}
-#endif
+ void (B<P>::*bpf1)() throw(B<P>::T, int) = &B<P>::f;
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
+ // cxx98-error at -3 {{target exception specification is not superset of source}}
+
+ void (B<P>::*bpf2)() throw(int) = &B<P>::f;
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
+ // cxx98-14-error at -3 {{target exception specification is not superset of source}}
+ // since-cxx17-warning at -4 {{target exception specification is not superset of source}}
void (B<P>::*bpf3)() = &B<P>::f;
void (B<P>::*bpf4)() throw() = &B<P>::f;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{not superset}}
-#else
- // expected-error at -4 {{
diff erent exception specifications}}
-#endif
+ // cxx98-14-error at -1 {{target exception specification is not superset of source}}
+ // since-cxx17-error at -2 {{cannot initialize a variable of type 'void (B<P>::*)() throw()' with an rvalue of type 'void (dr1330::B<dr1330::P>::*)() throw(T, typename P::type)':
diff erent exception specifications}}
#if __cplusplus >= 201103L
static_assert(noexcept(B<P>().g()), "");
@@ -214,57 +258,64 @@ namespace dr1330 { // dr1330: 4 c++11
static_assert(!noexcept(B<Q>().g()), "");
#endif
- template<typename T> int f() throw(typename T::error) { return 0; } // expected-error 1-4{{prior to '::'}} expected-note 0-1{{prior to '::'}} expected-note 0-1{{requested here}}
-#if __cplusplus > 201402L
- // expected-error at -2 0-1{{C++17}} expected-note at -2 0-1{{noexcept}}
-#endif
+ template<typename T> int f() throw(typename T::error) { return 0; } // #dr1330-f
+ // expected-error@#dr1330-f {{type 'int' cannot be used prior to '::' because it has no members}}
+ // cxx98-note@#dr1330-f-int {{in instantiation of function template specialization 'dr1330::f<int>' requested here}}
+ // since-cxx11-note@#dr1330-f-int {{in instantiation of exception specification for 'f<int>' requested here}}
+ // cxx98-14-error@#dr1330-f {{type 'short' cannot be used prior to '::' because it has no members}}
+ // cxx98-14-note@#dr1330-f-short {{in instantiation of function template specialization 'dr1330::f<short>' requested here}}
+ // cxx11-14-note@#dr1330-f {{in instantiation of exception specification for 'f<short>' requested here}}
+ // since-cxx11-error@#dr1330-f {{type 'char' cannot be used prior to '::' because it has no members}}
+ // since-cxx11-note@#dr1330-f-char {{in instantiation of exception specification for 'f<char>' requested here}}
+ // since-cxx11-error@#dr1330-f {{type 'float' cannot be used prior to '::' because it has no members}}
+ // since-cxx11-note@#dr1330-f-float {{in instantiation of exception specification for 'f<float>' requested here}}
+ // since-cxx17-error@#dr1330-f {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note@#dr1330-f {{use 'noexcept(false)' instead}}
+
// An exception-specification is needed even if the function is only used in
// an unevaluated operand.
- int f1 = sizeof(f<int>()); // expected-note {{instantiation of}}
+ int f1 = sizeof(f<int>()); // #dr1330-f-int
#if __cplusplus >= 201103L
- decltype(f<char>()) f2; // expected-note {{instantiation of}}
- bool f3 = noexcept(f<float>()); // expected-note {{instantiation of}}
+ decltype(f<char>()) f2; // #dr1330-f-char
+ bool f3 = noexcept(f<float>()); /// #dr1330-f-float
#endif
// In C++17 onwards, substituting explicit template arguments into the
// function type substitutes into the exception specification (because it's
// part of the type). In earlier languages, we don't notice there's a problem
// until we've already started to instantiate.
- template int f<short>();
-#if __cplusplus >= 201703L
- // expected-error at -2 {{does not refer to a function template}}
-#else
- // expected-note at -4 {{instantiation of}}
-#endif
+ template int f<short>(); // #dr1330-f-short
+ // since-cxx17-error at -1 {{explicit instantiation of 'f' does not refer to a function template, variable template, member function, member class, or static data member}}
+ // since-cxx17-note@#dr1330-f {{candidate template ignored: substitution failure [with T = short]: type 'short' cannot be used prior to '::' because it has no members}}
template<typename T> struct C {
- C() throw(typename T::type); // expected-error 1-2{{prior to '::'}}
-#if __cplusplus > 201402L
- // expected-error at -2 0-1{{C++17}} expected-note at -2 0-1{{noexcept}}
-#endif
+ C() throw(typename T::type); // #dr1330-C
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
+ // cxx98-error@#dr1330-C {{type 'void' cannot be used prior to '::' because it has no members}}
+ // cxx98-note@#dr1330-C-void {{in instantiation of template class 'dr1330::C<void>' requested here}}
+ // expected-error@#dr1330-C {{type 'int' cannot be used prior to '::' because it has no members}}
+ // cxx98-note@#dr1330-C-int {{in instantiation of template class 'dr1330::C<int>' requested here}}
+ // since-cxx11-note@#dr1330-C-int {{in instantiation of exception specification for 'C' requested here}}
+ // since-cxx11-note@#dr1330-e {{in evaluation of exception specification for 'dr1330::E::E' needed here}}
};
- struct D : C<void> {}; // ok
-#if __cplusplus < 201103L
- // expected-note at -2 {{instantiation of}}
-#endif
+ struct D : C<void> {}; // #dr1330-C-void
void f(D &d) { d = d; } // ok
- struct E : C<int> {}; // expected-note {{in instantiation of}}
-#if __cplusplus >= 201103L
- E e; // expected-note {{needed here}}
-#endif
+ struct E : C<int> {}; // #dr1330-C-int
+ E e; // #dr1330-e
}
namespace dr1341 { // dr1341: sup P0683R1
#if __cplusplus >= 202002L
int a;
-const int b = 0; // #dr1341-b-decl
+const int b = 0; // #dr1341-b
struct S {
int x1 : 8 = 42;
int x2 : 8 { 42 };
int y1 : true ? 8 : a = 42;
int y2 : true ? 8 : b = 42;
- // expected-error at -1 {{cannot assign to variable 'b' with const-qualified type 'const int'}}
- // expected-note@#dr1341-b-decl {{variable 'b' declared const here}}
+ // since-cxx20-error at -1 {{cannot assign to variable 'b' with const-qualified type 'const int'}}
+ // since-cxx20-note@#dr1341-b {{variable 'b' declared const here}}
int y3 : (true ? 8 : b) = 42;
int z : 1 || new int { 0 };
};
@@ -272,44 +323,66 @@ struct S {
}
namespace dr1346 { // dr1346: 3.5
- auto a(1); // expected-error 0-1{{extension}}
- auto b(1, 2); // expected-error {{multiple expressions}} expected-error 0-1{{extension}}
+ auto a(1);
+ // cxx98-error at -1 {{'auto' type specifier is a C++11 extension}}
+ auto b(1, 2);
+ // cxx98-error at -1 {{'auto' type specifier is a C++11 extension}}
+ // expected-error at -2 {{initializer for variable 'b' with type 'auto' contains multiple expressions}}
#if __cplusplus >= 201103L
- auto c({}); // expected-error {{parenthesized initializer list}}
- auto d({1}); // expected-error {{parenthesized initializer list}}
- auto e({1, 2}); // expected-error {{parenthesized initializer list}}
+ auto c({});
+ // since-cxx11-error at -1 {{cannot deduce type for variable 'c' with type 'auto' from parenthesized initializer list}}
+ auto d({1});
+ // since-cxx11-error at -1 {{cannot deduce type for variable 'd' with type 'auto' from parenthesized initializer list}}
+ auto e({1, 2});
+ // since-cxx11-error at -1 {{cannot deduce type for variable 'e' with type 'auto' from parenthesized initializer list}}
#endif
- template<typename...Ts> void f(Ts ...ts) { // expected-error 0-1{{extension}}
- auto x(ts...); // expected-error {{empty}} expected-error 0-1{{extension}}
+ template<typename...Ts> void f(Ts ...ts) {
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
+ auto x(ts...);
+ // cxx98-error at -1 {{'auto' type specifier is a C++11 extension}}
+ // expected-error at -2 {{initializer for variable 'x' with type 'auto' is empty}}
+ // expected-note@#dr1346-f {{in instantiation of function template specialization 'dr1346::f<>' requested here}}
}
- template void f(); // expected-note {{instantiation}}
+ template void f(); // #dr1346-f
#if __cplusplus >= 201103L
void init_capture() {
- [a(1)] {} (); // expected-error 0-1{{extension}}
- [b(1, 2)] {} (); // expected-error {{multiple expressions}} expected-error 0-1{{extension}}
-#if __cplusplus >= 201103L
- [c({})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}}
- [d({1})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}}
- [e({1, 2})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}}
-#endif
+ [a(1)] {} ();
+ // cxx11-error at -1 {{initialized lambda captures are a C++14 extension}}
+ [b(1, 2)] {} ();
+ // cxx11-error at -1 {{initialized lambda captures are a C++14 extension}}
+ // since-cxx11-error at -2 {{initializer for lambda capture 'b' contains multiple expressions}}
+ [c({})] {} ();
+ // cxx11-error at -1 {{initialized lambda captures are a C++14 extension}}
+ // since-cxx11-error at -2 {{cannot deduce type for lambda capture 'c' from parenthesized initializer list}}
+ [d({1})] {} ();
+ // cxx11-error at -1 {{initialized lambda captures are a C++14 extension}}
+ // since-cxx11-error at -2 {{cannot deduce type for lambda capture 'd' from parenthesized initializer list}}
+ [e({1, 2})] {} ();
+ // cxx11-error at -1 {{initialized lambda captures are a C++14 extension}}
+ // since-cxx11-error at -2 {{cannot deduce type for lambda capture 'e' from parenthesized initializer list}}
}
#endif
}
namespace dr1347 { // dr1347: 3.1
- auto x = 5, *y = &x; // expected-error 0-1{{extension}}
- auto z = y, *q = y; // expected-error {{'auto' deduced as 'int *' in declaration of 'z' and deduced as 'int' in declaration of 'q'}} expected-error 0-1{{extension}}
+ auto x = 5, *y = &x;
+ // cxx98-error at -1 {{'auto' type specifier is a C++11 extension}}
+ auto z = y, *q = y;
+ // cxx98-error at -1 {{'auto' type specifier is a C++11 extension}}
+ // expected-error at -2 {{'auto' deduced as 'int *' in declaration of 'z' and deduced as 'int' in declaration of 'q'}}
#if __cplusplus >= 201103L
- auto a = 5, b = {1, 2}; // expected-error {{'auto' deduced as 'int' in declaration of 'a' and deduced as 'std::initializer_list<int>' in declaration of 'b'}}
- auto (*fp)(int) -> int, i = 0; // expected-error {{declaration with trailing return type must be the only declaration in its group}}
+ auto a = 5, b = {1, 2};
+ // since-cxx11-error at -1 {{'auto' deduced as 'int' in declaration of 'a' and deduced as 'std::initializer_list<int>' in declaration of 'b'}}
+ auto (*fp)(int) -> int, i = 0;
+ // since-cxx11-error at -1 {{declaration with trailing return type must be the only declaration in its group}}
#endif
}
namespace dr1358 { // dr1358: 3.1
#if __cplusplus >= 201103L
struct Lit { constexpr operator int() const { return 0; } };
- struct NonLit { NonLit(); operator int(); }; // expected-note 2{{no constexpr constructors}}
+ struct NonLit { NonLit(); operator int(); }; // #dr1358-NonLit
struct NonConstexprConv { constexpr operator int() const; };
struct Virt { virtual int f(int) const; };
@@ -336,8 +409,12 @@ namespace dr1358 { // dr1358: 3.1
// But the corresponding non-template cases are rejected.
struct B : Virt {
int member;
- constexpr B(NonLit u) : member(u) {} // expected-error {{not a literal type}}
- constexpr NonLit f(NonLit u) const { return NonLit(); } // expected-error {{not a literal type}}
+ constexpr B(NonLit u) : member(u) {}
+ // since-cxx11-error at -1 {{constexpr constructor's 1st parameter type 'NonLit' is not a literal type}}
+ // since-cxx11-note@#dr1358-NonLit {{'NonLit' is not literal because it is not an aggregate and has no constexpr constructors other than copy or move constructors}}
+ constexpr NonLit f(NonLit u) const { return NonLit(); }
+ // since-cxx11-error at -1 {{constexpr function's return type 'NonLit' is not a literal type}}
+ // since-cxx11-note@#dr1358-NonLit {{'NonLit' is not literal because it is not an aggregate and has no constexpr constructors other than copy or move constructors}}
};
#endif
}
@@ -345,65 +422,113 @@ namespace dr1358 { // dr1358: 3.1
namespace dr1359 { // dr1359: 3.5
#if __cplusplus >= 201103L
union A { constexpr A() = default; };
- union B { constexpr B() = default; int a; }; // expected-error {{not constexpr}} expected-note 2{{candidate}}
- union C { constexpr C() = default; int a, b; }; // expected-error {{not constexpr}} expected-note 2{{candidate}}
- struct X { constexpr X() = default; union {}; }; // expected-error {{does not declare anything}}
- struct Y { constexpr Y() = default; union { int a; }; }; // expected-error {{not constexpr}} expected-note 2{{candidate}}
+ union B { constexpr B() = default; int a; }; // #dr1359-B
+ // cxx11-17-error at -1 {{defaulted definition of default constructor is not constexpr}}
+ union C { constexpr C() = default; int a, b; }; // #dr1359-C
+ // cxx11-17-error at -1 {{defaulted definition of default constructor is not constexpr}}
+ struct X { constexpr X() = default; union {}; };
+ // since-cxx11-error at -1 {{declaration does not declare anything}}
+ struct Y { constexpr Y() = default; union { int a; }; }; // #dr1359-Y
+ // cxx11-17-error at -1 {{defaulted definition of default constructor is not constexpr}}
constexpr A a = A();
- constexpr B b = B(); // expected-error {{no matching}}
- constexpr C c = C(); // expected-error {{no matching}}
+ constexpr B b = B();
+ // cxx11-17-error at -1 {{no matching constructor for initialization of 'B'}}
+ // cxx11-17-note@#dr1359-B {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided}}
+ // cxx11-17-note@#dr1359-B {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided}}
+ constexpr C c = C();
+ // cxx11-17-error at -1 {{no matching constructor for initialization of 'C'}}
+ // cxx11-17-note@#dr1359-C {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided}}
+ // cxx11-17-note@#dr1359-C {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided}}
constexpr X x = X();
- constexpr Y y = Y(); // expected-error {{no matching}}
+ constexpr Y y = Y();
+ // cxx11-17-error at -1 {{no matching constructor for initialization of 'Y'}}
+ // cxx11-17-note@#dr1359-Y {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided}}
+ // cxx11-17-note@#dr1359-Y {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided}}
#endif
}
namespace dr1388 { // dr1388: 4
- template<typename A, typename ...T> void f(T..., A); // expected-note 1+{{candidate}} expected-error 0-1{{C++11}}
- template<typename ...T> void g(T..., int); // expected-note 1+{{candidate}} expected-error 0-1{{C++11}}
- template<typename ...T, typename A> void h(T..., A); // expected-note 1+{{candidate}} expected-error 0-1{{C++11}}
+ template<typename A, typename ...T> void f(T..., A); // #dr1388-f
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
+ template<typename ...T> void g(T..., int); // #dr1388-g
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
+ template<typename ...T, typename A> void h(T..., A); // #dr1388-h
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
void test_f() {
f(0); // ok, trailing parameter pack deduced to empty
- f(0, 0); // expected-error {{no matching}}
+ f(0, 0);
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr1388-f {{candidate function [with A = int, T = <>] not viable: requires 1 argument, but 2 were provided}}
f<int>(0);
- f<int>(0, 0); // expected-error {{no matching}}
+ f<int>(0, 0);
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr1388-f {{candidate function [with A = int, T = <>] not viable: requires 1 argument, but 2 were provided}}
f<int, int>(0, 0);
- f<int, int, int>(0, 0); // expected-error {{no matching}}
+ f<int, int, int>(0, 0);
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr1388-f {{candidate function [with A = int, T = <int, int>] not viable: requires 3 arguments, but 2 were provided}}
g(0);
- g(0, 0); // expected-error {{no matching}}
+ g(0, 0);
+ // expected-error at -1 {{no matching function for call to 'g'}}
+ // expected-note@#dr1388-g {{candidate function [with T = <>] not viable: requires 1 argument, but 2 were provided}}
g<>(0);
- g<int>(0); // expected-error {{no matching}}
+ g<int>(0);
+ // expected-error at -1 {{no matching function for call to 'g'}}
+ // expected-note@#dr1388-g {{candidate function [with T = <int>] not viable: requires 2 arguments, but 1 was provided}}
g<int>(0, 0);
h(0);
- h(0, 0); // expected-error {{no matching}}
+ h(0, 0);
+ // expected-error at -1 {{no matching function for call to 'h'}}
+ // expected-note@#dr1388-h {{candidate function [with T = <>, A = int] not viable: requires 1 argument, but 2 were provided}}
h<int>(0, 0);
- h<int, int>(0, 0); // expected-error {{no matching}}
+ h<int, int>(0, 0);
+ // expected-error at -1 {{no matching function for call to 'h'}}
+ // expected-note@#dr1388-h {{candidate template ignored: couldn't infer template argument 'A'}}
}
// A non-trailing parameter pack is still a non-deduced context, even though
// we know exactly how many arguments correspond to it.
template<typename T, typename U> struct pair {};
- template<typename ...T> struct tuple { typedef char type; }; // expected-error 0-2{{C++11}}
- template<typename ...T, typename ...U> void f_pair_1(pair<T, U>..., int); // expected-error 0-2{{C++11}} expected-note {{[with T = <int, long>]: deduced incomplete pack <(no value), (no value)> for template parameter 'U'}}
- template<typename ...T, typename U> void f_pair_2(pair<T, char>..., U); // expected-error 0-2{{C++11}}
- template<typename ...T, typename ...U> void f_pair_3(pair<T, U>..., tuple<U...>); // expected-error 0-2{{C++11}} expected-note {{deduced packs of
diff erent lengths for parameter 'U' (<(no value), (no value)> vs. <char>)}}
- template<typename ...T> void f_pair_4(pair<T, char>..., T...); // expected-error 0-2{{C++11}} expected-note {{<int, long> vs. <int, long, const char *>}}
+ template<typename ...T> struct tuple { typedef char type; }; //
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
+ template<typename ...T, typename ...U> void f_pair_1(pair<T, U>..., int); // #dr1388-f-1
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
+ // cxx98-error at -2 {{variadic templates are a C++11 extension}}
+ template<typename ...T, typename U> void f_pair_2(pair<T, char>..., U);
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
+ template<typename ...T, typename ...U> void f_pair_3(pair<T, U>..., tuple<U...>); // #dr1388-f-3
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
+ // cxx98-error at -2 {{variadic templates are a C++11 extension}}
+ template<typename ...T> void f_pair_4(pair<T, char>..., T...); // #dr1388-f-4
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
void g(pair<int, char> a, pair<long, char> b, tuple<char, char> c) {
- f_pair_1<int, long>(a, b, 0); // expected-error {{no match}}
+ f_pair_1<int, long>(a, b, 0);
+ // expected-error at -1 {{no matching function for call to 'f_pair_1'}}
+ // expected-note@#dr1388-f-1 {{candidate template ignored: substitution failure [with T = <int, long>]: deduced incomplete pack <(no value), (no value)> for template parameter 'U'}}
f_pair_2<int, long>(a, b, 0);
f_pair_3<int, long>(a, b, c);
- f_pair_3<int, long>(a, b, tuple<char>()); // expected-error {{no match}}
+ f_pair_3<int, long>(a, b, tuple<char>());
+ // expected-error at -1 {{no matching function for call to 'f_pair_3'}}
+ // expected-note@#dr1388-f-3 {{candidate template ignored: deduced packs of
diff erent lengths for parameter 'U' (<(no value), (no value)> vs. <char>)}}
f_pair_4<int, long>(a, b, 0, 0L);
- f_pair_4<int, long>(a, b, 0, 0L, "foo"); // expected-error {{no match}}
+ f_pair_4<int, long>(a, b, 0, 0L, "foo");
+ // expected-error at -1 {{no matching function for call to 'f_pair_4'}}
+ // expected-note@#dr1388-f-4 {{candidate template ignored: deduced packs of
diff erent lengths for parameter 'T' (<int, long> vs. <int, long, const char *>)}}
}
}
namespace dr1391 { // dr1391: partial
struct A {}; struct B : A {};
- template<typename T> struct C { C(int); typename T::error error; }; // expected-error 2{{'::'}}
+ template<typename T> struct C { C(int); typename T::error error; }; // #dr1391-C
+ // expected-error@#dr1391-C {{type 'int' cannot be used prior to '::' because it has no members}}
+ // expected-note@#dr1391-b {{in instantiation of template class 'dr1391::C<int>' requested here}}
+ // expected-note@#dr1391-b {{while substituting deduced template arguments into function template 'b' [with T = int]}}
+ // expected-error@#dr1391-C {{type 'double' cannot be used prior to '::' because it has no members}}
+ // expected-note@#dr1391-c {{in instantiation of template class 'dr1391::C<double>' requested here}}
template<typename T> struct D {};
// No deduction is performed for parameters with no deducible template-parameters, therefore types do not need to match.
@@ -444,28 +569,36 @@ namespace dr1391 { // dr1391: partial
void test_b() {
b(0, 0); // ok, deduction fails prior to forming a conversion sequence and instantiating C<int>
// FIXME: The "while substituting" note should point at the overload candidate.
- b<int>(0, 0); // expected-note {{instantiation of}} expected-note {{while substituting}}
+ b<int>(0, 0); // #dr1391-b
}
template<typename T> struct Id { typedef T type; };
template<typename T> void c(T, typename Id<C<T> >::type);
void test_c() {
// Implicit conversion sequences for dependent types are checked later.
- c(0.0, 0); // expected-note {{instantiation of}}
+ c(0.0, 0); // #dr1391-c
}
namespace partial_ordering {
// FIXME: Second template should be considered more specialized because non-dependent parameter is ignored.
- template<typename T> int a(T, short) = delete; // expected-error 0-1{{extension}} expected-note {{candidate}}
- template<typename T> int a(T*, char); // expected-note {{candidate}}
- int test_a = a((int*)0, 0); // FIXME: expected-error {{ambiguous}}
+ template<typename T> int a(T, short) = delete; // #dr1391-a-short
+ // cxx98-error at -1 {{deleted function definitions are a C++11 extension}}
+ template<typename T> int a(T*, char); // #dr1391-a-char
+ int test_a = a((int*)0, 0);
+ // expected-error at -1 {{call to 'a' is ambiguous}} FIXME
+ // expected-note@#dr1391-a-short {{candidate function [with T = int *] has been explicitly deleted}}
+ // expected-note@#dr1391-a-char {{candidate function [with T = int]}}
// FIXME: Second template should be considered more specialized:
// deducing #1 from #2 ignores the second P/A pair, so deduction succeeds,
// deducing #2 from #1 fails to deduce T, so deduction fails.
- template<typename T> int b(T, int) = delete; // expected-error 0-1{{extension}} expected-note {{candidate}}
- template<typename T, typename U> int b(T*, U); // expected-note {{candidate}}
- int test_b = b((int*)0, 0); // FIXME: expected-error {{ambiguous}}
+ template<typename T> int b(T, int) = delete; // #dr1391-b-int
+ // cxx98-error at -1 {{deleted function definitions are a C++11 extension}}
+ template<typename T, typename U> int b(T*, U); // #dr1391-b-U
+ int test_b = b((int*)0, 0);
+ // expected-error at -1 {{call to 'b' is ambiguous}} FIXME
+ // expected-note@#dr1391-b-int {{candidate function [with T = int *] has been explicitly deleted}}
+ // expected-note@#dr1391-b-U {{candidate function [with T = int, U = int]}}
// Unintended consequences: because partial ordering does not consider
// explicit template arguments, and deduction from a non-dependent type
@@ -499,26 +632,26 @@ namespace dr1395 { // dr1395: 16
namespace dr1397 { // dr1397: 3.2
#if __cplusplus >= 201103L
-struct A { // #dr1397-struct-A
- void *p = A{}; // #dr1397-void-p
-#if __cplusplus == 201103L
- // expected-error@#dr1397-struct-A {{default member initializer for 'p' needed within definition of enclosing class 'A' outside of member functions}}
- // expected-note@#dr1397-void-p {{in evaluation of exception specification for 'dr1397::A::A' needed here}}
- // expected-note@#dr1397-void-p {{default member initializer declared here}}
-#elif __cplusplus >= 201402L
- // expected-error@#dr1397-void-p {{default member initializer for 'p' needed within definition of enclosing class 'A' outside of member functions}}
- // expected-note@#dr1397-void-p {{default member initializer declared here}}
-#endif
+struct A {
+// cxx11-error at -1 {{default member initializer for 'p' needed within definition of enclosing class 'A' outside of member functions}}
+// cxx11-note@#dr1397-p {{in evaluation of exception specification for 'dr1397::A::A' needed here}}
+// cxx11-note@#dr1397-p {{default member initializer declared here}}
+ void *p = A{}; // #dr1397-p
+ // since-cxx14-error at -1 {{default member initializer for 'p' needed within definition of enclosing class 'A' outside of member functions}}
+ // since-cxx14-note at -2 {{default member initializer declared here}}
operator void*() const { return nullptr; }
};
#endif
} // namespace dr1397
namespace dr1399 { // dr1399: dup 1388
- template<typename ...T> void f(T..., int, T...) {} // expected-note {{candidate}} expected-error 0-1{{C++11}}
+ template<typename ...T> void f(T..., int, T...) {} // #dr1399-f
+ // cxx98-error at -1 {{variadic templates are a C++11 extension}}
void g() {
f(0);
f<int>(0, 0, 0);
- f(0, 0, 0); // expected-error {{no match}}
+ f(0, 0, 0);
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr1399-f {{candidate template ignored: deduced packs of
diff erent lengths for parameter 'T' (<> vs. <int, int>)}}
}
}
diff --git a/clang/test/CXX/drs/dr14xx.cpp b/clang/test/CXX/drs/dr14xx.cpp
index 7dd7da95d034de..d262f6f9dcab79 100644
--- a/clang/test/CXX/drs/dr14xx.cpp
+++ b/clang/test/CXX/drs/dr14xx.cpp
@@ -1,8 +1,10 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx11-17,since-cxx11, -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,cxx14-17,cxx11-17,since-cxx11,since-cxx14 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,cxx14-17,cxx11-17,since-cxx11,since-cxx14 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx11,since-cxx14,since-cxx20 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx11,since-cxx14,since-cxx20 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2c %s -verify=expected,since-cxx11,since-cxx14,since-cxx20 -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr1413 { // dr1413: 12
template<int> struct Check {
@@ -15,24 +17,41 @@ namespace dr1413 { // dr1413: 12
void d();
void f() {
- Check<true ? 0 : A::unknown_spec>::type *var1; // expected-error {{undeclared identifier 'var1'}}
- Check<true ? 0 : a>::type *var2; // ok, variable declaration expected-note 0+{{here}}
- Check<true ? 0 : b>::type *var3; // expected-error {{undeclared identifier 'var3'}}
- Check<true ? 0 : ((void)c, 0)>::type *var4; // expected-error {{undeclared identifier 'var4'}}
+ Check<true ? 0 : A::unknown_spec>::type *var1;
+ // expected-error at -1 {{use of undeclared identifier 'var1'}}
+
+ // ok, variable declaration
+ Check<true ? 0 : a>::type *var2; // #dr1413-var2
+ Check<true ? 0 : b>::type *var3;
+ // expected-error at -1 {{use of undeclared identifier 'var3'}}
+ // expected-note@#dr1413-var2 {{'var2' declared here}}
+ Check<true ? 0 : ((void)c, 0)>::type *var4;
+ // expected-error at -1 {{use of undeclared identifier 'var4'}}
+ // expected-note@#dr1413-var2 {{'var2' declared here}}
+
// value-dependent because of the implied type-dependent 'this->', not because of 'd'
- Check<true ? 0 : (d(), 0)>::type *var5; // expected-error {{undeclared identifier 'var5'}}
+ Check<true ? 0 : (d(), 0)>::type *var5;
+ // expected-error at -1 {{use of undeclared identifier 'var5'}}
+ // expected-note@#dr1413-var2 {{'var2' declared here}}
+
// value-dependent because of the value-dependent '&' operator, not because of 'A::d'
- Check<true ? 0 : (&A::d(), 0)>::type *var5; // expected-error {{undeclared identifier 'var5'}}
+ Check<true ? 0 : (&A::d(), 0)>::type *var5;
+ // expected-error at -1 {{use of undeclared identifier 'var5'}}
+ // expected-note@#dr1413-var2 {{'var2' declared here}}
}
};
}
namespace dr1423 { // dr1423: 11
#if __cplusplus >= 201103L
- bool b1 = nullptr; // expected-error {{cannot initialize}}
- bool b2(nullptr); // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
- bool b3 = {nullptr}; // expected-error {{cannot initialize}}
- bool b4{nullptr}; // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
+ bool b1 = nullptr;
+ // since-cxx11-error at -1 {{cannot initialize a variable of type 'bool' with an rvalue of type 'std::nullptr_t'}}
+ bool b2(nullptr);
+ // since-cxx11-warning at -1 {{implicit conversion of nullptr constant to 'bool'}}
+ bool b3 = {nullptr};
+ // since-cxx11-error at -1 {{cannot initialize a variable of type 'bool' with an rvalue of type 'std::nullptr_t'}}
+ bool b4{nullptr};
+ // since-cxx11-warning at -1 {{implicit conversion of nullptr constant to 'bool'}}
#endif
}
@@ -62,7 +81,8 @@ namespace dr1432 { // dr1432: 16
namespace dr1443 { // dr1443: yes
struct A {
int i;
- A() { void foo(int=i); } // expected-error {{default argument references 'this'}}
+ A() { void foo(int=i); }
+ // expected-error at -1 {{default argument references 'this'}}
};
}
@@ -70,49 +90,54 @@ namespace dr1460 { // dr1460: 3.5
#if __cplusplus >= 201103L
namespace DRExample {
union A {
- union {}; // expected-error {{does not declare anything}}
- union {}; // expected-error {{does not declare anything}}
+ union {};
+ // expected-error at -1 {{declaration does not declare anything}}
+ union {};
+ // expected-error at -1 {{declaration does not declare anything}}
constexpr A() {}
};
constexpr A a = A();
union B {
- union {}; // expected-error {{does not declare anything}}
- union {}; // expected-error {{does not declare anything}}
+ union {};
+ // expected-error at -1 {{declaration does not declare anything}}
+ union {};
+ // expected-error at -1 {{declaration does not declare anything}}
constexpr B() = default;
};
constexpr B b = B();
union C {
- union {}; // expected-error {{does not declare anything}}
- union {}; // expected-error {{does not declare anything}}
+ union {};
+ // expected-error at -1 {{declaration does not declare anything}}
+ union {};
+ // expected-error at -1 {{declaration does not declare anything}}
};
constexpr C c = C();
-#if __cplusplus > 201103L
+#if __cplusplus >= 201403L
constexpr void f() { C c; }
static_assert((f(), true), "");
#endif
}
union A {};
- union B { int n; }; // expected-note 0+{{here}}
+ union B { int n; }; // #dr1460-B
union C { int n = 0; };
- struct D { union {}; }; // expected-error {{does not declare anything}}
- struct E { union { int n; }; }; // expected-note 0+{{here}}
+ struct D { union {}; };
+ // expected-error at -1 {{declaration does not declare anything}}
+ struct E { union { int n; }; }; // #dr1460-E
struct F { union { int n = 0; }; };
struct X {
friend constexpr A::A() noexcept;
friend constexpr B::B() noexcept;
-#if __cplusplus <= 201703L
- // expected-error at -2 {{follows non-constexpr declaration}}
-#endif
+ // cxx11-17-error at -1 {{constexpr declaration of 'B' follows non-constexpr declaration}}
+ // cxx11-17-note@#dr1460-B {{previous declaration is here}}
friend constexpr C::C() noexcept;
friend constexpr D::D() noexcept;
friend constexpr E::E() noexcept;
-#if __cplusplus <= 201703L
- // expected-error at -2 {{follows non-constexpr declaration}}
-#endif
+ // cxx11-17-error at -1 {{constexpr declaration of 'E' follows non-constexpr declaration}}
+ // cxx11-17-note@#dr1460-E {{previous declaration is here}}
friend constexpr F::F() noexcept;
};
@@ -128,79 +153,77 @@ namespace dr1460 { // dr1460: 3.5
namespace Defaulted {
union A { constexpr A() = default; };
union B { int n; constexpr B() = default; };
-#if __cplusplus <= 201703L
- // expected-error at -2 {{not constexpr}}
-#endif
+ // cxx11-17-error at -1 {{defaulted definition of default constructor is not constexpr}}
union C { int n = 0; constexpr C() = default; };
- struct D { union {}; constexpr D() = default; }; // expected-error {{does not declare anything}}
+ struct D { union {}; constexpr D() = default; };
+ // expected-error at -1 {{declaration does not declare anything}}
struct E { union { int n; }; constexpr E() = default; };
-#if __cplusplus <= 201703L
- // expected-error at -2 {{not constexpr}}
-#endif
+ // cxx11-17-error at -1 {{defaulted definition of default constructor is not constexpr}}
struct F { union { int n = 0; }; constexpr F() = default; };
struct G { union { int n = 0; }; union { int m; }; constexpr G() = default; };
-#if __cplusplus <= 201703L
- // expected-error at -2 {{not constexpr}}
-#endif
+ // cxx11-17-error at -1 {{defaulted definition of default constructor is not constexpr}}
struct H {
union {
int n = 0;
};
- union { // expected-note 0-2{{member not initialized}}
+ union { // #dr1460-H-union
int m;
};
constexpr H() {}
-#if __cplusplus <= 201703L
- // expected-error at -2 {{initialize all members}}
-#endif
+ // cxx11-17-error at -1 {{constexpr constructor that does not initialize all members is a C++20 extension}}
+ // cxx11-17-note@#dr1460-H-union {{member not initialized by constructor}}
constexpr H(bool) : m(1) {}
constexpr H(char) : n(1) {}
-#if __cplusplus <= 201703L
- // expected-error at -2 {{initialize all members}}
-#endif
+ // cxx11-17-error at -1 {{constexpr constructor that does not initialize all members is a C++20 extension}}
+ // cxx11-17-note@#dr1460-H-union {{member not initialized by constructor}}
constexpr H(double) : m(1), n(1) {}
};
}
-#if __cplusplus > 201103L
+#if __cplusplus >= 201403L
template<typename T> constexpr bool check() {
- T t;
-#if __cplusplus <= 201703L
- // expected-note-re at -2 2{{non-constexpr constructor '{{[BE]}}'}}
-#endif
+ T t; // #dr1460-t
return true;
}
static_assert(check<A>(), "");
- static_assert(check<B>(), "");
-#if __cplusplus <= 201703L
- // expected-error at -2 {{constant}} expected-note at -2 {{in call}}
-#endif
+ static_assert(check<B>(), ""); // #dr1460-check-B
+ // cxx14-17-error at -1 {{static assertion expression is not an integral constant expression}}
+ // cxx14-17-note@#dr1460-t {{non-constexpr constructor 'B' cannot be used in a constant expression}}
+ // cxx14-17-note@#dr1460-check-B {{in call to 'check<dr1460::B>()'}}
+ // cxx14-17-note@#dr1460-B {{declared here}}
static_assert(check<C>(), "");
static_assert(check<D>(), "");
- static_assert(check<E>(), "");
-#if __cplusplus <= 201703L
- // expected-error at -2 {{constant}} expected-note at -2 {{in call}}
-#endif
+ static_assert(check<E>(), ""); // #dr1460-check-E
+ // cxx14-17-error at -1 {{static assertion expression is not an integral constant expression}}
+ // cxx14-17-note@#dr1460-t {{non-constexpr constructor 'E' cannot be used in a constant expression}}
+ // cxx14-17-note@#dr1460-check-E {{in call to 'check<dr1460::E>()'}}
+ // cxx14-17-note@#dr1460-E {{declared here}}
static_assert(check<F>(), "");
#endif
union G {
- int a = 0; // expected-note {{previous initialization is here}}
- int b = 0; // expected-error {{initializing multiple members of union}}
+ int a = 0; // #dr1460-G-a
+ int b = 0;
+ // expected-error at -1 {{initializing multiple members of union}}
+ // expected-note@#dr1460-G-a {{previous initialization is here}}
};
union H {
union {
- int a = 0; // expected-note {{previous initialization is here}}
+ int a = 0; // #dr1460-H-a
};
union {
- int b = 0; // expected-error {{initializing multiple members of union}}
+ int b = 0;
+ // expected-error at -1 {{initializing multiple members of union}}
+ // expected-note@#dr1460-H-a {{previous initialization is here}}
};
};
struct I {
union {
- int a = 0; // expected-note {{previous initialization is here}}
- int b = 0; // expected-error {{initializing multiple members of union}}
+ int a = 0; // #dr1460-I-a
+ int b = 0;
+ // expected-error at -1 {{initializing multiple members of union}}
+ // expected-note@#dr1460-I-a {{previous initialization is here}}
};
};
struct J {
@@ -223,14 +246,24 @@ namespace dr1460 { // dr1460: 3.5
constexpr B(const char*) {}
};
static_assert(B().a == 1, "");
- static_assert(B().b == 2, ""); // expected-error {{constant}} expected-note {{read of}}
- static_assert(B('x').a == 0, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(B().b == 2, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'b' of union with active member 'a' is not allowed in a constant expression}}
+ static_assert(B('x').a == 0, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'a' of union with active member 'b' is not allowed in a constant expression}}
static_assert(B('x').b == 4, "");
- static_assert(B(123).b == 2, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(B(123).b == 2, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'b' of union with active member 'c' is not allowed in a constant expression}}
static_assert(B(123).c == 3, "");
- static_assert(B("").a == 1, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(B("").a == 1, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'a' of union with active member 'b' is not allowed in a constant expression}}
static_assert(B("").b == 2, "");
- static_assert(B("").c == 3, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(B("").c == 3, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'c' of union with active member 'b' is not allowed in a constant expression}}
struct C {
union { int a, b = 2, c; };
@@ -243,31 +276,55 @@ namespace dr1460 { // dr1460: 3.5
};
static_assert(C().a == 1, "");
- static_assert(C().b == 2, ""); // expected-error {{constant}} expected-note {{read of}}
- static_assert(C().d == 4, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(C().b == 2, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'b' of union with active member 'a' is not allowed in a constant expression}}
+ static_assert(C().d == 4, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'd' of union with active member 'e' is not allowed in a constant expression}}
static_assert(C().e == 5, "");
- static_assert(C('x').b == 2, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(C('x').b == 2, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'b' of union with active member 'c' is not allowed in a constant expression}}
static_assert(C('x').c == 3, "");
- static_assert(C('x').d == 4, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(C('x').d == 4, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'd' of union with active member 'e' is not allowed in a constant expression}}
static_assert(C('x').e == 5, "");
static_assert(C(1).b == 2, "");
- static_assert(C(1).c == 3, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(C(1).c == 3, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'c' of union with active member 'b' is not allowed in a constant expression}}
static_assert(C(1).d == 4, "");
- static_assert(C(1).e == 5, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(C(1).e == 5, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'e' of union with active member 'd' is not allowed in a constant expression}}
static_assert(C(1.f).b == 2, "");
- static_assert(C(1.f).c == 3, ""); // expected-error {{constant}} expected-note {{read of}}
- static_assert(C(1.f).e == 5, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(C(1.f).c == 3, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'c' of union with active member 'b' is not allowed in a constant expression}}
+ static_assert(C(1.f).e == 5, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'e' of union with active member 'f' is not allowed in a constant expression}}
static_assert(C(1.f).f == 6, "");
- static_assert(C("").a == 1, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(C("").a == 1, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'a' of union with active member 'b' is not allowed in a constant expression}}
static_assert(C("").b == 2, "");
- static_assert(C("").c == 3, ""); // expected-error {{constant}} expected-note {{read of}}
- static_assert(C("").d == 4, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(C("").c == 3, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'c' of union with active member 'b' is not allowed in a constant expression}}
+ static_assert(C("").d == 4, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'd' of union with active member 'e' is not allowed in a constant expression}}
static_assert(C("").e == 5, "");
- static_assert(C("").f == 6, ""); // expected-error {{constant}} expected-note {{read of}}
+ static_assert(C("").f == 6, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of member 'f' of union with active member 'e' is not allowed in a constant expression}}
struct D;
extern const D d;
@@ -315,8 +372,10 @@ namespace std {
const _E* end() const {return __begin_ + __size_;}
};
} // std
+#endif
namespace dr1467 { // dr1467: 3.7 c++11
+#if __cplusplus >= 201103L
// Note that the change to [over.best.ics] was partially undone by DR2076;
// the resulting rule is tested with the tests for that change.
@@ -382,9 +441,12 @@ namespace dr1467 { // dr1467: 3.7 c++11
X x;
X x2{x};
- void f1(int); // expected-note {{candidate function}}
- void f1(std::initializer_list<long>) = delete; // expected-note {{candidate function has been explicitly deleted}}
- void g1() { f1({42}); } // expected-error {{call to deleted function 'f1'}}
+ void f1(int); // #dr1467-f1
+ void f1(std::initializer_list<long>) = delete; // #dr1467-f1-deleted
+ void g1() { f1({42}); }
+ // since-cxx11-error at -1 {{call to deleted function 'f1'}}
+ // since-cxx11-note@#dr1467-f1 {{candidate function}}
+ // since-cxx11-note@#dr1467-f1-deleted {{candidate function has been explicitly deleted}}
template <class T, class U>
struct Pair {
@@ -394,9 +456,12 @@ namespace dr1467 { // dr1467: 3.7 c++11
String(const char *);
};
- void f2(Pair<const char *, const char *>); // expected-note {{candidate function}}
- void f2(std::initializer_list<String>) = delete; // expected-note {{candidate function has been explicitly deleted}}
- void g2() { f2({"foo", "bar"}); } // expected-error {{call to deleted function 'f2'}}
+ void f2(Pair<const char *, const char *>); // #dr1467-f2
+ void f2(std::initializer_list<String>) = delete; // #dr1467-f2-deleted
+ void g2() { f2({"foo", "bar"}); }
+ // since-cxx11-error at -1 {{call to deleted function 'f2'}}
+ // since-cxx11-note@#dr1467-f2 {{candidate function}}
+ // since-cxx11-note@#dr1467-f2-deleted {{candidate function has been explicitly deleted}}
} // dr_example
namespace nonaggregate {
@@ -453,39 +518,89 @@ namespace dr1467 { // dr1467: 3.7 c++11
}
} // namespace NonAmbiguous
-#if __cplusplus >= 201103L
namespace StringLiterals {
// When the array size is 4 the call will attempt to bind an lvalue to an
// rvalue and fail. Therefore #2 will be called. (rsmith will bring this
// issue to CWG)
- void f(const char(&&)[4]); // expected-note 2 {{expects an rvalue}} expected-note 3 {{no known conversion}}
- void f(const char(&&)[5]) = delete; // expected-note 2 {{candidate function has been explicitly deleted}} expected-note 3 {{no known conversion}}
- void f(const wchar_t(&&)[4]); // expected-note {{expects an rvalue}} expected-note 4 {{no known conversion}}
- void f(const wchar_t(&&)[5]) = delete; // expected-note {{candidate function has been explicitly deleted}} expected-note 4 {{no known conversion}}
+ void f(const char(&&)[4]); // #dr1467-f-char-4
+ void f(const char(&&)[5]) = delete; // #dr1467-f-char-5
+ void f(const wchar_t(&&)[4]); // #dr1467-f-wchar-4
+ void f(const wchar_t(&&)[5]) = delete; // #dr1467-f-wchar-5
#if __cplusplus >= 202002L
- void f2(const char8_t(&&)[4]); // expected-note {{expects an rvalue}}
- void f2(const char8_t(&&)[5]) = delete; // expected-note {{candidate function has been explicitly deleted}}
+ void f2(const char8_t(&&)[4]); // #dr1467-f2-char8-4
+ void f2(const char8_t(&&)[5]) = delete; // #dr1467-f2-char8-5
#endif
- void f(const char16_t(&&)[4]); // expected-note {{expects an rvalue}} expected-note 4 {{no known conversion}}
- void f(const char16_t(&&)[5]) = delete; // expected-note {{candidate function has been explicitly deleted}} expected-note 4 {{no known conversion}}
- void f(const char32_t(&&)[4]); // expected-note {{expects an rvalue}} expected-note 4 {{no known conversion}}
- void f(const char32_t(&&)[5]) = delete; // expected-note {{candidate function has been explicitly deleted}} expected-note 4 {{no known conversion}}
+ void f(const char16_t(&&)[4]); // #dr1467-f-char16-4
+ void f(const char16_t(&&)[5]) = delete; // #dr1467-f-char16-5
+ void f(const char32_t(&&)[4]); // #dr1467-f-char32-4
+ void f(const char32_t(&&)[5]) = delete; // #dr1467-f-char32-5
void g() {
- f({"abc"}); // expected-error {{call to deleted function 'f'}}
- f({((("abc")))}); // expected-error {{call to deleted function 'f'}}
- f({L"abc"}); // expected-error {{call to deleted function 'f'}}
+ f({"abc"});
+ // since-cxx11-error at -1 {{call to deleted function 'f'}}
+ // since-cxx11-note@#dr1467-f-char-5 {{candidate function has been explicitly deleted}}
+ // since-cxx11-note@#dr1467-f-char-4 {{candidate function not viable: expects an rvalue for 1st argument}}
+ // since-cxx11-note@#dr1467-f-wchar-4 {{candidate function not viable: no known conversion from 'const char[4]' to 'const wchar_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-wchar-5 {{candidate function not viable: no known conversion from 'const char[4]' to 'const wchar_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char16-4 {{candidate function not viable: no known conversion from 'const char[4]' to 'const char16_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char16-5 {{candidate function not viable: no known conversion from 'const char[4]' to 'const char16_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char32-4 {{candidate function not viable: no known conversion from 'const char[4]' to 'const char32_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char32-5 {{candidate function not viable: no known conversion from 'const char[4]' to 'const char32_t' for 1st argument}}
+ f({((("abc")))});
+ // since-cxx11-error at -1 {{call to deleted function 'f'}}
+ // since-cxx11-note@#dr1467-f-char-5 {{candidate function has been explicitly deleted}}
+ // since-cxx11-note@#dr1467-f-char-4 {{candidate function not viable: expects an rvalue for 1st argument}}
+ // since-cxx11-note@#dr1467-f-wchar-4 {{candidate function not viable: no known conversion from 'const char[4]' to 'const wchar_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-wchar-5 {{candidate function not viable: no known conversion from 'const char[4]' to 'const wchar_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char16-4 {{candidate function not viable: no known conversion from 'const char[4]' to 'const char16_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char16-5 {{candidate function not viable: no known conversion from 'const char[4]' to 'const char16_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char32-4 {{candidate function not viable: no known conversion from 'const char[4]' to 'const char32_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char32-5 {{candidate function not viable: no known conversion from 'const char[4]' to 'const char32_t' for 1st argument}}
+ f({L"abc"});
+ // since-cxx11-error at -1 {{call to deleted function 'f'}}
+ // since-cxx11-note@#dr1467-f-wchar-5 {{candidate function has been explicitly deleted}}
+ // since-cxx11-note@#dr1467-f-char-4 {{candidate function not viable: no known conversion from 'const wchar_t[4]' to 'const char' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char-5 {{candidate function not viable: no known conversion from 'const wchar_t[4]' to 'const char' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-wchar-4 {{candidate function not viable: expects an rvalue for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char16-4 {{candidate function not viable: no known conversion from 'const wchar_t[4]' to 'const char16_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char16-5 {{candidate function not viable: no known conversion from 'const wchar_t[4]' to 'const char16_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char32-4 {{candidate function not viable: no known conversion from 'const wchar_t[4]' to 'const char32_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char32-5 {{candidate function not viable: no known conversion from 'const wchar_t[4]' to 'const char32_t' for 1st argument}}
#if __cplusplus >= 202002L
- f2({u8"abc"}); // expected-error {{call to deleted function 'f2'}}
+ f2({u8"abc"});
+ // since-cxx20-error at -1 {{call to deleted function 'f2'}}
+ // since-cxx20-note@#dr1467-f2-char8-5 {{candidate function has been explicitly deleted}}
+ // since-cxx20-note@#dr1467-f2-char8-4 {{candidate function not viable: expects an rvalue for 1st argument}}
#endif
- f({uR"(abc)"}); // expected-error {{call to deleted function 'f'}}
- f({(UR"(abc)")}); // expected-error {{call to deleted function 'f'}}
+ f({uR"(abc)"});
+ // since-cxx11-error at -1 {{call to deleted function 'f'}}
+ // since-cxx11-note@#dr1467-f-char16-5 {{candidate function has been explicitly deleted}}
+ // since-cxx11-note@#dr1467-f-char-4 {{candidate function not viable: no known conversion from 'const char16_t[4]' to 'const char' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char-5 {{candidate function not viable: no known conversion from 'const char16_t[4]' to 'const char' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-wchar-4 {{candidate function not viable: no known conversion from 'const char16_t[4]' to 'const wchar_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-wchar-5 {{candidate function not viable: no known conversion from 'const char16_t[4]' to 'const wchar_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char16-4 {{candidate function not viable: expects an rvalue for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char32-4 {{candidate function not viable: no known conversion from 'const char16_t[4]' to 'const char32_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char32-5 {{candidate function not viable: no known conversion from 'const char16_t[4]' to 'const char32_t' for 1st argument}}
+ f({(UR"(abc)")});
+ // since-cxx11-error at -1 {{call to deleted function 'f'}}
+ // since-cxx11-note@#dr1467-f-char32-5 {{candidate function has been explicitly deleted}}
+ // since-cxx11-note@#dr1467-f-char-4 {{candidate function not viable: no known conversion from 'const char32_t[4]' to 'const char' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char-5 {{candidate function not viable: no known conversion from 'const char32_t[4]' to 'const char' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-wchar-4 {{candidate function not viable: no known conversion from 'const char32_t[4]' to 'const wchar_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-wchar-5 {{candidate function not viable: no known conversion from 'const char32_t[4]' to 'const wchar_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char16-4 {{candidate function not viable: no known conversion from 'const char32_t[4]' to 'const char16_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char16-5 {{candidate function not viable: no known conversion from 'const char32_t[4]' to 'const char16_t' for 1st argument}}
+ // since-cxx11-note@#dr1467-f-char32-4 {{candidate function not viable: expects an rvalue for 1st argument}}
}
} // namespace StringLiterals
#endif
} // dr1467
namespace dr1479 { // dr1479: 3.1
- int operator"" _a(const char*, std::size_t = 0); // expected-error {{literal operator cannot have a default argument}}
+#if __cplusplus >= 201103L
+ int operator"" _a(const char*, std::size_t = 0);
+ // since-cxx11-error at -1 {{literal operator cannot have a default argument}}
+#endif
}
namespace dr1482 { // dr1482: 3.0
@@ -495,42 +610,59 @@ template <typename T> struct S {
typedef char I;
};
enum E2 : S<E2>::I { e };
-// expected-error at -1 {{use of undeclared identifier 'E2'}}
+// since-cxx11-error at -1 {{use of undeclared identifier 'E2'}}
#endif
} // namespace dr1482
namespace dr1490 { // dr1490: 3.7 c++11
+#if __cplusplus >= 201103L
// List-initialization from a string literal
- char s[4]{"abc"}; // Ok
- std::initializer_list<char>{"abc"}; // expected-error {{expected unqualified-id}}}
+ char s[4]{"abc"}; // Ok
+ std::initializer_list<char>{"abc"};
+ // since-cxx11-error at -1 {{expected unqualified-id}}}
+#endif
} // dr1490
namespace dr1495 { // dr1495: 4
+#if __cplusplus >= 201103L
// Deduction succeeds in both directions.
- template<typename T, typename U> struct A {}; // expected-note {{template is declared here}}
- template<typename T, typename U> struct A<U, T> {}; // expected-error {{class template partial specialization is not more specialized}}
+ template<typename T, typename U> struct A {}; // #dr1495-A
+ template<typename T, typename U> struct A<U, T> {};
+ // since-cxx11-error at -1 {{class template partial specialization is not more specialized than the primary template}}
+ // since-cxx11-note@#dr1495-A {{template is declared here}}
// Primary template is more specialized.
- template<typename, typename...> struct B {}; // expected-note {{template is declared here}}
- template<typename ...Ts> struct B<Ts...> {}; // expected-error {{not more specialized}}
+ template<typename, typename...> struct B {}; // #dr1495-B
+ template<typename ...Ts> struct B<Ts...> {};
+ // since-cxx11-error at -1 {{class template partial specialization is not more specialized than the primary template}}
+ // since-cxx11-note@#dr1495-B {{template is declared here}}
// Deduction fails in both directions.
- template<int, typename, typename ...> struct C {}; // expected-note {{template is declared here}}
- template<typename ...Ts> struct C<0, Ts...> {}; // expected-error {{not more specialized}}
+ template<int, typename, typename ...> struct C {}; // #dr1495-C
+ template<typename ...Ts> struct C<0, Ts...> {};
+ // since-cxx11-error at -1 {{class template partial specialization is not more specialized than the primary template}}
+ // since-cxx11-note@#dr1495-C {{template is declared here}}
#if __cplusplus >= 201402L
// Deduction succeeds in both directions.
- template<typename T, typename U> int a; // expected-note {{template is declared here}}
- template<typename T, typename U> int a<U, T>; // expected-error {{variable template partial specialization is not more specialized}}
+ template<typename T, typename U> int a; // #dr1495-a
+ template<typename T, typename U> int a<U, T>;
+ // since-cxx14-error at -1 {{variable template partial specialization is not more specialized than the primary template}}
+ // since-cxx14-note@#dr1495-a {{template is declared here}}
// Primary template is more specialized.
- template<typename, typename...> int b; // expected-note {{template is declared here}}
- template<typename ...Ts> int b<Ts...>; // expected-error {{not more specialized}}
+ template<typename, typename...> int b; // #dr1495-b
+ template<typename ...Ts> int b<Ts...>;
+ // since-cxx14-error at -1 {{variable template partial specialization is not more specialized than the primary template}}
+ // since-cxx14-note@#dr1495-b {{template is declared here}}
// Deduction fails in both directions.
- template<int, typename, typename ...> int c; // expected-note {{template is declared here}}
- template<typename ...Ts> int c<0, Ts...>; // expected-error {{not more specialized}}
+ template<int, typename, typename ...> int c; // #dr1495-c
+ template<typename ...Ts> int c<0, Ts...>;
+ // since-cxx14-error at -1 {{variable template partial specialization is not more specialized than the primary template}}
+ // since-cxx14-note@#dr1495-c {{template is declared here}}
+#endif
#endif
}
@@ -544,5 +676,3 @@ struct A {
static_assert(__is_trivial(A), "");
#endif
}
-
-#endif
diff --git a/clang/test/CXX/drs/dr15xx.cpp b/clang/test/CXX/drs/dr15xx.cpp
index a53b14694998bf..007b42c74affb1 100644
--- a/clang/test/CXX/drs/dr15xx.cpp
+++ b/clang/test/CXX/drs/dr15xx.cpp
@@ -1,13 +1,18 @@
// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify=expected,cxx14_17 -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify=expected,cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,cxx11-14 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,cxx11-14,cxx14-17 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx20,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx20,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2c -triple x86_64-unknown-unknown %s -verify=expected,since-cxx20,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr1512 { // dr1512: 4
void f(char *p) {
- if (p > 0) {} // expected-error {{ordered comparison between pointer and zero}}
+ if (p > 0) {}
+ // expected-error at -1 {{ordered comparison between pointer and zero ('char *' and 'int')}}
#if __cplusplus >= 201103L
- if (p > nullptr) {} // expected-error {{invalid operands}}
+ if (p > nullptr) {}
+ // since-cxx11-error at -1 {{invalid operands to binary expression ('char *' and 'std::nullptr_t')}}
#endif
}
bool g(int **x, const int **y) {
@@ -28,10 +33,20 @@ namespace dr1512 { // dr1512: 4
template<typename A, typename B, typename C> void composite_pointer_type_is_ord() {
composite_pointer_type_is_base<A, B, C>();
- typedef __typeof(val<A>() < val<B>()) cmp; // cxx17-warning 2 {{ordered comparison of function pointers}}
- typedef __typeof(val<A>() <= val<B>()) cmp; // cxx17-warning 2 {{ordered comparison of function pointers}}
- typedef __typeof(val<A>() > val<B>()) cmp; // cxx17-warning 2 {{ordered comparison of function pointers}}
- typedef __typeof(val<A>() >= val<B>()) cmp; // cxx17-warning 2 {{ordered comparison of function pointers}}
+ typedef __typeof(val<A>() < val<B>()) cmp; // #dr1512-lt
+ // since-cxx17-warning@#dr1512-lt {{ordered comparison of function pointers ('int (*)() noexcept' and 'int (*)()')}}
+ // since-cxx17-note@#dr1512-noexcept-1st {{in instantiation of function template specialization 'dr1512::composite_pointer_type_is_ord<int (*)() noexcept, int (*)(), int (*)()>' requested here}}
+ // since-cxx17-warning@#dr1512-lt {{ordered comparison of function pointers ('int (*)()' and 'int (*)() noexcept')}}
+ // since-cxx17-note@#dr1512-noexcept-2nd {{in instantiation of function template specialization 'dr1512::composite_pointer_type_is_ord<int (*)(), int (*)() noexcept, int (*)()>' requested here}}
+ typedef __typeof(val<A>() <= val<B>()) cmp;
+ // since-cxx17-warning at -1 {{ordered comparison of function pointers ('int (*)() noexcept' and 'int (*)()')}}
+ // since-cxx17-warning at -2 {{ordered comparison of function pointers ('int (*)()' and 'int (*)() noexcept')}}
+ typedef __typeof(val<A>() > val<B>()) cmp;
+ // since-cxx17-warning at -1 {{ordered comparison of function pointers ('int (*)() noexcept' and 'int (*)()')}}
+ // since-cxx17-warning at -2 {{ordered comparison of function pointers ('int (*)()' and 'int (*)() noexcept')}}
+ typedef __typeof(val<A>() >= val<B>()) cmp;
+ // since-cxx17-warning at -1 {{ordered comparison of function pointers ('int (*)() noexcept' and 'int (*)()')}}
+ // since-cxx17-warning at -2 {{ordered comparison of function pointers ('int (*)()' and 'int (*)() noexcept')}}
typedef bool cmp;
}
@@ -77,10 +92,11 @@ namespace dr1512 { // dr1512: 4
composite_pointer_type_is_unord<const int *B::*, volatile int *A::*, const volatile int *const B::*>();
no_composite_pointer_type<int (A::*)(), int (C::*)()>();
no_composite_pointer_type<const int (A::*)(), volatile int (C::*)()>();
+ // since-cxx20-warning at -1 {{volatile-qualified return type 'volatile int' is deprecated}}
-#if __cplusplus > 201402
- composite_pointer_type_is_ord<int (*)() noexcept, int (*)(), int (*)()>(); // expected-note {{requested here}}
- composite_pointer_type_is_ord<int (*)(), int (*)() noexcept, int (*)()>(); // expected-note {{requested here}}
+#if __cplusplus >= 201703L
+ composite_pointer_type_is_ord<int (*)() noexcept, int (*)(), int (*)()>(); // #dr1512-noexcept-1st
+ composite_pointer_type_is_ord<int (*)(), int (*)() noexcept, int (*)()>(); // #dr1512-noexcept-2nd
composite_pointer_type_is_unord<int (A::*)() noexcept, int (A::*)(), int (A::*)()>();
composite_pointer_type_is_unord<int (A::*)(), int (A::*)() noexcept, int (A::*)()>();
// FIXME: This looks like a standard defect; these should probably all have type 'int (B::*)()'.
@@ -113,24 +129,40 @@ namespace dr1512 { // dr1512: 4
}
#if __cplusplus >= 201103L
- template<typename T> struct Wrap { operator T(); }; // expected-note 4{{converted to type 'std::nullptr_t'}} expected-note 4{{converted to type 'int *'}}
+ template<typename T> struct Wrap { operator T(); }; // #dr1512-Wrap
void test_overload() {
using nullptr_t = decltype(nullptr);
void(Wrap<nullptr_t>() == Wrap<nullptr_t>());
void(Wrap<nullptr_t>() != Wrap<nullptr_t>());
- void(Wrap<nullptr_t>() < Wrap<nullptr_t>()); // expected-error {{invalid operands}}
- void(Wrap<nullptr_t>() > Wrap<nullptr_t>()); // expected-error {{invalid operands}}
- void(Wrap<nullptr_t>() <= Wrap<nullptr_t>()); // expected-error {{invalid operands}}
- void(Wrap<nullptr_t>() >= Wrap<nullptr_t>()); // expected-error {{invalid operands}}
+ void(Wrap<nullptr_t>() < Wrap<nullptr_t>());
+ // since-cxx11-error at -1 {{invalid operands to binary expression ('Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>') and 'Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>'))}}
+ void(Wrap<nullptr_t>() > Wrap<nullptr_t>());
+ // since-cxx11-error at -1 {{invalid operands to binary expression ('Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>') and 'Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>'))}}
+ void(Wrap<nullptr_t>() <= Wrap<nullptr_t>());
+ // since-cxx11-error at -1 {{invalid operands to binary expression ('Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>') and 'Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>'))}}
+ void(Wrap<nullptr_t>() >= Wrap<nullptr_t>());
+ // since-cxx11-error at -1 {{invalid operands to binary expression ('Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>') and 'Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>'))}}
// Under dr1213, this is ill-formed: we select the builtin operator<(int*, int*)
// but then only convert as far as 'nullptr_t', which we then can't convert to 'int*'.
void(Wrap<nullptr_t>() == Wrap<int*>());
void(Wrap<nullptr_t>() != Wrap<int*>());
- void(Wrap<nullptr_t>() < Wrap<int*>()); // expected-error {{invalid operands to binary expression ('Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>') and 'Wrap<int *>')}}
- void(Wrap<nullptr_t>() > Wrap<int*>()); // expected-error {{invalid operands}}
- void(Wrap<nullptr_t>() <= Wrap<int*>()); // expected-error {{invalid operands}}
- void(Wrap<nullptr_t>() >= Wrap<int*>()); // expected-error {{invalid operands}}
+ void(Wrap<nullptr_t>() < Wrap<int*>());
+ // since-cxx11-error at -1 {{invalid operands to binary expression ('Wrap<nullptr_t>' (aka 'Wrap<std::nullptr_t>') and 'Wrap<int *>')}}
+ // since-cxx11-note@#dr1512-Wrap {{first operand was implicitly converted to type 'std::nullptr_t'}}
+ // since-cxx11-note@#dr1512-Wrap {{second operand was implicitly converted to type 'int *'}}
+ void(Wrap<nullptr_t>() > Wrap<int*>());
+ // since-cxx11-error at -1 {{invalid operands}}
+ // since-cxx11-note@#dr1512-Wrap {{first operand was implicitly converted to type 'std::nullptr_t'}}
+ // since-cxx11-note@#dr1512-Wrap{{second operand was implicitly converted to type 'int *'}}
+ void(Wrap<nullptr_t>() <= Wrap<int*>());
+ // since-cxx11-error at -1 {{invalid operands}}
+ // since-cxx11-note@#dr1512-Wrap {{first operand was implicitly converted to type 'std::nullptr_t'}}
+ // since-cxx11-note@#dr1512-Wrap {{second operand was implicitly converted to type 'int *'}}
+ void(Wrap<nullptr_t>() >= Wrap<int*>());
+ // since-cxx11-error at -1 {{invalid operands}}
+ // since-cxx11-note@#dr1512-Wrap {{first operand was implicitly converted to type 'std::nullptr_t'}}
+ // since-cxx11-note@#dr1512-Wrap {{second operand was implicitly converted to type 'int *'}}
}
#endif
}
@@ -138,8 +170,10 @@ namespace dr1512 { // dr1512: 4
namespace dr1514 { // dr1514: 11
#if __cplusplus >= 201103L
struct S {
- enum E : int {}; // expected-note {{previous}}
- enum E : int {}; // expected-error {{redefinition}}
+ enum E : int {}; // #dr1514-E
+ enum E : int {};
+ // since-cxx11-error at -1 {{redefinition of 'E'}}
+ // since-cxx11-note@#dr1514-E {{previous definition is here}}
};
S::E se; // OK, complete type, not zero-width bitfield.
@@ -149,88 +183,139 @@ namespace dr1514 { // dr1514: 11
namespace dr1518 { // dr1518: 4
#if __cplusplus >= 201103L
-struct Z0 { // expected-note 0+ {{candidate}}
- explicit Z0() = default; // expected-note 0+ {{here}}
+struct Z0 { // #dr1518-Z0
+ explicit Z0() = default; // #dr1518-Z0-ctor
};
-struct Z { // expected-note 0+ {{candidate}}
- explicit Z(); // expected-note 0+ {{here}}
- explicit Z(int); // expected-note {{not a candidate}}
- explicit Z(int, int); // expected-note 0+ {{here}}
+struct Z { // #dr1518-Z
+ explicit Z(); // #dr1518-Z-ctor
+ explicit Z(int); // #dr1518-Z-int
+ explicit Z(int, int); // #dr1518-Z-int-int
};
-template <class T> int Eat(T); // expected-note 0+ {{candidate}}
+template <class T> int Eat(T); // #dr1518-Eat
Z0 a;
Z0 b{};
-Z0 c = {}; // expected-error {{explicit in copy-initialization}}
-int i = Eat<Z0>({}); // expected-error {{no matching function for call to 'Eat'}}
-
-Z c2 = {}; // expected-error {{explicit in copy-initialization}}
-int i2 = Eat<Z>({}); // expected-error {{no matching function for call to 'Eat'}}
-Z a1 = 1; // expected-error {{no viable conversion}}
+Z0 c = {};
+// since-cxx11-error at -1 {{chosen constructor is explicit in copy-initialization}}
+// since-cxx11-note@#dr1518-Z0-ctor {{explicit constructor declared here}}
+int i = Eat<Z0>({});
+// since-cxx11-error at -1 {{no matching function for call to 'Eat'}}
+// since-cxx11-note@#dr1518-Eat {{candidate function template not viable: cannot convert initializer list argument to 'Z0'}}
+
+Z c2 = {};
+// since-cxx11-error at -1 {{chosen constructor is explicit in copy-initialization}}
+// since-cxx11-note@#dr1518-Z-ctor {{explicit constructor declared here}}
+int i2 = Eat<Z>({});
+// since-cxx11-error at -1 {{no matching function for call to 'Eat'}}
+// since-cxx11-note@#dr1518-Eat {{candidate function template not viable: cannot convert initializer list argument to 'Z'}}
+Z a1 = 1;
+// since-cxx11-error at -1 {{no viable conversion from 'int' to 'Z'}}
+// since-cxx11-note@#dr1518-Z {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const Z &' for 1st argument}}
+// since-cxx11-note@#dr1518-Z {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'Z &&' for 1st argument}}
+// since-cxx11-note@#dr1518-Z-int {{explicit constructor is not a candidate}}
Z a3 = Z(1);
Z a2(1);
Z *p = new Z(1);
Z a4 = (Z)1;
Z a5 = static_cast<Z>(1);
-Z a6 = {4, 3}; // expected-error {{explicit in copy-initialization}}
+Z a6 = {4, 3};
+// since-cxx11-error at -1 {{chosen constructor is explicit in copy-initialization}}
+// since-cxx11-note@#dr1518-Z-int-int {{explicit constructor declared here}}
-struct UserProvidedBaseCtor { // expected-note 0+ {{candidate}}
+struct UserProvidedBaseCtor { // #dr1518-U
UserProvidedBaseCtor() {}
};
-struct DoesntInheritCtor : UserProvidedBaseCtor { // expected-note 0+ {{candidate}}
+struct DoesntInheritCtor : UserProvidedBaseCtor { // #dr1518-D-U
int x;
};
DoesntInheritCtor I{{}, 42};
-#if __cplusplus <= 201402L
-// expected-error at -2 {{no matching constructor}}
-#endif
-
-struct BaseCtor { BaseCtor() = default; }; // expected-note 0+ {{candidate}}
-struct InheritsCtor : BaseCtor { // expected-note 1+ {{candidate}}
- using BaseCtor::BaseCtor; // expected-note 2 {{inherited here}}
+// cxx11-14-error at -1 {{no matching constructor for initialization of 'DoesntInheritCtor'}}
+// cxx11-14-note@#dr1518-D-U {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 2 were provided}}
+// cxx11-14-note@#dr1518-D-U {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 2 were provided}}
+// cxx11-14-note@#dr1518-D-U {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 2 were provided}}
+
+struct BaseCtor { BaseCtor() = default; }; // #dr1518-BC
+struct InheritsCtor : BaseCtor { // #dr1518-I
+ using BaseCtor::BaseCtor; // #dr1518-I-using
int x;
};
-InheritsCtor II = {{}, 42}; // expected-error {{no matching constructor}}
+InheritsCtor II = {{}, 42};
+// since-cxx11-error at -1 {{no matching constructor for initialization of 'InheritsCtor'}}
+// since-cxx11-note@#dr1518-BC {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 2 were provided}}
+// since-cxx11-note@#dr1518-I-using {{constructor from base class 'BaseCtor' inherited here}}
+// since-cxx11-note@#dr1518-BC {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 2 were provided}}
+// since-cxx11-note@#dr1518-I-using {{constructor from base class 'BaseCtor' inherited here}}
+// since-cxx11-note@#dr1518-I {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 2 were provided}}
+// since-cxx11-note@#dr1518-I {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 2 were provided}}
+// since-cxx11-note@#dr1518-I {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 2 were provided}}
namespace std_example {
struct A {
- explicit A() = default; // expected-note 2{{declared here}}
+ explicit A() = default; // #dr1518-A
};
struct B : A {
- explicit B() = default; // expected-note 2{{declared here}}
+ explicit B() = default; // #dr1518-B
};
struct C {
- explicit C(); // expected-note 2{{declared here}}
+ explicit C(); // #dr1518-C
};
struct D : A {
C c;
- explicit D() = default; // expected-note 2{{declared here}}
+ explicit D() = default; // #dr1518-D
};
template <typename T> void f() {
T t; // ok
T u{}; // ok
- T v = {}; // expected-error 4{{explicit}}
+ T v = {}; // #dr1518-v
+ // since-cxx11-error@#dr1518-v {{chosen constructor is explicit in copy-initialization}}
+ // since-cxx11-note@#dr1518-f-A {{in instantiation of function template specialization 'dr1518::std_example::f<dr1518::std_example::A>' requested here}}
+ // since-cxx11-note@#dr1518-A {{explicit constructor declared here}}
+ // since-cxx11-error@#dr1518-v {{chosen constructor is explicit in copy-initialization}}
+ // since-cxx11-note@#dr1518-f-B {{in instantiation of function template specialization 'dr1518::std_example::f<dr1518::std_example::B>' requested here}}
+ // since-cxx11-note@#dr1518-B {{explicit constructor declared here}}
+ // since-cxx11-error@#dr1518-v {{chosen constructor is explicit in copy-initialization}}
+ // since-cxx11-note@#dr1518-f-C {{in instantiation of function template specialization 'dr1518::std_example::f<dr1518::std_example::C>' requested here}}
+ // since-cxx11-note@#dr1518-C {{explicit constructor declared here}}
+ // since-cxx11-error@#dr1518-v {{chosen constructor is explicit in copy-initialization}}
+ // since-cxx11-note@#dr1518-f-D {{in instantiation of function template specialization 'dr1518::std_example::f<dr1518::std_example::D>' requested here}}
+ // since-cxx11-note@#dr1518-D {{explicit constructor declared here}}
}
template <typename T> void g() {
- void x(T t); // expected-note 4{{parameter}}
- x({}); // expected-error 4{{explicit}}
+ void x(T t); // #dr1518-x
+ x({}); // #dr1518-x-call
+ // since-cxx11-error@#dr1518-x-call {{chosen constructor is explicit in copy-initialization}}
+ // since-cxx11-note@#dr1518-g-A {{in instantiation of function template specialization 'dr1518::std_example::g<dr1518::std_example::A>' requested here}}
+ // since-cxx11-note@#dr1518-A {{explicit constructor declared here}}
+ // since-cxx11-note@#dr1518-x {{passing argument to parameter 't' here}}
+ // since-cxx11-error@#dr1518-x-call {{chosen constructor is explicit in copy-initialization}}
+ // since-cxx11-note@#dr1518-g-B {{in instantiation of function template specialization 'dr1518::std_example::g<dr1518::std_example::B>' requested here}}
+ // since-cxx11-note@#dr1518-B {{explicit constructor declared here}}
+ // since-cxx11-note@#dr1518-x {{passing argument to parameter 't' here}}
+ // since-cxx11-error@#dr1518-x-call {{chosen constructor is explicit in copy-initialization}}
+ // since-cxx11-note@#dr1518-g-C {{in instantiation of function template specialization 'dr1518::std_example::g<dr1518::std_example::C>' requested here}}
+ // since-cxx11-note@#dr1518-C {{explicit constructor declared here}}
+ // since-cxx11-note@#dr1518-x {{passing argument to parameter 't' here}}
+ // since-cxx11-error@#dr1518-x-call {{chosen constructor is explicit in copy-initialization}}
+ // since-cxx11-note@#dr1518-g-D {{in instantiation of function template specialization 'dr1518::std_example::g<dr1518::std_example::D>' requested here}}
+ // since-cxx11-note@#dr1518-D {{explicit constructor declared here}}
+ // since-cxx11-note@#dr1518-x {{passing argument to parameter 't' here}}
}
void test() {
- f<A>(); // expected-note {{instantiation of}}
- f<B>(); // expected-note {{instantiation of}}
- f<C>(); // expected-note {{instantiation of}}
- f<D>(); // expected-note {{instantiation of}}
- g<A>(); // expected-note {{instantiation of}}
- g<B>(); // expected-note {{instantiation of}}
- g<C>(); // expected-note {{instantiation of}}
- g<D>(); // expected-note {{instantiation of}}
+ f<A>(); // #dr1518-f-A
+ f<B>(); // #dr1518-f-B
+ f<C>(); // #dr1518-f-C
+ f<D>(); // #dr1518-f-D
+ g<A>(); // #dr1518-g-A
+ g<B>(); // #dr1518-g-B
+ g<C>(); // #dr1518-g-C
+ g<D>(); // #dr1518-g-D
}
}
-#endif // __cplusplus >= 201103L
+#endif // __cplusplus >= 201103L
}
namespace dr1550 { // dr1550: 3.4
@@ -242,13 +327,16 @@ namespace dr1550 { // dr1550: 3.4
namespace dr1558 { // dr1558: 12
#if __cplusplus >= 201103L
template<class T, class...> using first_of = T;
- template<class T> first_of<void, typename T::type> f(int); // expected-note {{'int' cannot be used prior to '::'}}
- template<class T> void f(...) = delete; // expected-note {{deleted}}
+ template<class T> first_of<void, typename T::type> f(int); // #dr1558-f
+ template<class T> void f(...) = delete; // #dr1558-f-deleted
struct X { typedef void type; };
void test() {
f<X>(0);
- f<int>(0); // expected-error {{deleted}}
+ f<int>(0);
+ // since-cxx11-error at -1 {{call to deleted function 'f'}}
+ // since-cxx11-note@#dr1558-f-deleted {{candidate function [with T = int] has been explicitly deleted}}
+ // since-cxx11-note@#dr1558-f {{candidate template ignored: substitution failure [with T = int]: type 'int' cannot be used prior to '::' because it has no members}}
}
#endif
}
@@ -283,17 +371,25 @@ namespace dr1573 { // dr1573: 3.9
struct C { C(); constexpr C(int) {} };
struct D : C { using C::C; };
constexpr D d = D(0); // ok
- struct E : C { using C::C; A a; }; // expected-note {{non-literal type}}
- constexpr E e = E(0); // expected-error {{non-literal type}}
+ struct E : C { using C::C; A a; }; // #dr1573-E
+ constexpr E e = E(0);
+ // since-cxx11-error at -1 {{constexpr variable cannot have non-literal type 'const E'}}
+ // since-cxx11-note@#dr1573-E {{'E' is not literal because it has data member 'a' of non-literal type 'A'}}
+
// FIXME: This diagnostic is pretty bad; we should explain that the problem
// is that F::c would be initialized by a non-constexpr constructor.
- struct F : C { using C::C; C c; }; // expected-note {{here}}
- constexpr F f = F(0); // expected-error {{constant expression}} expected-note {{constructor inherited from base class 'C'}}
+ struct F : C { using C::C; C c; }; // #dr1573-F
+ constexpr F f = F(0);
+ // since-cxx11-error at -1 {{constexpr variable 'f' must be initialized by a constant expression}}
+ // since-cxx11-note at -2 {{constructor inherited from base class 'C' cannot be used in a constant expression; derived class cannot be implicitly initialized}}
+ // since-cxx11-note@#dr1573-F {{declared here}}
// inherited constructor is effectively deleted if the user-written constructor would be
struct G { G(int); };
- struct H : G { using G::G; G g; }; // expected-note {{constructor inherited by 'H' is implicitly deleted because field 'g' has no default constructor}}
- H h(0); // expected-error {{constructor inherited by 'H' from base class 'G' is implicitly deleted}}
+ struct H : G { using G::G; G g; }; // #dr1573-H
+ H h(0);
+ // since-cxx11-error at -1 {{constructor inherited by 'H' from base class 'G' is implicitly deleted}}
+ // since-cxx11-note@#dr1573-H {{constructor inherited by 'H' is implicitly deleted because field 'g' has no default constructor}}
#endif
}
@@ -336,13 +432,15 @@ namespace std {
typedef basic_string<char> string;
} // std
+#endif
namespace dr1579 { // dr1579: 3.9
+#if __cplusplus >= 201103L
template<class T>
struct GenericMoveOnly {
GenericMoveOnly();
- template<class U> GenericMoveOnly(const GenericMoveOnly<U> &) = delete; // expected-note 5 {{marked deleted here}}
- GenericMoveOnly(const int &) = delete; // expected-note 2 {{marked deleted here}}
+ template<class U> GenericMoveOnly(const GenericMoveOnly<U> &) = delete; // #dr1579-deleted-U
+ GenericMoveOnly(const int &) = delete; // #dr1579-deleted-int
template<class U> GenericMoveOnly(GenericMoveOnly<U> &&);
GenericMoveOnly(int &&);
};
@@ -369,17 +467,29 @@ GenericMoveOnly<float> DR1579_Ineligible(int &AnInt,
extern GenericMoveOnly<char> ExternMove;
if (0)
- return AnInt; // expected-error{{invokes a deleted function}}
+ return AnInt;
+ // since-cxx11-error at -1 {{conversion function from 'int' to 'GenericMoveOnly<float>' invokes a deleted function}}
+ // since-cxx11-note@#dr1579-deleted-int {{'GenericMoveOnly' has been explicitly marked deleted here}}
else if (0)
- return GlobalMO; // expected-error{{invokes a deleted function}}
+ return GlobalMO;
+ // since-cxx11-error at -1 {{conversion function from 'GenericMoveOnly<char>' to 'GenericMoveOnly<float>' invokes a deleted function}}
+ // since-cxx11-note@#dr1579-deleted-U {{'GenericMoveOnly<char>' has been explicitly marked deleted here}}
else if (0)
- return StaticMove; // expected-error{{invokes a deleted function}}
+ return StaticMove;
+ // since-cxx11-error at -1 {{conversion function from 'GenericMoveOnly<char>' to 'GenericMoveOnly<float>' invokes a deleted function}}
+ // since-cxx11-note@#dr1579-deleted-U {{'GenericMoveOnly<char>' has been explicitly marked deleted here}}
else if (0)
- return ExternMove; // expected-error{{invokes a deleted function}}
+ return ExternMove;
+ // since-cxx11-error at -1 {{conversion function from 'GenericMoveOnly<char>' to 'GenericMoveOnly<float>' invokes a deleted function}}
+ // since-cxx11-note@#dr1579-deleted-U {{'GenericMoveOnly<char>' has been explicitly marked deleted here}}
else if (0)
- return AnInt; // expected-error{{invokes a deleted function}}
+ return AnInt;
+ // since-cxx11-error at -1 {{conversion function from 'int' to 'GenericMoveOnly<float>' invokes a deleted function}}
+ // since-cxx11-note@#dr1579-deleted-int {{'GenericMoveOnly' has been explicitly marked deleted here}}
else
- return CharMO; // expected-error{{invokes a deleted function}}
+ return CharMO;
+ // since-cxx11-error at -1 {{conversion function from 'GenericMoveOnly<char>' to 'GenericMoveOnly<float>' invokes a deleted function}}
+ // since-cxx11-note@#dr1579-deleted-U {{'GenericMoveOnly<char>' has been explicitly marked deleted here}}
}
auto DR1579_lambda_valid = [](GenericMoveOnly<float> mo) ->
@@ -389,24 +499,34 @@ auto DR1579_lambda_valid = [](GenericMoveOnly<float> mo) ->
auto DR1579_lambda_invalid = []() -> GenericMoveOnly<char> {
static GenericMoveOnly<float> mo;
- return mo; // expected-error{{invokes a deleted function}}
+ return mo;
+ // since-cxx11-error at -1 {{conversion function from 'GenericMoveOnly<float>' to 'GenericMoveOnly<char>' invokes a deleted function}}
+ // since-cxx11-note@#dr1579-deleted-U {{'GenericMoveOnly<float>' has been explicitly marked deleted here}}
};
+#endif
} // end namespace dr1579
namespace dr1584 {
+#if __cplusplus >= 201103L
// Deducing function types from cv-qualified types
- template<typename T> void f(const T *); // expected-note {{candidate template ignored}}
+ template<typename T> void f(const T *); // #dr1584-f
template<typename T> void g(T *, const T * = 0);
- template<typename T> void h(T *) { T::error; } // expected-error {{no members}}
+ template<typename T> void h(T *) { T::error; }
+ // since-cxx11-error at -1 {{type 'void ()' cannot be used prior to '::' because it has no members}}
+ // since-cxx11-note@#dr1584-h {{in instantiation of function template specialization 'dr1584::h<void ()>' requested here}}
template<typename T> void h(const T *);
void i() {
- f(&i); // expected-error {{no matching function}}
+ f(&i);
+ // since-cxx11-error at -1 {{no matching function for call to 'f'}}
+ // since-cxx11-note@#dr1584-f {{candidate template ignored: could not match 'const T *' against 'void (*)()'}}
g(&i);
- h(&i); // expected-note {{here}}
+ h(&i); // #dr1584-h
}
+#endif
}
namespace dr1589 { // dr1589: 3.7 c++11
+#if __cplusplus >= 201103L
// Ambiguous ranking of list-initialization sequences
void f0(long, int=0); // Would makes selection of #0 ambiguous
@@ -425,25 +545,35 @@ namespace dr1589 { // dr1589: 3.7 c++11
void g2() { f2({"foo","bar"}); } // chooses #4
namespace with_error {
- void f0(long); // #0
- void f0(std::initializer_list<int>); // #00 expected-note {{candidate function}}
- void f0(std::initializer_list<int>, int = 0); // expected-note {{candidate function}}
- void g0() { f0({1L}); } // expected-error{{call to 'f0' is ambiguous}}
-
- void f1(int); // #1
- void f1(std::initializer_list<long>); // #2 expected-note {{candidate function}}
- void f1(std::initializer_list<long>, int = 0); // expected-note {{candidate function}}
- void g1() { f1({42}); } // expected-error{{call to 'f1' is ambiguous}}
-
- void f2(std::pair<const char*, const char*>); // #3
- void f2(std::initializer_list<std::string>); // #4 expected-note {{candidate function}}
- void f2(std::initializer_list<std::string>, int = 0); // expected-note {{candidate function}}
- void g2() { f2({"foo","bar"}); } // expected-error{{call to 'f2' is ambiguous}}
+ void f0(long);
+ void f0(std::initializer_list<int>); // #dr1589-f0-ilist
+ void f0(std::initializer_list<int>, int = 0); // #dr1589-f0-ilist-int
+ void g0() { f0({1L}); }
+ // since-cxx11-error at -1 {{call to 'f0' is ambiguous}}
+ // since-cxx11-note@#dr1589-f0-ilist {{candidate function}}
+ // since-cxx11-note@#dr1589-f0-ilist-int {{candidate function}}
+
+ void f1(int);
+ void f1(std::initializer_list<long>); // #dr1589-f1-ilist
+ void f1(std::initializer_list<long>, int = 0); // #dr1589-f1-ilist-long
+ void g1() { f1({42}); }
+ // since-cxx11-error at -1 {{call to 'f1' is ambiguous}}
+ // since-cxx11-note@#dr1589-f1-ilist {{candidate function}}
+ // since-cxx11-note@#dr1589-f1-ilist-long {{candidate function}}
+
+ void f2(std::pair<const char*, const char*>);
+ void f2(std::initializer_list<std::string>); // #dr1589-f2-ilist
+ void f2(std::initializer_list<std::string>, int = 0); // #dr1589-f2-ilist-int
+ void g2() { f2({"foo","bar"}); }
+ // since-cxx11-error at -1 {{call to 'f2' is ambiguous}}
+ // since-cxx11-note@#dr1589-f2-ilist {{candidate function}}
+ // since-cxx11-note@#dr1589-f2-ilist-int {{candidate function}}
}
-
+#endif
} // dr1589
-namespace dr1591 { //dr1591. Deducing array bound and element type from initializer list
+namespace dr1591 { //dr1591. Deducing array bound and element type from initializer list
+#if __cplusplus >= 201103L
template<class T, int N> int h(T const(&)[N]);
int X = h({1,2,3}); // T deduced to int, N deduced to 3
@@ -451,8 +581,10 @@ namespace dr1591 { //dr1591. Deducing array bound and element type from initial
int Y = j({42}); // T deduced to int, array bound not considered
struct Aggr { int i; int j; };
- template<int N> int k(Aggr const(&)[N]); //expected-note{{not viable}}
- int Y0 = k({1,2,3}); //expected-error{{no matching function}}
+ template<int N> int k(Aggr const(&)[N]); // #dr1591-k
+ int Y0 = k({1,2,3});
+ // since-cxx11-error at -1 {{no matching function for call to 'k'}}
+ // since-cxx11-note@#dr1591-k {{candidate function [with N = 3] not viable: no known conversion from 'int' to 'const Aggr' for 1st argument}}
int Z = k({{1},{2},{3}}); // OK, N deduced to 3
template<int M, int N> int m(int const(&)[M][N]);
@@ -463,54 +595,64 @@ namespace dr1591 { //dr1591. Deducing array bound and element type from initial
namespace check_multi_dim_arrays {
- template<class T, int N, int M, int O> int ***f(const T (&a)[N][M][O]); //expected-note{{deduced conflicting values}}
- template<class T, int N, int M> int **f(const T (&a)[N][M]); //expected-note{{couldn't infer}}
+ template<class T, int N, int M, int O> int ***f(const T (&a)[N][M][O]); // #dr1591-f-3
+ template<class T, int N, int M> int **f(const T (&a)[N][M]); // #dr1591-f-2
- template<class T, int N> int *f(const T (&a)[N]); //expected-note{{couldn't infer}}
+ template<class T, int N> int *f(const T (&a)[N]); // #dr1591-f-1
int ***p3 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12} } });
- int ***p33 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12, 13} } }); //expected-error{{no matching}}
+ int ***p33 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12, 13} } });
+ // since-cxx11-error at -1 {{no matching function for call to 'f'}}
+ // since-cxx11-note@#dr1591-f-2 {{candidate template ignored: couldn't infer template argument 'T'}}
+ // since-cxx11-note@#dr1591-f-1 {{candidate template ignored: couldn't infer template argument 'T'}}
+ // since-cxx11-note@#dr1591-f-3 {{candidate template ignored: deduced conflicting values for parameter 'O' (2 vs. 3)}}
int **p2 = f({ {1,2,3}, {3, 4, 5} });
int **p22 = f({ {1,2}, {3, 4} });
int *p1 = f({1, 2, 3});
}
namespace check_multi_dim_arrays_rref {
- template<class T, int N, int M, int O> int ***f(T (&&a)[N][M][O]); //expected-note{{deduced conflicting values}}
- template<class T, int N, int M> int **f(T (&&a)[N][M]); //expected-note{{couldn't infer}}
+ template<class T, int N, int M, int O> int ***g(T (&&a)[N][M][O]); // #dr1591-g-3
+ template<class T, int N, int M> int **g(T (&&a)[N][M]); // #dr1591-g-2
- template<class T, int N> int *f(T (&&a)[N]); //expected-note{{couldn't infer}}
- int ***p3 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12} } });
- int ***p33 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12, 13} } }); //expected-error{{no matching}}
- int **p2 = f({ {1,2,3}, {3, 4, 5} });
- int **p22 = f({ {1,2}, {3, 4} });
- int *p1 = f({1, 2, 3});
+ template<class T, int N> int *g(T (&&a)[N]); // #dr1591-g-1
+ int ***p3 = g({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12} } });
+ int ***p33 = g({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12, 13} } });
+ // since-cxx11-error at -1 {{no matching function for call to 'g'}}
+ // since-cxx11-note@#dr1591-g-2 {{candidate template ignored: couldn't infer template argument 'T'}}
+ // since-cxx11-note@#dr1591-g-1 {{candidate template ignored: couldn't infer template argument 'T'}}
+ // since-cxx11-note@#dr1591-g-3 {{candidate template ignored: deduced conflicting values for parameter 'O' (2 vs. 3)}}
+ int **p2 = g({ {1,2,3}, {3, 4, 5} });
+ int **p22 = g({ {1,2}, {3, 4} });
+ int *p1 = g({1, 2, 3});
}
namespace check_arrays_of_init_list {
- template<class T, int N> float *f(const std::initializer_list<T> (&)[N]);
- template<class T, int N> double *f(const T(&)[N]);
- double *p = f({1, 2, 3});
- float *fp = f({{1}, {1, 2}, {1, 2, 3}});
+ template<class T, int N> float *h(const std::initializer_list<T> (&)[N]);
+ template<class T, int N> double *h(const T(&)[N]);
+ double *p = h({1, 2, 3});
+ float *fp = h({{1}, {1, 2}, {1, 2, 3}});
}
namespace core_reflector_28543 {
- template<class T, int N> int *f(T (&&)[N]); // #1
- template<class T> char *f(std::initializer_list<T> &&); //#2
- template<class T, int N, int M> int **f(T (&&)[N][M]); //#3 expected-note{{candidate}}
- template<class T, int N> char **f(std::initializer_list<T> (&&)[N]); //#4 expected-note{{candidate}}
+ template<class T, int N> int *i(T (&&)[N]); // #1
+ template<class T> char *i(std::initializer_list<T> &&); // #2
+ template<class T, int N, int M> int **i(T (&&)[N][M]); // #3 #dr1591-i-2
+ template<class T, int N> char **i(std::initializer_list<T> (&&)[N]); // #4 #dr1591-i-1
- template<class T> short *f(T (&&)[2]); //#5
+ template<class T> short *i(T (&&)[2]); // #5
template<class T> using Arr = T[];
- char *pc = f({1, 2, 3}); // OK prefer #2 via 13.3.3.2 [over.ics.rank]
- char *pc2 = f({1, 2}); // #2 also
- int *pi = f(Arr<int>{1, 2, 3}); // OK prefer #1
+ char *pc = i({1, 2, 3}); // OK prefer #2 via 13.3.3.2 [over.ics.rank]
+ char *pc2 = i({1, 2}); // #2 also
+ int *pi = i(Arr<int>{1, 2, 3}); // OK prefer #1
- void *pv1 = f({ {1, 2, 3}, {4, 5, 6} }); // expected-error{{ambiguous}} btw 3 & 4
- char **pcc = f({ {1}, {2, 3} }); // OK #4
+ void *pv1 = i({ {1, 2, 3}, {4, 5, 6} }); // ambiguous btw 3 & 4
+ // since-cxx11-error at -1 {{call to 'i' is ambiguous}}
+ // since-cxx11-note@#dr1591-i-2 {{candidate function [with T = int, N = 2, M = 3]}}
+ // since-cxx11-note@#dr1591-i-1 {{candidate function [with T = int, N = 2]}}
+ char **pcc = i({ {1}, {2, 3} }); // OK #4
- short *ps = f(Arr<int>{1, 2}); // OK #5
+ short *ps = i(Arr<int>{1, 2}); // OK #5
}
-} // dr1591
-
#endif
+} // dr1591
diff --git a/clang/test/CXX/drs/dr16xx.cpp b/clang/test/CXX/drs/dr16xx.cpp
index cbf0b487ba1557..3f074c4d57354a 100644
--- a/clang/test/CXX/drs/dr16xx.cpp
+++ b/clang/test/CXX/drs/dr16xx.cpp
@@ -1,12 +1,14 @@
-// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++2a -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-
-#if __cplusplus < 201103L
-// expected-error at +1 {{variadic macro}}
+// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify=expected,cxx98-14,cxx98 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify=expected,cxx98-14,since-cxx11,cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx14,cxx98-14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx14,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx14,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx14,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2c -triple x86_64-unknown-unknown %s -verify=expected,since-cxx14,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+
+#if __cplusplus == 199711L
#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
+// cxx98-error at -1 {{variadic macros are a C99 feature}}
#endif
#if __cplusplus >= 201103L
@@ -25,9 +27,7 @@ namespace std {
namespace dr1601 { // dr1601: 10
enum E : char { e };
-#if __cplusplus < 201103L
- // expected-error at -2 {{enumeration types with a fixed underlying type are a C++11 extension}}
-#endif
+// cxx98-error at -1 {{enumeration types with a fixed underlying type are a C++11 extension}}
void f(char);
void f(int);
void g() {
@@ -53,16 +53,20 @@ namespace dr1631 { // dr1631: 3.7
void f(int, A);
void test() {
- f({0}, {{1}}); // expected-warning {{braces around scalar init}}
+ f({0}, {{1}});
+ // since-cxx11-warning at -1 {{braces around scalar initializer}}
}
namespace with_error {
void f(B, int); // TODO: expected- note {{candidate function}}
- void f(int, A); // expected-note {{candidate function}}
- void f(int, A, int = 0); // expected-note {{candidate function}}
+ void f(int, A); // #dr1631-f
+ void f(int, A, int = 0); // #dr1631-f-int
void test() {
- f({0}, {{1}}); // expected-error{{call to 'f' is ambiguous}}
+ f({0}, {{1}});
+ // since-cxx11-error at -1 {{call to 'f' is ambiguous}}
+ // since-cxx11-note@#dr1631-f {{candidate function}}
+ // since-cxx11-note@#dr1631-f-int {{candidate function}}
}
}
#endif
@@ -71,8 +75,8 @@ namespace dr1631 { // dr1631: 3.7
namespace dr1638 { // dr1638: 3.1
#if __cplusplus >= 201103L
template<typename T> struct A {
- enum class E; // expected-note {{previous}}
- enum class F : T; // expected-note 2{{previous}}
+ enum class E; // #dr1638-E
+ enum class F : T; // #dr1638-F
};
template<> enum class A<int>::E;
@@ -83,16 +87,27 @@ namespace dr1638 { // dr1638: 3.1
template<> enum class A<short>::E : int;
template<> enum class A<short>::E : int {};
- template<> enum class A<short>::F; // expected-error {{
diff erent underlying type}}
- template<> enum class A<char>::E : char; // expected-error {{
diff erent underlying type}}
- template<> enum class A<char>::F : int; // expected-error {{
diff erent underlying type}}
-
- enum class A<unsigned>::E; // expected-error {{template specialization requires 'template<>'}} expected-error {{nested name specifier}}
- template enum class A<unsigned>::E; // expected-error {{enumerations cannot be explicitly instantiated}}
- enum class A<unsigned>::E *e; // expected-error {{must use 'enum' not 'enum class'}}
+ template<> enum class A<short>::F;
+ // since-cxx11-error at -1 {{enumeration redeclared with
diff erent underlying type 'int' (was 'short')}}
+ // since-cxx11-note@#dr1638-F {{previous declaration is here}}
+ template<> enum class A<char>::E : char;
+ // since-cxx11-error at -1 {{enumeration redeclared with
diff erent underlying type 'char' (was 'int')}}
+ // since-cxx11-note@#dr1638-E {{previous declaration is here}}
+ template<> enum class A<char>::F : int;
+ // since-cxx11-error at -1 {{enumeration redeclared with
diff erent underlying type 'int' (was 'char')}}
+ // since-cxx11-note@#dr1638-F {{previous declaration is here}}
+
+ enum class A<unsigned>::E;
+ // since-cxx11-error at -1 {{template specialization requires 'template<>'}}
+ // since-cxx11-error at -2 {{forward declaration of enum class cannot have a nested name specifier}}
+ template enum class A<unsigned>::E;
+ // since-cxx11-error at -1 {{enumerations cannot be explicitly instantiated}}
+ enum class A<unsigned>::E *e;
+ // since-cxx11-error at -1 {{reference to enumeration must use 'enum' not 'enum class'}}
struct B {
- friend enum class A<unsigned>::E; // expected-error {{must use 'enum' not 'enum class'}}
+ friend enum class A<unsigned>::E;
+ // since-cxx11-error at -1 {{reference to enumeration must use 'enum' not 'enum class'}}
};
#endif
}
@@ -100,37 +115,50 @@ namespace dr1638 { // dr1638: 3.1
namespace dr1645 { // dr1645: 3.9
#if __cplusplus >= 201103L
struct A {
- constexpr A(int, float = 0); // expected-note {{candidate}}
- explicit A(int, int = 0); // expected-note 2{{candidate}}
- A(int, int, int = 0) = delete; // expected-note {{candidate}}
+ constexpr A(int, float = 0); // #dr1645-int-float
+ explicit A(int, int = 0); // #dr1645-int-int
+ A(int, int, int = 0) = delete; // #dr1645-int-int-int
};
struct B : A {
- using A::A; // expected-note 4{{inherited here}}
+ using A::A; // #dr1645-using
};
- constexpr B a(0); // expected-error {{ambiguous}}
- constexpr B b(0, 0); // expected-error {{ambiguous}}
+ constexpr B a(0);
+ // since-cxx11-error at -1 {{call to constructor of 'const B' is ambiguous}}
+ // since-cxx11-note@#dr1645-int-float {{candidate inherited constructor}}
+ // since-cxx11-note@#dr1645-using {{constructor from base class 'A' inherited here}}
+ // since-cxx11-note@#dr1645-int-int {{candidate inherited constructor}}
+ // since-cxx11-note@#dr1645-using {{constructor from base class 'A' inherited here}}
+ constexpr B b(0, 0);
+ // since-cxx11-error at -1 {{call to constructor of 'const B' is ambiguous}}
+ // since-cxx11-note@#dr1645-int-int {{candidate inherited constructor}}
+ // since-cxx11-note@#dr1645-using {{constructor from base class 'A' inherited here}}
+ // since-cxx11-note@#dr1645-int-int-int {{candidate inherited constructor has been explicitly deleted}}
+ // since-cxx11-note@#dr1645-using {{constructor from base class 'A' inherited here}}
#endif
}
namespace dr1652 { // dr1652: 3.6
int a, b;
- int arr[&a + 1 == &b ? 1 : 2]; // expected-error 2{{variable length array}}
- // expected-note at -1 {{points past the end}}
+ int arr[&a + 1 == &b ? 1 : 2];
+ // expected-error at -1 {{variable length arrays in C++ are a Clang extension}}
+ // expected-note at -2 {{comparison against pointer '&a + 1' that points past the end of a complete object has unspecified value}}
+ // expected-error at -3 {{variable length array declaration not allowed at file scope}}
}
namespace dr1653 { // dr1653: 4 c++17
void f(bool b) {
++b;
+ // cxx98-14-warning at -1 {{incrementing expression of type bool is deprecated and incompatible with C++17}}
+ // since-cxx17-error at -2 {{SO C++17 does not allow incrementing expression of type bool}}
b++;
-#if __cplusplus <= 201402L
- // expected-warning at -3 {{deprecated}} expected-warning at -2 {{deprecated}}
-#else
- // expected-error at -5 {{incrementing expression of type bool}} expected-error at -4 {{incrementing expression of type bool}}
-#endif
- --b; // expected-error {{cannot decrement expression of type bool}}
- b--; // expected-error {{cannot decrement expression of type bool}}
+ // cxx98-14-warning at -1 {{incrementing expression of type bool is deprecated and incompatible with C++17}}
+ // since-cxx17-error at -2 {{SO C++17 does not allow incrementing expression of type bool}}
+ --b;
+ // expected-error at -1 {{cannot decrement expression of type bool}}
+ b--;
+ // expected-error at -1 {{cannot decrement expression of type bool}}
b += 1; // ok
b -= 1; // ok
}
@@ -138,71 +166,88 @@ namespace dr1653 { // dr1653: 4 c++17
namespace dr1658 { // dr1658: 5
namespace DefCtor {
- class A { A(); }; // expected-note 0-2{{here}}
- class B { ~B(); }; // expected-note 0-2{{here}}
+ class A { A(); }; // #dr1658-A1
+ class B { ~B(); }; // #dr1658-B1
// The stars align! An abstract class does not construct its virtual bases.
struct C : virtual A { C(); virtual void foo() = 0; };
- C::C() = default; // ok, not deleted, expected-error 0-1{{extension}}
+ C::C() = default; // ok, not deleted
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
struct D : virtual B { D(); virtual void foo() = 0; };
- D::D() = default; // ok, not deleted, expected-error 0-1{{extension}}
+ D::D() = default; // ok, not deleted
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
// In all other cases, we are not so lucky.
- struct E : A { E(); virtual void foo() = 0; };
-#if __cplusplus < 201103L
- E::E() = default; // expected-error {{private default constructor}} expected-error {{extension}} expected-note {{here}}
-#else
- E::E() = default; // expected-error {{would delete}} expected-note at -4{{inaccessible default constructor}}
-#endif
- struct F : virtual A { F(); };
-#if __cplusplus < 201103L
- F::F() = default; // expected-error {{private default constructor}} expected-error {{extension}} expected-note {{here}}
-#else
- F::F() = default; // expected-error {{would delete}} expected-note at -4{{inaccessible default constructor}}
-#endif
-
- struct G : B { G(); virtual void foo() = 0; };
-#if __cplusplus < 201103L
- G::G() = default; // expected-error at -2 {{private destructor}} expected-error {{extension}} expected-note {{here}}
-#else
- G::G() = default; // expected-error {{would delete}} expected-note at -4{{inaccessible destructor}}
-#endif
- struct H : virtual B { H(); };
-#if __cplusplus < 201103L
- H::H() = default; // expected-error at -2 {{private destructor}} expected-error {{extension}} expected-note {{here}}
-#else
- H::H() = default; // expected-error {{would delete}} expected-note at -4{{inaccessible destructor}}
-#endif
+ struct E : A { E(); virtual void foo() = 0; }; // #dr1658-E1
+ E::E() = default; // #dr1658-E1-ctor
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error at -2 {{base class 'A' has private default constructor}}
+ // cxx98-note at -3 {{in defaulted default constructor for 'dr1658::DefCtor::E' first required here}}
+ // cxx98-note@#dr1658-A1 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-E1-ctor {{defaulting this default constructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-E1 {{default constructor of 'E' is implicitly deleted because base class 'A' has an inaccessible default constructor}}
+ struct F : virtual A { F(); }; // #dr1658-F1
+ F::F() = default; // #dr1658-F1-ctor
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error at -2 {{inherited virtual base class 'A' has private default constructor}}
+ // cxx98-note at -3 {{in defaulted default constructor for 'dr1658::DefCtor::F' first required here}}
+ // cxx98-note@#dr1658-A1 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-F1-ctor {{defaulting this default constructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-F1 {{default constructor of 'F' is implicitly deleted because base class 'A' has an inaccessible default constructor}}
+
+ struct G : B { G(); virtual void foo() = 0; }; // #dr1658-G1
+ G::G() = default; // #dr1658-G1-ctor
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error@#dr1658-G1 {{base class 'B' has private destructor}}
+ // cxx98-note@#dr1658-G1-ctor {{in defaulted default constructor for 'dr1658::DefCtor::G' first required here}}
+ // cxx98-note@#dr1658-B1 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-G1-ctor {{defaulting this default constructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-G1 {{default constructor of 'G' is implicitly deleted because base class 'B' has an inaccessible destructor}}
+ struct H : virtual B { H(); }; // #dr1658-H1
+ H::H() = default; // #dr1658-H1-ctor
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error@#dr1658-H1 {{base class 'B' has private destructor}}
+ // cxx98-note@#dr1658-H1-ctor {{in defaulted default constructor for 'dr1658::DefCtor::H' first required here}}
+ // cxx98-note@#dr1658-B1 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-H1-ctor {{defaulting this default constructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-H1 {{default constructor of 'H' is implicitly deleted because base class 'B' has an inaccessible destructor}}
}
namespace Dtor {
- class B { ~B(); }; // expected-note 0-2{{here}}
+ class B { ~B(); }; // #dr1658-B2
struct D : virtual B { ~D(); virtual void foo() = 0; };
- D::~D() = default; // ok, not deleted, expected-error 0-1{{extension}}
-
- struct G : B { ~G(); virtual void foo() = 0; };
-#if __cplusplus < 201103L
- G::~G() = default; // expected-error at -2 {{private destructor}} expected-error {{extension}} expected-note {{here}}
-#else
- G::~G() = default; // expected-error {{would delete}} expected-note at -4{{inaccessible destructor}}
-#endif
- struct H : virtual B { ~H(); };
-#if __cplusplus < 201103L
- H::~H() = default; // expected-error at -2 {{private destructor}} expected-error {{extension}} expected-note {{here}}
-#else
- H::~H() = default; // expected-error {{would delete}} expected-note at -4{{inaccessible destructor}}
-#endif
+ D::~D() = default; // ok, not deleted
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+
+ struct G : B { ~G(); virtual void foo() = 0; }; // #dr1658-G2
+ G::~G() = default; // #dr1658-G2-dtor
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error@#dr1658-G2 {{base class 'B' has private destructor}}
+ // cxx98-note@#dr1658-G2-dtor {{in defaulted destructor for 'dr1658::Dtor::G' first required here}}
+ // cxx98-note@#dr1658-B2 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-G2-dtor {{defaulting this destructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-G2 {{destructor of 'G' is implicitly deleted because base class 'B' has an inaccessible destructor}}
+ struct H : virtual B { ~H(); }; // #dr1658-H2
+ H::~H() = default; // #dr1658-H2-dtor
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error@#dr1658-H2 {{base class 'B' has private destructor}}
+ // cxx98-note@#dr1658-H2-dtor {{in defaulted destructor for 'dr1658::Dtor::H' first required here}}
+ // cxx98-note@#dr1658-B2 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-H2-dtor {{defaulting this destructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-H2 {{destructor of 'H' is implicitly deleted because base class 'B' has an inaccessible destructor}}
}
namespace MemInit {
- struct A { A(int); }; // expected-note {{here}}
+ struct A { A(int); }; // #dr1658-A3
struct B : virtual A {
B() {}
virtual void f() = 0;
};
struct C : virtual A {
- C() {} // expected-error {{must explicitly initialize}}
+ C() {}
+ // expected-error at -1 {{constructor for 'dr1658::MemInit::C' must explicitly initialize the base class 'A' which does not have a default constructor}}
+ // expected-note@#dr1658-A3 {{'dr1658::MemInit::A' declared here}}
};
}
@@ -220,28 +265,51 @@ namespace dr1658 { // dr1658: 5
}
namespace CopyCtor {
- class A { A(const A&); A(A&&); }; // expected-note 0-4{{here}} expected-error 0-1{{extension}}
-
- struct C : virtual A { C(const C&); C(C&&); virtual void foo() = 0; }; // expected-error 0-1{{extension}}
- C::C(const C&) = default; // expected-error 0-1{{extension}}
- C::C(C&&) = default; // expected-error 0-2{{extension}}
-
- struct E : A { E(const E&); E(E&&); virtual void foo() = 0; }; // expected-error 0-1{{extension}}
-#if __cplusplus < 201103L
- E::E(const E&) = default; // expected-error {{private copy constructor}} expected-error {{extension}} expected-note {{here}}
- E::E(E&&) = default; // expected-error {{private move constructor}} expected-error 2{{extension}} expected-note {{here}}
-#else
- E::E(const E&) = default; // expected-error {{would delete}} expected-note at -5{{inaccessible copy constructor}}
- E::E(E&&) = default; // expected-error {{would delete}} expected-note at -6{{inaccessible move constructor}}
-#endif
- struct F : virtual A { F(const F&); F(F&&); }; // expected-error 0-1{{extension}}
-#if __cplusplus < 201103L
- F::F(const F&) = default; // expected-error {{private copy constructor}} expected-error {{extension}} expected-note {{here}}
- F::F(F&&) = default; // expected-error {{private move constructor}} expected-error 2{{extension}} expected-note {{here}}
-#else
- F::F(const F&) = default; // expected-error {{would delete}} expected-note at -5{{inaccessible copy constructor}}
- F::F(F&&) = default; // expected-error {{would delete}} expected-note at -6{{inaccessible move constructor}}
-#endif
+ class A { A(const A&); A(A&&); }; // #dr1658-A5
+ // cxx98-error at -1 {{rvalue references are a C++11 extension}}
+
+ struct C : virtual A { C(const C&); C(C&&); virtual void foo() = 0; };
+ // cxx98-error at -1 {{rvalue references are a C++11 extension}}
+ C::C(const C&) = default;
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+ C::C(C&&) = default;
+ // cxx98-error at -1 {{rvalue references are a C++11 extension}}
+ // cxx98-error at -2 {{defaulted function definitions are a C++11 extension}}
+
+ struct E : A { E(const E&); E(E&&); virtual void foo() = 0; }; // #dr1658-E5
+ // cxx98-error at -1 {{rvalue references are a C++11 extension}}
+ E::E(const E&) = default; // #dr1658-E5-copy-ctor
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error at -2 {{base class 'A' has private copy constructor}}
+ // cxx98-note at -3 {{in defaulted copy constructor for 'dr1658::CopyCtor::E' first required here}}
+ // cxx98-note@#dr1658-A5 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-E5-copy-ctor {{defaulting this copy constructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-E5 {{copy constructor of 'E' is implicitly deleted because base class 'A' has an inaccessible copy constructor}}
+ E::E(E&&) = default; // #dr1658-E5-move-ctor
+ // cxx98-error at -1 {{rvalue references are a C++11 extension}}
+ // cxx98-error at -2 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error at -3 {{base class 'A' has private move constructor}}
+ // cxx98-note at -4 {{in defaulted move constructor for 'dr1658::CopyCtor::E' first required here}}
+ // cxx98-note@#dr1658-A5 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-E5-move-ctor {{defaulting this move constructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-E5 {{move constructor of 'E' is implicitly deleted because base class 'A' has an inaccessible move constructor}}
+ struct F : virtual A { F(const F&); F(F&&); }; // #dr1658-F5
+ // cxx98-error at -1 {{rvalue references are a C++11 extension}}
+ F::F(const F&) = default; // #dr1658-F5-copy-ctor
+ // cxx98-error at -1 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error at -2 {{inherited virtual base class 'A' has private copy constructor}}
+ // cxx98-note at -3 {{in defaulted copy constructor for 'dr1658::CopyCtor::F' first required here}}
+ // cxx98-note@#dr1658-A5 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-F5-copy-ctor {{defaulting this copy constructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-F5 {{copy constructor of 'F' is implicitly deleted because base class 'A' has an inaccessible copy constructor}}
+ F::F(F&&) = default; // #dr1658-F5-move-ctor
+ // cxx98-error at -1 {{rvalue references are a C++11 extension}}
+ // cxx98-error at -2 {{defaulted function definitions are a C++11 extension}}
+ // cxx98-error at -3 {{inherited virtual base class 'A' has private move constructor}}
+ // cxx98-note at -4 {{in defaulted move constructor for 'dr1658::CopyCtor::F' first required here}}
+ // cxx98-note@#dr1658-A5 {{implicitly declared private here}}
+ // since-cxx11-error@#dr1658-F5-move-ctor {{defaulting this move constructor would delete it after its first declaration}}
+ // since-cxx11-note@#dr1658-F5 {{move constructor of 'F' is implicitly deleted because base class 'A' has an inaccessible move constructor}}
}
// assignment case is superseded by dr2180
@@ -274,31 +342,38 @@ namespace dr1672 { // dr1672: 7
namespace dr1684 { // dr1684: 3.6
#if __cplusplus >= 201103L
- struct NonLiteral { // expected-note {{because}}
+ struct NonLiteral { // #dr1684-struct
NonLiteral();
- constexpr int f() { return 0; } // expected-warning 0-1{{will not be implicitly 'const'}}
+ constexpr int f() { return 0; }
+ // cxx11-warning at -1 {{'constexpr' non-static member function will not be implicitly 'const' in C++14; add 'const' to avoid a change in behavior}}
};
constexpr int f(NonLiteral &) { return 0; }
- constexpr int f(NonLiteral) { return 0; } // expected-error {{not a literal type}}
+ constexpr int f(NonLiteral) { return 0; }
+ // since-cxx11-error at -1 {{constexpr function's 1st parameter type 'NonLiteral' is not a literal type}}
+ // since-cxx11-note@#dr1684-struct {{'NonLiteral' is not literal because it is not an aggregate and has no constexpr constructors other than copy or move constructors}}
#endif
}
namespace dr1687 { // dr1687: 7
template<typename T> struct To {
- operator T(); // expected-note 2{{first operand was implicitly converted to type 'int *'}}
- // expected-note at -1 {{second operand was implicitly converted to type 'double'}}
-#if __cplusplus > 201703L
- // expected-note at -3 2{{operand was implicitly converted to type 'dr1687::E}}
-#endif
+ operator T(); // #dr1687-op-T
};
- int *a = To<int*>() + 100.0; // expected-error {{invalid operands to binary expression ('To<int *>' and 'double')}}
- int *b = To<int*>() + To<double>(); // expected-error {{invalid operands to binary expression ('To<int *>' and 'To<double>')}}
+ int *a = To<int*>() + 100.0;
+ // expected-error at -1 {{invalid operands to binary expression ('To<int *>' and 'double')}}
+ // expected-note@#dr1687-op-T {{first operand was implicitly converted to type 'int *'}}
+ // since-cxx20-note@#dr1687-op-T {{second operand was implicitly converted to type 'dr1687::E2'}}
+ int *b = To<int*>() + To<double>();
+ // expected-error at -1 {{invalid operands to binary expression ('To<int *>' and 'To<double>')}}
+ // expected-note@#dr1687-op-T {{first operand was implicitly converted to type 'int *'}}
+ // expected-note@#dr1687-op-T {{second operand was implicitly converted to type 'double'}}
-#if __cplusplus > 201703L
+#if __cplusplus >= 202002L
enum E1 {};
enum E2 {};
- auto c = To<E1>() <=> To<E2>(); // expected-error {{invalid operands to binary expression ('To<E1>' and 'To<E2>')}}
+ auto c = To<E1>() <=> To<E2>();
+ // since-cxx20-error at -1 {{invalid operands to binary expression ('To<E1>' and 'To<E2>')}}
+ // since-cxx20-note@#dr1687-op-T {{operand was implicitly converted to type 'dr1687::E}}
#endif
}
@@ -325,12 +400,14 @@ namespace dr1691 { // dr1691: 9
void f(E);
}
enum M::E : int {};
- void g(M::E); // expected-note {{declared here}}
+ void g(M::E); // #dr1691-g
}
void test() {
N::M::E e;
f(e); // ok
- g(e); // expected-error {{use of undeclared}}
+ g(e);
+ // since-cxx11-error at -1 {{use of undeclared identifier 'g'; did you mean 'N::g'?}}
+ // since-cxx11-note@#dr1691-g {{'N::g' declared here}}
}
#endif
}
@@ -356,7 +433,9 @@ namespace dr1696 { // dr1696: 7
extern struct A a;
struct A {
const A &x = { A{a, a} };
- const A &y = { A{} }; // expected-error {{default member initializer for 'y' needed within definition of enclosing class 'A' outside of member functions}} expected-note {{here}}
+ const A &y = { A{} };
+ // since-cxx14-error at -1 {{default member initializer for 'y' needed within definition of enclosing class 'A' outside of member functions}}
+ // since-cxx14-note at -2 {{default member initializer declared here}}
};
A a{a, a};
#endif
@@ -365,16 +444,20 @@ namespace dr1696 { // dr1696: 7
struct A { A(); ~A(); };
#if __cplusplus >= 201103L
struct B {
- A &&a; // expected-note {{declared here}}
- B() : a{} {} // expected-error {{reference member 'a' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ A &&a; // #dr1696-a
+ B() : a{} {}
+ // since-cxx11-error at -1 {{reference member 'a' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // since-cxx11-note@#dr1696-a {{reference member declared here}}
} b;
#endif
struct C {
C();
- const A &a; // expected-note {{declared here}}
+ const A &a; // #dr1696-C-a
};
- C::C() : a(A()) {} // expected-error {{reference member 'a' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ C::C() : a(A()) {}
+ // expected-error at -1 {{reference member 'a' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // expected-note@#dr1696-C-a {{reference member declared here}}
#if __cplusplus >= 201103L
// This is OK in C++14 onwards, per DR1815, though we don't support that yet:
@@ -383,51 +466,62 @@ namespace dr1696 { // dr1696: 7
// D1 d1 = {A()};
// ... which lifetime-extends the A temporary.
struct D1 {
-#if __cplusplus < 201402L
- // expected-error at -2 {{binds to a temporary}}
-#endif
- const A &a = A(); // expected-note {{default member init}}
+ // cxx11-error at -1 {{reference member 'a' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // cxx11-note@#dr1696-d1 {{in implicit default constructor for 'dr1696::D1' first required here}}
+ // cxx11-note@#dr1696-D1-a {{initializing field 'a' with default member initializer}}
+ const A &a = A(); // #dr1696-D1-a
};
- D1 d1 = {};
-#if __cplusplus < 201402L
- // expected-note at -2 {{first required here}}
-#else
- // expected-warning-re at -4 {{sorry, lifetime extension {{.*}} not supported}}
-#endif
+ D1 d1 = {}; // #dr1696-d1
+ // since-cxx14-warning at -1 {{sorry, lifetime extension of temporary created by aggregate initialization using default member initializer is not supported; lifetime of temporary will end at the end of the full-expression}}
+ // since-cxx14-note@#dr1696-D1-a {{initializing field 'a' with default member initializer}}
struct D2 {
- const A &a = A(); // expected-note {{default member init}}
- D2() {} // expected-error {{binds to a temporary}}
+ const A &a = A(); // #dr1696-D2-a
+ D2() {}
+ // since-cxx11-error at -1 {{reference member 'a' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // since-cxx11-note@#dr1696-D2-a {{initializing field 'a' with default member initializer}}
};
- struct D3 { // expected-error {{binds to a temporary}}
- const A &a = A(); // expected-note {{default member init}}
+ struct D3 {
+ // since-cxx11-error at -1 {{reference member 'a' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // since-cxx11-note@#dr1696-d3 {{in implicit default constructor for 'dr1696::D3' first required here}}
+ // since-cxx11-note@#dr1696-D3-a {{initializing field 'a' with default member initializer}}
+ const A &a = A(); // #dr1696-D3-a
};
- D3 d3; // expected-note {{first required here}}
+ D3 d3; // #dr1696-d3
struct haslist1 {
- std::initializer_list<int> il; // expected-note {{'std::initializer_list' member}}
- haslist1(int i) : il{i, 2, 3} {} // expected-error {{backing array for 'std::initializer_list' member 'il' is a temporary object}}
+ std::initializer_list<int> il; // #dr1696-il-1
+ haslist1(int i) : il{i, 2, 3} {}
+ // since-cxx11-error at -1 {{backing array for 'std::initializer_list' member 'il' is a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // since-cxx11-note@#dr1696-il-1 {{'std::initializer_list' member declared here}}
};
struct haslist2 {
- std::initializer_list<int> il; // expected-note {{'std::initializer_list' member}}
+ std::initializer_list<int> il; // #dr1696-il-2
haslist2();
};
- haslist2::haslist2() : il{1, 2} {} // expected-error {{backing array for 'std::initializer_list' member 'il' is a temporary object}}
+ haslist2::haslist2() : il{1, 2} {}
+ // since-cxx11-error at -1 {{backing array for 'std::initializer_list' member 'il' is a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // since-cxx11-note@#dr1696-il-2 {{'std::initializer_list' member declared here}}
struct haslist3 {
std::initializer_list<int> il = {1, 2, 3};
};
- struct haslist4 { // expected-error {{backing array for 'std::initializer_list' member 'il' is a temporary object}}
- std::initializer_list<int> il = {1, 2, 3}; // expected-note {{default member initializer}}
+ struct haslist4 {
+ // since-cxx11-error at -1 {{backing array for 'std::initializer_list' member 'il' is a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // since-cxx11-note@#dr1696-hl4 {{in implicit default constructor for 'dr1696::haslist4' first required here}}
+ // since-cxx11-note@#dr1696-il-4 {{initializing field 'il' with default member initializer}}
+ std::initializer_list<int> il = {1, 2, 3}; // #dr1696-il-4
};
- haslist4 hl4; // expected-note {{in implicit default constructor}}
+ haslist4 hl4; // #dr1696-hl4
struct haslist5 {
- std::initializer_list<int> il = {1, 2, 3}; // expected-note {{default member initializer}}
- haslist5() {} // expected-error {{backing array for 'std::initializer_list' member 'il' is a temporary object}}
+ std::initializer_list<int> il = {1, 2, 3}; // #dr1696-il-5
+ haslist5() {}
+ // since-cxx11-error at -1 {{backing array for 'std::initializer_list' member 'il' is a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // since-cxx11-note@#dr1696-il-5 {{nitializing field 'il' with default member initializer}}
};
#endif
}
diff --git a/clang/test/CXX/drs/dr17xx.cpp b/clang/test/CXX/drs/dr17xx.cpp
index 219119d1a4cd08..0c44fb231ce51a 100644
--- a/clang/test/CXX/drs/dr17xx.cpp
+++ b/clang/test/CXX/drs/dr17xx.cpp
@@ -1,10 +1,10 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++2c %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2c %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr1710 { // dr1710: no
// FIXME: all of the following is well-formed
@@ -32,13 +32,17 @@ namespace dr1715 { // dr1715: 3.9
struct D : B {
using B::B;
};
- struct E : B { // expected-note 2{{candidate}}
- template<class T> E(T t, typename T::Q q) : B(t, q) {} // expected-note {{'Q' is a private member}}
+ struct E : B { // #dr1715-E
+ template<class T> E(T t, typename T::Q q) : B(t, q) {} // #dr1715-E-ctor
};
B b(S(), 1);
D d(S(), 2);
- E e(S(), 3); // expected-error {{no match}}
+ E e(S(), 3);
+ // since-cxx11-error at -1 {{no matching constructor for initialization of 'E'}}
+ // since-cxx11-note@#dr1715-E-ctor {{candidate template ignored: substitution failure [with T = S]: 'Q' is a private member of 'dr1715::S'}}
+ // since-cxx11-note@#dr1715-E {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 2 were provided}}
+ // since-cxx11-note@#dr1715-E {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 2 were provided}}
#endif
}
@@ -73,12 +77,15 @@ struct S {
struct L : S {
using S::S;
};
- typename T::type value; // expected-error {{no member}}
- L l(value); // expected-note {{instantiation of}}
+ typename T::type value;
+ // since-cxx11-error at -1 {{type 'int' cannot be used prior to '::' because it has no members}}
+ // since-cxx11-note@#dr1736-l {{in instantiation of function template specialization 'dr1736::S::S<int>' requested here}}
+ // since-cxx11-note@#dr1736-s {{in instantiation of function template specialization 'dr1736::S::S<dr1736::Q>' requested here}}
+ L l(value); // #dr1736-l
}
};
struct Q { typedef int type; } q;
-S s(q); // expected-note {{instantiation of}}
+S s(q); // #dr1736-s
#endif
}
@@ -91,18 +98,23 @@ namespace dr1753 { // dr1753: 11
n.~T();
n.T::~T();
- n.dr1753::~T(); // expected-error {{'dr1753' does not refer to a type name in pseudo-destructor}}
+ n.dr1753::~T();
+ // expected-error at -1 {{'dr1753' does not refer to a type name in pseudo-destructor expression; expected the name of type 'T' (aka 'int')}}
n.dr1753::T::~T();
- n.A::~T(); // expected-error {{the type of object expression ('T' (aka 'int')) does not match the type being destroyed ('A') in pseudo-destructor expression}}
+ n.A::~T();
+ // expected-error at -1 {{the type of object expression ('T' (aka 'int')) does not match the type being destroyed ('A') in pseudo-destructor expression}}
n.A::T::~T();
- n.B::~T(); // expected-error {{'B' does not refer to a type name in pseudo-destructor expression}}
+ n.B::~T();
+ // expected-error at -1 {{'B' does not refer to a type name in pseudo-destructor expression; expected the name of type 'T' (aka 'int')}}
n.B::T::~T();
#if __cplusplus >= 201103L
- n.decltype(n)::~T(); // expected-error {{not a class, namespace, or enumeration}}
- n.T::~decltype(n)(); // expected-error {{expected a class name after '~'}}
+ n.decltype(n)::~T();
+ // since-cxx11-error at -1 {{'decltype(n)' (aka 'int') is not a class, namespace, or enumeration}}
+ n.T::~decltype(n)();
+ // since-cxx11-error at -1 {{expected a class name after '~' to name a destructor}}
n.~decltype(n)(); // OK
#endif
}
@@ -141,9 +153,9 @@ namespace dr1758 { // dr1758: 3.7
namespace dr1762 { // dr1762: 14
#if __cplusplus >= 201103L
float operator ""_E(const char *);
- // expected-error at +2 {{invalid suffix on literal; C++11 requires a space between literal and identifier}}
- // expected-warning at +1 {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
float operator ""E(const char *);
+ // since-cxx11-error at -1 {{invalid suffix on literal; C++11 requires a space between literal and identifier}}
+ // since-cxx11-warning at -2 {{user-defined literal suffixes not starting with '_' are reserved; no literal will invoke this operator}}
#endif
}
diff --git a/clang/test/CXX/drs/dr18xx.cpp b/clang/test/CXX/drs/dr18xx.cpp
index 49c11672208752..fbe67bd0c2f6db 100644
--- a/clang/test/CXX/drs/dr18xx.cpp
+++ b/clang/test/CXX/drs/dr18xx.cpp
@@ -1,14 +1,14 @@
-// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++2c -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
-
-#if __cplusplus < 201103L
-// expected-error at +1 {{variadic macro}}
+// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify=expected,cxx98 -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify=expected,cxx11-17,since-cxx11 -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify=expected,cxx11-17,since-cxx11,since-cxx14 -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify=expected,cxx11-17,since-cxx11,since-cxx14 -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx20,since-cxx11,since-cxx14 -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx20,since-cxx11,since-cxx14 -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2c -triple x86_64-unknown-unknown %s -verify=expected,since-cxx20,since-cxx11,since-cxx14 -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
+
+#if __cplusplus == 199711L
#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
+// cxx98-error at -1 {{variadic macros are a C99 feature}}
#endif
namespace dr1812 { // dr1812: no
@@ -16,7 +16,7 @@ namespace dr1812 { // dr1812: no
#if __cplusplus >= 201103L
template <typename T> struct A {
using B = typename T::C<int>;
- // expected-error at -1 {{use 'template' keyword to treat 'C' as a dependent template name}}
+ // since-cxx11-error at -1 {{use 'template' keyword to treat 'C' as a dependent template name}}
};
#endif
} // namespace dr1812
@@ -54,11 +54,16 @@ namespace dr1814 { // dr1814: yes
namespace dr1815 { // dr1815: no
#if __cplusplus >= 201402L
// FIXME: needs codegen test
- struct A { int &&r = 0; }; // expected-note {{default member init}}
- A a = {}; // FIXME expected-warning {{not supported}}
-
- struct B { int &&r = 0; }; // expected-error {{binds to a temporary}} expected-note {{default member init}}
- B b; // expected-note {{here}}
+ struct A { int &&r = 0; }; // #dr1815-A
+ A a = {};
+ // since-cxx14-warning at -1 {{sorry, lifetime extension of temporary created by aggregate initialization using default member initializer is not supported; lifetime of temporary will end at the end of the full-expression}} FIXME
+ // since-cxx14-note@#dr1815-A {{initializing field 'r' with default member initializer}}
+
+ struct B { int &&r = 0; }; // #dr1815-B
+ // since-cxx14-error at -1 {{reference member 'r' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
+ // since-cxx14-note@#dr1815-B {{initializing field 'r' with default member initializer}}
+ // since-cxx14-note@#dr1815-b {{in implicit default constructor for 'dr1815::B' first required here}}
+ B b; // #dr1815-b
#endif
}
@@ -80,9 +85,9 @@ struct A {
namespace dr1822 { // dr1822: yes
#if __cplusplus >= 201103L
- int a;
+ double a;
auto x = [] (int a) {
-#pragma clang __debug dump a // CHECK: ParmVarDecl
+ static_assert(__is_same(decltype(a), int), "should be resolved to lambda parameter");
};
#endif
}
@@ -98,16 +103,22 @@ namespace dr1837 { // dr1837: 3.3
};
class Outer {
- friend auto Other::q() -> decltype(this->p()) *; // expected-error {{invalid use of 'this'}}
+ friend auto Other::q() -> decltype(this->p()) *;
+ // since-cxx11-error at -1 {{invalid use of 'this' outside of a non-static member function}}
int g();
int f() {
extern void f(decltype(this->g()) *);
struct Inner {
- static_assert(Fish<decltype(this->g())>::value, ""); // expected-error {{invalid use of 'this'}}
- enum { X = Fish<decltype(this->f())>::value }; // expected-error {{invalid use of 'this'}}
- struct Inner2 : Fish<decltype(this->g())> { }; // expected-error {{invalid use of 'this'}}
- friend void f(decltype(this->g()) *); // expected-error {{invalid use of 'this'}}
- friend auto Other::q() -> decltype(this->p()) *; // expected-error {{invalid use of 'this'}}
+ static_assert(Fish<decltype(this->g())>::value, "");
+ // since-cxx11-error at -1 {{invalid use of 'this' outside of a non-static member function}}
+ enum { X = Fish<decltype(this->f())>::value };
+ // since-cxx11-error at -1 {{invalid use of 'this' outside of a non-static member function}}
+ struct Inner2 : Fish<decltype(this->g())> { };
+ // since-cxx11-error at -1 {{invalid use of 'this' outside of a non-static member function}}
+ friend void f(decltype(this->g()) *);
+ // since-cxx11-error at -1 {{invalid use of 'this' outside of a non-static member function}}
+ friend auto Other::q() -> decltype(this->p()) *;
+ // since-cxx11-error at -1 {{invalid use of 'this' outside of a non-static member function}}
};
return 0;
}
@@ -135,19 +146,21 @@ namespace dr1872 { // dr1872: 9
constexpr int x = A<X>().f();
constexpr int y = A<Y>().f();
-#if __cplusplus <= 201703L
- // expected-error at -2 {{constant expression}} expected-note at -2 {{call to virtual function}}
-#else
+ // cxx11-17-error at -1 {{constexpr variable 'y' must be initialized by a constant expression}}
+ // cxx11-17-note at -2 {{cannot evaluate call to virtual function in a constant expression in C++ standards before C++20}}
+#if __cplusplus >= 202002L
static_assert(y == 0);
#endif
// Note, this is invalid even though it would not use virtual dispatch.
constexpr int y2 = A<Y>().A<Y>::f();
-#if __cplusplus <= 201703L
- // expected-error at -2 {{constant expression}} expected-note at -2 {{call to virtual function}}
-#else
+ // cxx11-17-error at -1 {{constexpr variable 'y2' must be initialized by a constant expression}}
+ // cxx11-17-note at -2 {{cannot evaluate call to virtual function in a constant expression in C++ standards before C++20}}
+#if __cplusplus >= 202002L
static_assert(y == 0);
#endif
- constexpr int z = A<Z>().f(); // expected-error {{constant expression}} expected-note {{non-literal type}}
+ constexpr int z = A<Z>().f();
+ // since-cxx11-error at -1 {{constexpr variable 'z' must be initialized by a constant expression}}
+ // since-cxx11-note at -2 {{non-literal type 'A<Z>' cannot be used in a constant expression}}
#endif
}
@@ -166,33 +179,38 @@ namespace dr1881 { // dr1881: 7
void dr1891() { // dr1891: 4
#if __cplusplus >= 201103L
int n;
- auto a = []{}; // expected-note 0-4{{}}
- auto b = [=]{ return n; }; // expected-note 0-4{{}}
+ auto a = []{}; // #dr1891-a
+ auto b = [=]{ return n; }; // #dr1891-b
typedef decltype(a) A;
typedef decltype(b) B;
static_assert(!__has_trivial_constructor(A), "");
-#if __cplusplus > 201703L
- // expected-error at -2 {{failed}}
-#endif
+ // since-cxx20-error at -1 {{failed}}
static_assert(!__has_trivial_constructor(B), "");
// C++20 allows default construction for non-capturing lambdas (P0624R2).
A x;
-#if __cplusplus <= 201703L
- // expected-error at -2 {{no matching constructor}}
-#endif
- B y; // expected-error {{no matching constructor}}
+ // cxx11-17-error at -1 {{no matching constructor for initialization of 'A' (aka '(lambda at}}
+ // cxx11-17-note@#dr1891-a {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided}}
+ // cxx11-17-note@#dr1891-a {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided}}
+ B y;
+ // since-cxx11-error at -1 {{no matching constructor for initialization of 'B' (aka '(lambda at}}
+ // since-cxx11-note@#dr1891-b {{candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided}}
+ // since-cxx11-note@#dr1891-b {{candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided}}
// C++20 allows assignment for non-capturing lambdas (P0624R2).
a = a;
+ // cxx11-17-error-re at -1 {{{{object of type '\(lambda at .+\)' cannot be assigned because its copy assignment operator is implicitly deleted}}}}
+ // cxx11-17-note@#dr1891-a {{lambda expression begins here}}
a = static_cast<A&&>(a);
-#if __cplusplus <= 201703L
- // expected-error at -3 {{copy assignment operator is implicitly deleted}}
- // expected-error at -3 {{copy assignment operator is implicitly deleted}}
-#endif
- b = b; // expected-error {{copy assignment operator is implicitly deleted}}
- b = static_cast<B&&>(b); // expected-error {{copy assignment operator is implicitly deleted}}
+ // cxx11-17-error-re at -1 {{{{object of type '\(lambda at .+\)' cannot be assigned because its copy assignment operator is implicitly deleted}}}}
+ // cxx11-17-note@#dr1891-a {{lambda expression begins here}}
+ b = b;
+ // since-cxx11-error-re at -1 {{{{object of type '\(lambda at .+\)' cannot be assigned because its copy assignment operator is implicitly deleted}}}}
+ // since-cxx11-note@#dr1891-b {{lambda expression begins here}}
+ b = static_cast<B&&>(b);
+ // since-cxx11-error-re at -1 {{{{object of type '\(lambda at .+\)' cannot be assigned because its copy assignment operator is implicitly deleted}}}}
+ // since-cxx11-note@#dr1891-b {{lambda expression begins here}}
#endif
}
diff --git a/clang/test/CXX/drs/dr19xx.cpp b/clang/test/CXX/drs/dr19xx.cpp
index 73aa20cc58e2d1..716b1476831ed9 100644
--- a/clang/test/CXX/drs/dr19xx.cpp
+++ b/clang/test/CXX/drs/dr19xx.cpp
@@ -1,41 +1,36 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected,cxx98-11,cxx98 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx98-11,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2c %s -verify=expected,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
namespace std { struct type_info; }
namespace dr1902 { // dr1902: 3.7
struct A {};
struct B {
- B(A);
-#if __cplusplus >= 201103L
- // expected-note at -2 {{candidate}}
-#endif
-
- B() = delete;
-#if __cplusplus < 201103L
- // expected-error at -2 {{extension}}
-#endif
-
- B(const B&) // expected-note {{deleted here}}
-#if __cplusplus >= 201103L
- // expected-note at -2 {{candidate}}
-#else
- // expected-error at +2 {{extension}}
-#endif
- = delete;
-
+ B(A); // #dr1902-B-A
+ B() = delete; // #dr1902-B-ctor
+ // cxx98-error at -1 {{deleted function definitions are a C++11 extension}}
+ B(const B&) = delete; // #dr1902-B-copy-ctor
+ // cxx98-error at -1 {{deleted function definitions are a C++11 extension}}
operator A();
};
extern B b1;
- B b2(b1); // expected-error {{call to deleted}}
+ B b2(b1);
+ // expected-error at -1 {{call to deleted constructor of 'B'}}
+ // expected-note@#dr1902-B-copy-ctor {{'B' has been explicitly marked deleted here}}
#if __cplusplus >= 201103L
// This is ambiguous, even though calling the B(const B&) constructor would
// both directly and indirectly call a deleted function.
- B b({}); // expected-error {{ambiguous}}
+ B b({});
+ // since-cxx11-error at -1 {{call to constructor of 'B' is ambiguous}}
+ // since-cxx11-note@#dr1902-B-A {{candidate constructor}}
+ // since-cxx11-note@#dr1902-B-copy-ctor {{candidate constructor has been explicitly deleted}}
#endif
}
@@ -66,16 +61,22 @@ namespace dr1903 {
namespace dr1909 { // dr1909: 3.7
struct A {
- template<typename T> struct A {}; // expected-error {{member 'A' has the same name as its class}}
+ template<typename T> struct A {};
+ // expected-error at -1 {{member 'A' has the same name as its class}}
};
struct B {
- template<typename T> void B() {} // expected-error {{constructor cannot have a return type}}
+ template<typename T> void B() {}
+ // expected-error at -1 {{constructor cannot have a return type}}
};
struct C {
- template<typename T> static int C; // expected-error {{member 'C' has the same name as its class}} expected-error 0-1{{extension}}
+ template<typename T> static int C;
+ // expected-error at -1 {{member 'C' has the same name as its class}}
+ // cxx98-11-error at -2 {{variable templates are a C++14 extension}}
};
struct D {
- template<typename T> using D = int; // expected-error {{member 'D' has the same name as its class}} expected-error 0-1{{extension}}
+ template<typename T> using D = int;
+ // cxx98-error at -1 {{alias declarations are a C++11 extension}}
+ // expected-error at -2 {{member 'D' has the same name as its class}}
};
}
@@ -83,7 +84,8 @@ namespace dr1940 { // dr1940: 3.5
#if __cplusplus >= 201103L
static union {
static_assert(true, ""); // ok
- static_assert(false, ""); // expected-error {{static assertion failed}}
+ static_assert(false, "");
+ // since-cxx11-error at -1 {{static assertion failed}}
int not_empty;
};
#endif
@@ -122,15 +124,18 @@ derived d2(42, 9);
namespace dr1947 { // dr1947: 3.5
#if __cplusplus >= 201402L
unsigned o = 0'01; // ok
-unsigned b = 0b'01; // expected-error {{invalid digit 'b' in octal constant}}
-unsigned x = 0x'01; // expected-error {{invalid suffix 'x'01' on integer constant}}
+unsigned b = 0b'01;
+// since-cxx14-error at -1 {{invalid digit 'b' in octal constant}}
+unsigned x = 0x'01;
+// since-cxx14-error at -1 {{invalid suffix 'x'01' on integer constant}}
#endif
}
#if __cplusplus >= 201103L
// dr1948: 3.5
// FIXME: This diagnostic could be improved.
-void *operator new(__SIZE_TYPE__) noexcept { return nullptr; } // expected-error{{exception specification in declaration does not match previous declaration}}
+void *operator new(__SIZE_TYPE__) noexcept { return nullptr; }
+// since-cxx11-error at -1 {{exception specification in declaration does not match previous declaration}}
#endif
namespace dr1959 { // dr1959: 3.9
@@ -139,22 +144,31 @@ namespace dr1959 { // dr1959: 3.9
struct c;
struct a {
a() = default;
- a(const a &) = delete; // expected-note {{deleted}}
+ a(const a &) = delete; // #dr1959-copy-ctor
a(const b &) = delete; // not inherited
- a(c &&) = delete; // expected-note {{not viable}}
- template<typename T> a(T) = delete; // expected-note {{would take its own class type by value}}
+ a(c &&) = delete; // #dr1959-move-ctor
+ template<typename T> a(T) = delete; // #dr1959-temp-ctor
};
- struct b : a { // expected-note {{cannot bind}} expected-note {{deleted because}}
- using a::a; // expected-note 2{{inherited here}}
+ struct b : a { // #dr1959-b
+ using a::a; // #dr1959-using-a
};
a x;
// FIXME: As a resolution to an open DR against P0136R0, we disallow
// use of inherited constructors to construct from a single argument
// where the base class is reference-related to the argument type.
- b y = x; // expected-error {{no viable conversion}}
- b z = z; // expected-error {{deleted}}
+ b y = x;
+ // since-cxx11-error at -1 {{no viable conversion from 'a' to 'b'}}
+ // since-cxx11-note@#dr1959-move-ctor {{candidate inherited constructor not viable: no known conversion from 'a' to 'c &&' for 1st argument}}
+ // since-cxx11-note@#dr1959-using-a {{constructor from base class 'a' inherited here}}
+ // since-cxx11-note@#dr1959-b {{candidate constructor (the implicit copy constructor) not viable: cannot bind base class object of type 'a' to derived class reference 'const b &' for 1st argument}}
+ // since-cxx11-note@#dr1959-temp-ctor {{candidate template ignored: instantiation would take its own class type by value}}
+ // since-cxx11-note@#dr1959-using-a {{constructor from base class 'a' inherited here}}
+ b z = z;
+ // since-cxx11-error at -1 {{call to implicitly-deleted copy constructor of 'b'}}
+ // since-cxx11-note@#dr1959-b {{copy constructor of 'b' is implicitly deleted because base class 'a' has a deleted copy constructor}}
+ // since-cxx11-note@#dr1959-copy-ctor {{'a' has been explicitly marked deleted here}}
struct c : a {
using a::a;
@@ -191,16 +205,28 @@ using A::g;
namespace dr1966 { // dr1966: 11
#if __cplusplus >= 201103L
struct A {
- enum E : int {1}; // expected-error {{expected identifier}} (not bit-field)
+ enum E : int {1};
+ // since-cxx11-error at -1 {{expected identifier}} (not bit-field)
};
- auto *p1 = new enum E : int; // expected-error {{only permitted as a standalone declaration}}
- auto *p2 = new enum F : int {}; // expected-error {{only permitted as a standalone declaration}}
- auto *p3 = true ? new enum G : int {}; // expected-error {{forward reference}} expected-error {{incomplete}} expected-note {{declaration}}
- auto h() -> enum E : int {}; // expected-error {{only permitted as a standalone declaration}}
-
- enum X : enum Y : int {} {}; // expected-error {{cannot be defined in a type specifier}}
+ auto *p1 = new enum E : int;
+ // since-cxx11-error at -1 {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
+ auto *p2 = new enum F : int {};
+ // since-cxx11-error at -1 {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
+ auto *p3 = true ? new enum G : int {};
+ // since-cxx11-error at -1 {{ISO C++ forbids forward references to 'enum' types}}
+ // since-cxx11-error at -2 {{allocation of incomplete type 'enum G'}}
+ // since-cxx11-note at -3 {{forward declaration of 'dr1966::G'}}
+ auto h() -> enum E : int {};
+ // since-cxx11-error at -1 {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
+
+ enum X : enum Y : int {} {};
+ // since-cxx11-error at -1 {{'dr1966::Y' cannot be defined in a type specifier}}
struct Q {
- enum X : enum Y : int {} {}; // expected-error +{{}}
+ // FIXME: can we emit something nicer than that?
+ enum X : enum Y : int {} {};
+ // since-cxx11-error at -1 {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration; missing list of enumerators?}}
+ // since-cxx11-error at -2 {{non-integral type 'enum Y' is an invalid underlying type}}
+ // since-cxx11-error at -3 {{anonymous bit-field cannot have a default member initializer}}
};
#endif
}
diff --git a/clang/test/CXX/drs/dr412.cpp b/clang/test/CXX/drs/dr412.cpp
index af385ff463c734..8ea29135d1df82 100644
--- a/clang/test/CXX/drs/dr412.cpp
+++ b/clang/test/CXX/drs/dr412.cpp
@@ -1,7 +1,10 @@
// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT="throw()" -DBAD_ALLOC="throw(std::bad_alloc)"
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC=
// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC=
-// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC=
+// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC=
+// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC=
+// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC=
+// RUN: %clang_cc1 -std=c++2c %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC=
// dr412: 3.4
// lwg404: yes
@@ -11,11 +14,17 @@
__extension__ typedef __SIZE_TYPE__ size_t;
namespace std { struct bad_alloc {}; }
-inline void* operator new(size_t) BAD_ALLOC; // expected-error {{cannot be declared 'inline'}}
-inline void* operator new[](size_t) BAD_ALLOC; // expected-error {{cannot be declared 'inline'}}
-inline void operator delete(void*) NOEXCEPT; // expected-error {{cannot be declared 'inline'}}
-inline void operator delete[](void*) NOEXCEPT; // expected-error {{cannot be declared 'inline'}}
+inline void* operator new(size_t) BAD_ALLOC;
+// expected-error at -1 {{replacement function 'operator new' cannot be declared 'inline'}}
+inline void* operator new[](size_t) BAD_ALLOC;
+// expected-error at -1 {{replacement function 'operator new[]' cannot be declared 'inline'}}
+inline void operator delete(void*) NOEXCEPT;
+// expected-error at -1 {{replacement function 'operator delete' cannot be declared 'inline'}}
+inline void operator delete[](void*) NOEXCEPT;
+// expected-error at -1 {{replacement function 'operator delete[]' cannot be declared 'inline'}}
#ifdef __cpp_sized_deallocation
-inline void operator delete(void*, size_t) NOEXCEPT; // expected-error {{cannot be declared 'inline'}}
-inline void operator delete[](void*, size_t) NOEXCEPT; // expected-error {{cannot be declared 'inline'}}
+inline void operator delete(void*, size_t) NOEXCEPT;
+// expected-error at -1 {{replacement function 'operator delete' cannot be declared 'inline'}}
+inline void operator delete[](void*, size_t) NOEXCEPT;
+// expected-error at -1 {{replacement function 'operator delete[]' cannot be declared 'inline'}}
#endif
diff --git a/clang/test/CXX/drs/dr7xx.cpp b/clang/test/CXX/drs/dr7xx.cpp
index 11901b80d64622..926bff1cc479c5 100644
--- a/clang/test/CXX/drs/dr7xx.cpp
+++ b/clang/test/CXX/drs/dr7xx.cpp
@@ -1,37 +1,53 @@
-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++98 %s -verify=expected,cxx98-14,cxx98-11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 %s -verify=expected,cxx98-14,cxx98-11,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++14 %s -verify=expected,cxx98-14,since-cxx14,since-cxx11,cxx14 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++17 %s -verify=expected,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++2a %s -verify=expected,since-cxx14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr705 { // dr705: yes
namespace N {
struct S {};
- void f(S); // expected-note {{declared here}}
+ void f(S); // #dr705-f
}
void g() {
N::S s;
f(s); // ok
- (f)(s); // expected-error {{use of undeclared}}
+ (f)(s);
+ // expected-error at -1 {{use of undeclared identifier 'f'}}
+ // expected-note@#dr705-f {{'N::f' declared here}}
}
}
namespace dr712 { // dr712: partial
void use(int);
void f() {
- const int a = 0; // expected-note 5{{here}}
+ const int a = 0; // #dr712-f-a
struct X {
void g(bool cond) {
use(a);
use((a));
use(cond ? a : a);
- use((cond, a)); // expected-warning 2{{left operand of comma operator has no effect}} FIXME: should only warn once
-
- (void)a; // FIXME: expected-error {{declared in enclosing}}
- (void)(a); // FIXME: expected-error {{declared in enclosing}}
- (void)(cond ? a : a); // FIXME: expected-error 2{{declared in enclosing}}
- (void)(cond, a); // FIXME: expected-error {{declared in enclosing}} expected-warning {{left operand of comma operator has no effect}}
+ // FIXME: should only warn once
+ use((cond, a));
+ // expected-warning at -1 {{left operand of comma operator has no effect}}
+ // expected-warning at -2 {{left operand of comma operator has no effect}}
+
+ (void)a;
+ // expected-error at -1 {{reference to local variable 'a' declared in enclosing function 'dr712::f'}} FIXME
+ // expected-note@#dr712-f-a {{'a' declared here}}
+ (void)(a);
+ // expected-error at -1 {{reference to local variable 'a' declared in enclosing function 'dr712::f'}} FIXME
+ // expected-note@#dr712-f-a {{'a' declared here}}
+ (void)(cond ? a : a); // #dr712-ternary
+ // expected-error@#dr712-ternary {{reference to local variable 'a' declared in enclosing function 'dr712::f'}} FIXME
+ // expected-note@#dr712-f-a {{'a' declared here}}
+ // expected-error@#dr712-ternary {{reference to local variable 'a' declared in enclosing function 'dr712::f'}} FIXME
+ // expected-note@#dr712-f-a {{'a' declared here}}
+ (void)(cond, a); // #dr712-comma
+ // expected-error at -1 {{reference to local variable 'a' declared in enclosing function 'dr712::f'}} FIXME
+ // expected-note@#dr712-f-a {{'a' declared here}}
+ // expected-warning@#dr712-comma {{left operand of comma operator has no effect}}
}
};
}
@@ -39,14 +55,18 @@ namespace dr712 { // dr712: partial
#if __cplusplus >= 201103L
void g() {
struct A { int n; };
- constexpr A a = {0}; // expected-note 2{{here}}
+ constexpr A a = {0}; // #dr712-g-a
struct X {
void g(bool cond) {
use(a.n);
use(a.*&A::n);
- (void)a.n; // FIXME: expected-error {{declared in enclosing}}
- (void)(a.*&A::n); // FIXME: expected-error {{declared in enclosing}}
+ (void)a.n;
+ // since-cxx11-error at -1 {{reference to local variable 'a' declared in enclosing function 'dr712::g'}} FIXME
+ // since-cxx11-note@#dr712-g-a {{'a' declared here}}
+ (void)(a.*&A::n);
+ // since-cxx11-error at -1 {{reference to local variable 'a' declared in enclosing function 'dr712::g'}} FIXME
+ // since-cxx11-note@#dr712-g-a {{'a' declared here}}
}
};
}
@@ -55,9 +75,10 @@ namespace dr712 { // dr712: partial
namespace dr727 { // dr727: partial
struct A {
- template<typename T> struct C; // expected-note 6{{here}}
- template<typename T> void f(); // expected-note {{here}}
- template<typename T> static int N; // expected-error 0-1{{C++14}} expected-note 6{{here}}
+ template<typename T> struct C; // #dr727-C
+ template<typename T> void f(); // #dr727-f
+ template<typename T> static int N; // #dr727-N
+ // cxx98-11-error at -1 {{variable templates are a C++14 extension}}
template<> struct C<int>;
template<> void f<int>();
@@ -67,19 +88,40 @@ namespace dr727 { // dr727: partial
template<typename T> static int N<T*>;
struct B {
- template<> struct C<float>; // expected-error {{not in class 'A' or an enclosing namespace}}
- template<> void f<float>(); // expected-error {{no function template matches}}
- template<> static int N<float>; // expected-error {{not in class 'A' or an enclosing namespace}}
-
- template<typename T> struct C<T**>; // expected-error {{not in class 'A' or an enclosing namespace}}
- template<typename T> static int N<T**>; // expected-error {{not in class 'A' or an enclosing namespace}}
-
- template<> struct A::C<double>; // expected-error {{not in class 'A' or an enclosing namespace}}
- template<> void A::f<double>(); // expected-error {{no function template matches}} expected-error {{cannot have a qualified name}}
- template<> static int A::N<double>; // expected-error {{not in class 'A' or an enclosing namespace}} expected-error {{cannot have a qualified name}}
-
- template<typename T> struct A::C<T***>; // expected-error {{not in class 'A' or an enclosing namespace}}
- template<typename T> static int A::N<T***>; // expected-error {{not in class 'A' or an enclosing namespace}} expected-error {{cannot have a qualified name}}
+ template<> struct C<float>;
+ // expected-error at -1 {{class template specialization of 'C' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-C {{explicitly specialized declaration is here}}
+ template<> void f<float>();
+ // expected-error at -1 {{no function template matches function template specialization 'f'}}
+ template<> static int N<float>;
+ // expected-error at -1 {{variable template specialization of 'N' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-N {{explicitly specialized declaration is here}}
+
+ template<typename T> struct C<T**>;
+ // expected-error at -1 {{class template partial specialization of 'C' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-C {{explicitly specialized declaration is here}}
+ template<typename T> static int N<T**>;
+ // expected-error at -1 {{variable template partial specialization of 'N' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-N {{explicitly specialized declaration is here}}
+
+ template<> struct A::C<double>;
+ // expected-error at -1 {{class template specialization of 'C' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-C {{explicitly specialized declaration is here}}
+ template<> void A::f<double>();
+ // expected-error at -1 {{o function template matches function template specialization 'f'}}
+ // expected-error at -2 {{non-friend class member 'f' cannot have a qualified name}}
+ template<> static int A::N<double>;
+ // expected-error at -1 {{non-friend class member 'N' cannot have a qualified name}}
+ // expected-error at -2 {{variable template specialization of 'N' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-N {{explicitly specialized declaration is here}}
+
+ template<typename T> struct A::C<T***>;
+ // expected-error at -1 {{class template partial specialization of 'C' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-C {{explicitly specialized declaration is here}}
+ template<typename T> static int A::N<T***>;
+ // expected-error at -1 {{non-friend class member 'N' cannot have a qualified name}}
+ // expected-error at -2 {{variable template partial specialization of 'N' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-N {{explicitly specialized declaration is here}}
};
};
@@ -91,19 +133,36 @@ namespace dr727 { // dr727: partial
template<typename T> int A::N<T****>;
namespace C {
- template<> struct A::C<long>; // expected-error {{not in class 'A' or an enclosing namespace}}
- template<> void A::f<long>(); // expected-error {{not in class 'A' or an enclosing namespace}}
- template<> int A::N<long>; // expected-error {{not in class 'A' or an enclosing namespace}}
-
- template<typename T> struct A::C<T*****>; // expected-error {{not in class 'A' or an enclosing namespace}}
- template<typename T> int A::N<T*****>; // expected-error {{not in class 'A' or an enclosing namespace}}
+ template<> struct A::C<long>;
+ // expected-error at -1 {{class template specialization of 'C' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-C {{explicitly specialized declaration is here}}
+ template<> void A::f<long>();
+ // expected-error at -1 {{function template specialization of 'f' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-f {{explicitly specialized declaration is here}}
+ template<> int A::N<long>;
+ // expected-error at -1 {{variable template specialization of 'N' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-N {{explicitly specialized declaration is here}}
+
+ template<typename T> struct A::C<T*****>;
+ // expected-error at -1 {{class template partial specialization of 'C' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-C {{explicitly specialized declaration is here}}
+ template<typename T> int A::N<T*****>;
+ // expected-error at -1 {{variable template partial specialization of 'N' not in class 'A' or an enclosing namespace}}
+ // expected-note@#dr727-N {{explicitly specialized declaration is here}}
}
template<typename>
struct D {
- template<typename T> struct C { typename T::error e; }; // expected-error {{no members}}
- template<typename T> void f() { T::error; } // expected-error {{no members}}
- template<typename T> static const int N = T::error; // expected-error {{no members}} expected-error 0-1{{C++14}}
+ template<typename T> struct C { typename T::error e; };
+ // expected-error at -1 {{type 'float' cannot be used prior to '::' because it has no members}}
+ // expected-note@#dr727-C-float {{in instantiation of template class 'dr727::D<int>::C<float>' requested here}}
+ template<typename T> void f() { T::error; }
+ // expected-error at -1 {{type 'float' cannot be used prior to '::' because it has no members}}
+ // expected-note@#dr727-f-float {{in instantiation of function template specialization 'dr727::D<int>::f<float>' requested here}}
+ template<typename T> static const int N = T::error;
+ // cxx98-11-error at -1 {{variable templates are a C++14 extension}}
+ // expected-error at -2 {{type 'float' cannot be used prior to '::' because it has no members}}
+ // expected-note@#dr727-N-float {{in instantiation of static data member 'dr727::D<int>::N<float>' requested here}}
template<> struct C<int> {};
template<> void f<int>() {}
@@ -114,7 +173,8 @@ namespace dr727 { // dr727: partial
template<typename>
struct E {
- template<> void f<void>() {} // expected-error {{no candidate function template}}
+ template<> void f<void>() {}
+ // expected-error at -1 {{no candidate function template was found for dependent member function template specialization}}
};
};
@@ -126,9 +186,9 @@ namespace dr727 { // dr727: partial
D<int>::C<int*>();
int b = D<int>::N<int*>;
- D<int>::C<float>(); // expected-note {{instantiation of}}
- di.f<float>(); // expected-note {{instantiation of}}
- int c = D<int>::N<float>; // expected-note {{instantiation of}}
+ D<int>::C<float>(); // #dr727-C-float
+ di.f<float>(); // #dr727-f-float
+ int c = D<int>::N<float>; // #dr727-N-float
}
namespace mixed_inner_outer_specialization {
@@ -148,28 +208,30 @@ namespace dr727 { // dr727: partial
#if __cplusplus >= 201402L
template<int> struct B {
template<int> static const int u = 1;
- template<> static const int u<0> = 2; // expected-note {{here}}
+ template<> static const int u<0> = 2; // #dr727-u0
// Note that in C++17 onwards, these are implicitly inline, and so the
// initializer of v<0> is not instantiated with the declaration. In
// C++14, v<0> is a non-defining declaration and its initializer is
// instantiated with the class.
template<int> static constexpr int v = 1;
- template<> static constexpr int v<0> = 2; // #v0
+ template<> static constexpr int v<0> = 2; // #dr727-v0
- template<int> static const inline int w = 1; // expected-error 0-1{{C++17 extension}}
- template<> static const inline int w<0> = 2; // expected-error 0-1{{C++17 extension}}
+ template<int> static const inline int w = 1;
+ // cxx14-error at -1 {{inline variables are a C++17 extension}}
+ template<> static const inline int w<0> = 2;
+ // cxx14-error at -1 {{inline variables are a C++17 extension}}
};
template<> template<int> constexpr int B<0>::u = 3;
- template<> template<> constexpr int B<0>::u<0> = 4; // expected-error {{already has an initializer}}
+ template<> template<> constexpr int B<0>::u<0> = 4;
+ // since-cxx14-error at -1 {{static data member 'u' already has an initializer}}
+ // since-cxx14-note@#dr727-u0 {{previous initialization is here}}
template<> template<int> constexpr int B<0>::v = 3;
template<> template<> constexpr int B<0>::v<0> = 4;
-#if __cplusplus < 201702L
- // expected-error at -2 {{already has an initializer}}
- // expected-note@#v0 {{here}}
-#endif
+ // cxx14-error at -1 {{static data member 'v' already has an initializer}}
+ // cxx14-note@#dr727-v0 {{previous initialization is here}}
template<> template<int> constexpr int B<0>::w = 3;
template<> template<> constexpr int B<0>::w<0> = 4;
@@ -182,10 +244,8 @@ namespace dr727 { // dr727: partial
static_assert(B<1>().v<0> == 2, "");
static_assert(B<0>().v<1> == 3, "");
static_assert(B<0>().v<0> == 4, "");
-#if __cplusplus < 201702L
- // expected-error at -2 {{failed}} \
- // expected-note at -2 {{evaluates to '2 == 4'}}
-#endif
+ // cxx14-error at -1 {{static assertion failed due to requirement 'dr727::mixed_inner_outer_specialization::B<0>().v<0> == 4'}}
+ // cxx14-note at -2 {{expression evaluates to '2 == 4'}}
static_assert(B<1>().w<1> == 1, "");
static_assert(B<1>().w<0> == 2, "");
@@ -205,13 +265,23 @@ namespace dr727 { // dr727: partial
template<> int f2<T>() {}
template<> int f2<U>() {}
- template<typename> static int v1; // expected-error 0-1{{C++14 extension}}
- template<> static int v1<T>; // expected-note {{previous}}
- template<> static int v1<U>; // expected-error {{duplicate member}}
-
- template<typename> static inline int v2; // expected-error 0-1{{C++17 extension}} expected-error 0-1{{C++14 extension}}
- template<> static inline int v2<T>; // expected-error 0-1{{C++17 extension}} expected-note {{previous}}
- template<> static inline int v2<U>; // expected-error 0-1{{C++17 extension}} expected-error {{duplicate member}}
+ template<typename> static int v1;
+ // cxx98-11-error at -1 {{variable templates are a C++14 extension}}
+ template<> static int v1<T>; // #dr727-v1-T
+ template<> static int v1<U>;
+ // expected-error at -1 {{duplicate member 'v1'}}
+ // expected-note@#dr727-Collision-int-int {{in instantiation of template class 'dr727::Collision<int, int>' requested here}}
+ // expected-note@#dr727-v1-T {{previous}}
+
+ template<typename> static inline int v2;
+ // cxx98-11-error at -1 {{variable templates are a C++14 extension}}
+ // cxx98-14-error at -2 {{inline variables are a C++17 extension}}
+ template<> static inline int v2<T>; // #dr727-v2-T
+ // cxx98-14-error at -1 {{inline variables are a C++17 extension}}
+ template<> static inline int v2<U>;
+ // cxx98-14-error at -1 {{inline variables are a C++17 extension}}
+ // expected-error at -2 {{duplicate member 'v2'}}
+ // expected-note@#dr727-v2-T {{previous declaration is here}}
// FIXME: Missing diagnostic for duplicate class explicit specialization.
template<typename> struct S1;
@@ -219,10 +289,12 @@ namespace dr727 { // dr727: partial
template<> struct S1<U>;
template<typename> struct S2;
- template<> struct S2<T> {}; // expected-note {{previous}}
- template<> struct S2<U> {}; // expected-error {{redefinition}}
+ template<> struct S2<T> {}; // #dr727-S2-T
+ template<> struct S2<U> {};
+ // expected-error at -1 {{redefinition of 'S2<int>'}}
+ // expected-note@#dr727-S2-T {{previous}}
};
- Collision<int, int> c; // expected-note {{in instantiation of}}
+ Collision<int, int> c; // #dr727-Collision-int-int
}
namespace dr777 { // dr777: 3.7
diff --git a/clang/test/CXX/drs/dr8xx.cpp b/clang/test/CXX/drs/dr8xx.cpp
index 11948d0410eb56..b031e65095cdb0 100644
--- a/clang/test/CXX/drs/dr8xx.cpp
+++ b/clang/test/CXX/drs/dr8xx.cpp
@@ -1,30 +1,27 @@
-// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
-// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
-// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
-// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
-// RUN: %clang_cc1 -std=c++2c -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++2c -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+#if __cplusplus == 199711L
// expected-no-diagnostics
+#endif
namespace dr873 { // dr873: 3.0
#if __cplusplus >= 201103L
template <typename T> void f(T &&);
-template <> void f(int &) {} // #1
-template <> void f(int &&) {} // #2
+template <> void f(int &) = delete; // #dr873-lvalue-ref
+template <> void f(int &&) = delete; // #dr873-rvalue-ref
void g(int i) {
- f(i); // calls f<int&>(int&), i.e., #1
-#pragma clang __debug dump f(i)
- // CHECK: CallExpr {{.*}}
- // CHECK-NEXT: |-ImplicitCastExpr {{.*}}
- // CHECK-NEXT: | `-DeclRefExpr {{.*}} 'f' 'void (int &)' {{.*}}
-
- f(0); // calls f<int>(int&&), i.e., #2
-#pragma clang __debug dump f(0)
- // CHECK: CallExpr {{.*}}
- // CHECK-NEXT: |-ImplicitCastExpr {{.*}}
- // CHECK-NEXT: | `-DeclRefExpr {{.*}} 'f' 'void (int &&)' {{.*}}
+ f(i); // calls f<int&>(int&)
+ // since-cxx11-error at -1 {{call to deleted function 'f'}}
+ // since-cxx11-note@#dr873-lvalue-ref {{candidate function [with T = int &] has been implicitly deleted}}
+ f(0); // calls f<int>(int&&)
+ // since-cxx11-error at -1 {{call to deleted function 'f'}}
+ // since-cxx11-note@#dr873-rvalue-ref {{candidate function [with T = int] has been implicitly deleted}}
}
#endif
} // namespace dr873
diff --git a/clang/test/CXX/drs/dr9xx.cpp b/clang/test/CXX/drs/dr9xx.cpp
index e5265822924801..7ea295a684b7a2 100644
--- a/clang/test/CXX/drs/dr9xx.cpp
+++ b/clang/test/CXX/drs/dr9xx.cpp
@@ -1,9 +1,9 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
namespace std {
__extension__ typedef __SIZE_TYPE__ size_t;
@@ -46,27 +46,31 @@ namespace dr948 { // dr948: 3.7
namespace dr952 { // dr952: 2.8
namespace example1 {
struct A {
- typedef int I; // #dr952-typedef-decl
+ typedef int I; // #dr952-I
};
-struct B : private A { // #dr952-inheritance
+struct B : private A { // #dr952-B
};
struct C : B {
void f() {
- I i1; // expected-error {{private member}}
- // expected-note@#dr952-inheritance {{constrained by private inheritance}}
- // expected-note@#dr952-typedef-decl {{declared here}}
+ I i1;
+ // expected-error at -1 {{'I' is a private member of 'dr952::example1::A'}}
+ // expected-note@#dr952-B {{constrained by private inheritance here}}
+ // expected-note@#dr952-I {{member is declared here}}
}
- I i2; // expected-error {{private member}}
- // expected-note@#dr952-inheritance {{constrained by private inheritance}}
- // expected-note@#dr952-typedef-decl {{declared here}}
+ I i2;
+ // expected-error at -1 {{'I' is a private member of 'dr952::example1::A'}}
+ // expected-note@#dr952-B {{constrained by private inheritance here}}
+ // expected-note@#dr952-I {{member is declared here}}
struct D {
- I i3; // expected-error {{private member}}
- // expected-note@#dr952-inheritance {{constrained by private inheritance}}
- // expected-note@#dr952-typedef-decl {{declared here}}
+ I i3;
+ // expected-error at -1 {{'I' is a private member of 'dr952::example1::A'}}
+ // expected-note@#dr952-B {{constrained by private inheritance here}}
+ // expected-note@#dr952-I {{member is declared here}}
void g() {
- I i4; // expected-error {{private member}}
- // expected-note@#dr952-inheritance {{constrained by private inheritance}}
- // expected-note@#dr952-typedef-decl {{declared here}}
+ I i4;
+ // expected-error at -1 {{'I' is a private member of 'dr952::example1::A'}}
+ // expected-note@#dr952-B {{constrained by private inheritance here}}
+ // expected-note@#dr952-I {{member is declared here}}
}
};
};
@@ -91,10 +95,10 @@ namespace dr974 { // dr974: yes
}
namespace dr977 { // dr977: yes
-enum E { e = E() };
+enum E { e = E() }; // #dr977-E
#if !defined(_WIN32) || defined(__MINGW32__)
-// expected-error at -2 {{invalid use of incomplete type 'E'}}
-// expected-note at -3 {{definition of 'dr977::E' is not complete until the closing '}'}}
+// expected-error@#dr977-E {{invalid use of incomplete type 'E'}}
+// expected-note@#dr977-E {{definition of 'dr977::E' is not complete until the closing '}'}}
#endif
#if __cplusplus >= 201103L
enum E2 : int { e2 = E2() };
@@ -105,23 +109,29 @@ enum struct E4 : int { e = static_cast<int>(E4()) };
namespace dr990 { // dr990: 3.5
#if __cplusplus >= 201103L
- struct A { // expected-note 2{{candidate}}
- A(std::initializer_list<int>); // expected-note {{candidate}}
+ struct A { // #dr990-A
+ A(std::initializer_list<int>); // #dr990-A-init-list
};
struct B {
A a;
};
B b1 { };
- B b2 { 1 }; // expected-error {{no viable conversion from 'int' to 'A'}}
+ B b2 { 1 };
+ // since-cxx11-error at -1 {{no viable conversion from 'int' to 'A'}}
+ // since-cxx11-note@#dr990-A {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const A &' for 1st argument}}
+ // since-cxx11-note@#dr990-A {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'A &&' for 1st argument}}
+ // since-cxx11-note@#dr990-A-init-list {{candidate constructor not viable: no known conversion from 'int' to 'std::initializer_list<int>' for 1st argument}}
B b3 { { 1 } };
struct C {
C();
C(int);
- C(std::initializer_list<int>) = delete; // expected-note {{here}}
+ C(std::initializer_list<int>) = delete; // #dr990-deleted
};
C c1[3] { 1 }; // ok
- C c2[3] { 1, {2} }; // expected-error {{call to deleted}}
+ C c2[3] { 1, {2} };
+ // since-cxx11-error at -1 {{call to deleted constructor of 'C'}}
+ // since-cxx11-note@#dr990-deleted {{'C' has been explicitly marked deleted here}}
struct D {
D();
More information about the cfe-commits
mailing list