[clang] [clang][NFC] Refactor expected directives in C++ DRs 600-699 (PR #74477)
via cfe-commits
cfe-commits at lists.llvm.org
Tue Dec 5 06:20:50 PST 2023
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Vlad Serebrennikov (Endilll)
<details>
<summary>Changes</summary>
[clang][NFC] Refactor expected directives in C++ DRs 600-699
This patch continues the work started with https://github.com/llvm/llvm-project/commit/ea5b1ef016d020c37f903d6c7d4f623be975dab8. See that commit and its corresponding PR for details.
---
Patch is 55.30 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/74477.diff
1 Files Affected:
- (modified) clang/test/CXX/drs/dr6xx.cpp (+418-238)
``````````diff
diff --git a/clang/test/CXX/drs/dr6xx.cpp b/clang/test/CXX/drs/dr6xx.cpp
index 4cba1f057cb27..37694e3647c63 100644
--- a/clang/test/CXX/drs/dr6xx.cpp
+++ b/clang/test/CXX/drs/dr6xx.cpp
@@ -1,22 +1,24 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
-// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
-// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected,cxx98-17,cxx98-14,cxx98 -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx98-17,cxx11-17,cxx98-14,since-cxx11,cxx11 -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,cxx98-17,cxx11-17,cxx98-14,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,cxx98-17,cxx11-17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
namespace dr600 { // dr600: 2.8
struct S {
void f(int);
private:
- void f(double); // expected-note {{declared private here}}
+ void f(double); // #dr600-f-double
};
void g(S *sp) {
sp->f(2);
// access control is applied after overload resolution
- sp->f(2.2); // expected-error {{is a private member}}
+ sp->f(2.2);
+ // expected-error at -1 {{'f' is a private member of 'dr600::S'}}
+ // expected-note@#dr600-f-double {{declared private here}}
}
} // namespace dr600
@@ -41,7 +43,8 @@ namespace dr601 { // dr601: yes
#endif
#if __INT_MAX__ == 0x7FFFFFFF
-_Static_assert(0x80000000 < -1, "0x80000000 should be unsigned"); // expected-error {{C11}}
+_Static_assert(0x80000000 < -1, "0x80000000 should be unsigned");
+// expected-error at -1 {{'_Static_assert' is a C11 extension}}
#endif
#if MAX > 0xFFFFFFFFFFFFFFFF && 0x8000000000000000 < -1
@@ -49,7 +52,7 @@ _Static_assert(0x80000000 < -1, "0x80000000 should be unsigned"); // expected-er
#endif
#if __cplusplus >= 201103L && __LLONG_MAX__ == 0x7FFFFFFFFFFFFFFF
-static_assert(0x8000000000000000 < -1, "0x8000000000000000 should be unsigned"); // expected-error {{C11}}
+static_assert(0x8000000000000000 < -1, "0x8000000000000000 should be unsigned");
#endif
#undef MAX
@@ -74,9 +77,7 @@ namespace dr603 { // dr603: yes
template<unsigned char> struct S {};
typedef S<'\001'> S1;
typedef S<(1ul << __CHAR_BIT__) + 1> S1;
-#if __cplusplus >= 201103L
- // expected-error at -2 {{cannot be narrowed}}
-#endif
+ // since-cxx11-error at -1 {{cannot be narrowed}}
}
// dr604: na
@@ -85,14 +86,18 @@ namespace dr603 { // dr603: yes
namespace dr606 { // dr606: 3.0
#if __cplusplus >= 201103L
template<typename T> struct S {};
- template<typename T> void f(S<T> &&); // expected-note {{expects an rvalue}}
+ template<typename T> void f(S<T> &&); // #dr606-f
template<typename T> void g(T &&);
- template<typename T> void h(const T &&); // expected-note {{expects an rvalue}}
+ template<typename T> void h(const T &&); // #dr606-h
void test(S<int> s) {
- f(s); // expected-error {{no match}}
+ f(s);
+ // since-cxx11-error at -1 {{no matching function for call to 'f'}}
+ // since-cxx11-note@#dr606-f {{candidate function [with T = int] not viable: expects an rvalue for 1st argument}}
g(s);
- h(s); // expected-error {{no match}}
+ h(s);
+ // since-cxx11-error at -1 {{no matching function for call to 'h'}}
+ // since-cxx11-note@#dr606-h {{candidate function [with T = dr606::S<int>] not viable: expects an rvalue for 1st argument}}
g(test);
h(test); // ok, an rvalue reference can bind to a function lvalue
@@ -152,33 +157,32 @@ namespace dr613 { // dr613: yes c++11
B &g(int);
int an1 = sizeof(A::n);
+ // cxx98-error at -1 {{invalid use of non-static data member 'n'}}
int an2 = sizeof(A::n + 1); // valid per dr850
+ // cxx98-error at -1 {{invalid use of non-static data member 'n'}}
int an3 = sizeof A::n;
+ // cxx98-error at -1 {{invalid use of non-static data member 'n'}}
int an4 = sizeof(f(A::n));
+ // cxx98-error at -1 {{invalid use of non-static data member 'n'}}
int an5 = sizeof(g(A::n));
+ // cxx98-error at -1 {{invalid use of non-static data member 'n'}}
const std::type_info &an6 = typeid(A::n);
+ // cxx98-error at -1 {{invalid use of non-static data member 'n'}}
const std::type_info &an7 = typeid(A::n + 1);
+ // cxx98-error at -1 {{invalid use of non-static data member 'n'}}
const std::type_info &an8 = typeid(f(A::n));
- const std::type_info &an9 = typeid(g(A::n)); // expected-error {{non-static}}
-#if __cplusplus < 201103L
- // expected-error at -10 {{non-static}}
- // expected-error at -10 {{non-static}}
- // expected-error at -10 {{non-static}}
- // expected-error at -10 {{non-static}}
- // expected-error at -10 {{non-static}}
- // expected-error at -10 {{non-static}}
- // expected-error at -10 {{non-static}}
- // expected-error at -10 {{non-static}}
-#endif
+ // cxx98-error at -1 {{invalid use of non-static data member 'n'}}
+ const std::type_info &an9 = typeid(g(A::n));
+ // expected-error at -1 {{invalid use of non-static data member 'n'}}
void A::f() {
int an1 = sizeof n;
+ // cxx98-error at -1 {{invalid use of member 'n' in static member function}}
const std::type_info &an2 = typeid(n + 1);
-#if __cplusplus < 201103L
- // expected-error at -3 {{static}}
- // expected-error at -3 {{static}}
-#endif
- const std::type_info &an3 = typeid(g(n)); // expected-error {{static}}
+ // cxx98-error at -1 {{invalid use of member 'n' in static member function}}
+ const std::type_info &an3 = typeid(g(n));
+ // cxx98-error at -1 {{invalid use of member 'n' in static member function}}
+ // since-cxx11-error at -2 {{invalid use of non-static data member 'n'}}
}
}
@@ -219,16 +223,20 @@ namespace dr619 { // dr619: yes
struct S { static int x[10]; };
int x[];
- _Static_assert(sizeof(x) == sizeof(int) * 10, ""); // expected-error {{C11}}
+ _Static_assert(sizeof(x) == sizeof(int) * 10, "");
+ // expected-error at -1 {{'_Static_assert' is a C11 extension}}
extern int x[];
- _Static_assert(sizeof(x) == sizeof(int) * 10, ""); // expected-error {{C11}}
+ _Static_assert(sizeof(x) == sizeof(int) * 10, "");
+ // expected-error at -1 {{'_Static_assert' is a C11 extension}}
int S::x[];
- _Static_assert(sizeof(S::x) == sizeof(int) * 10, ""); // expected-error {{C11}}
+ _Static_assert(sizeof(S::x) == sizeof(int) * 10, "");
+ // expected-error at -1 {{'_Static_assert' is a C11 extension}}
void f() {
extern int x[];
- sizeof(x); // expected-error {{incomplete}}
+ sizeof(x);
+ // expected-error at -1 {{invalid application of 'sizeof' to an incomplete type 'int[]'}}
}
}
@@ -236,8 +244,10 @@ namespace dr619 { // dr619: yes
namespace dr621 { // dr621: yes
template<typename T> T f();
- template<> int f() {} // expected-note {{previous}}
- template<> int f<int>() {} // expected-error {{redefinition}}
+ template<> int f() {} // #dr621-f
+ template<> int f<int>() {}
+ // expected-error at -1 {{redefinition of 'f<int>'}}
+ // expected-note@#dr621-f {{previous definition is here}}
}
// dr623: na
@@ -247,20 +257,29 @@ namespace dr621 { // dr621: yes
namespace dr625 { // dr625: yes
template<typename T> struct A {};
- A<auto> x = A<int>(); // expected-error {{'auto' not allowed in template argument}} expected-error 0-1{{extension}}
+ A<auto> x = A<int>();
+ // cxx98-error at -1 {{'auto' type specifier is a C++11 extension}}
+ // expected-error at -2 {{'auto' not allowed in template argument}}
void f(int);
- void (*p)(auto) = f; // expected-error {{'auto' not allowed in function prototype}} expected-error 0-1{{extension}}
+ void (*p)(auto) = f;
+ // cxx98-error at -1 {{'auto' type specifier is a C++11 extension}}
+ // expected-error at -2 {{'auto' not allowed in function prototype}}
}
namespace dr626 { // dr626: yes
#define STR(x) #x
char c[2] = STR(c); // ok, type matches
- wchar_t w[2] = STR(w); // expected-error {{initializing wide char array with non-wide string literal}}
+ wchar_t w[2] = STR(w);
+ // expected-error at -1 {{initializing wide char array with non-wide string literal}}
}
namespace dr627 { // dr627: yes
void f() {
- true a = 0; // expected-error +{{}} expected-warning {{unused}}
+ // FIXME: emitted diagnostic have a room for improvement
+ true a = 0;
+ // expected-error at -1 {{expected ';' after expression}}
+ // expected-error at -2 {{use of undeclared identifier 'a'}}
+ // expected-warning at -3 {{expression result unused}}
}
}
@@ -270,17 +289,12 @@ namespace dr629 { // dr629: 2.9
typedef int T;
int n = 1;
void f() {
- auto T = 2;
-#if __cplusplus < 201103L
- // expected-error at -2 {{expected unqualified-id}}
-#else
- // expected-note at -4 {{previous}}
-#endif
+ auto T = 2; // #dr629-T
+ // cxx98-error at -1 {{expected unqualified-id}}
auto T(n);
-#if __cplusplus >= 201103L
- // expected-error at -2 {{redefinition of 'T'}}
-#endif
+ // since-cxx11-error at -1 {{redefinition of 'T'}}
+ // since-cxx11-note@#dr629-T {{previous definition is here}}
}
}
@@ -311,17 +325,20 @@ const bool MB_EQ_WC =
',' == L',' && '\\' == L'\\' && '"' == L'"' && '\'' == L'\'';
#if __STDC_MB_MIGHT_NEQ_WC__
#ifndef __FreeBSD__ // PR22208, FreeBSD expects us to give a bad (but conforming) answer here.
-_Static_assert(!MB_EQ_WC, "__STDC_MB_MIGHT_NEQ_WC__ but all basic source characters have same representation"); // expected-error {{C11}}
+_Static_assert(!MB_EQ_WC, "__STDC_MB_MIGHT_NEQ_WC__ but all basic source characters have same representation");
+// expected-error at -1 {{'_Static_assert' is a C11 extension}}
#endif
#else
-_Static_assert(MB_EQ_WC, "!__STDC_MB_MIGHT_NEQ_WC__ but some character differs"); // expected-error {{C11}}
+_Static_assert(MB_EQ_WC, "!__STDC_MB_MIGHT_NEQ_WC__ but some character differs");
+// expected-error at -1 {{'_Static_assert' is a C11 extension}}
#endif
}
// dr631: na
namespace dr632 { // dr632: yes
- struct S { int n; } s = {{5}}; // expected-warning {{braces}}
+ struct S { int n; } s = {{5}};
+ // expected-warning at -1 {{braces around scalar initializer}}
}
// dr633: na
@@ -334,12 +351,15 @@ namespace dr634 { // dr634: yes
template<typename T> int (&g(T))[sizeof f(T())];
int (&a)[sizeof(int)] = g(S());
int (&b)[1] = g(0);
- int k = f(S()); // expected-error {{cannot pass}}
+ int k = f(S());
+ // cxx98-error at -1 {{cannot pass object of non-POD type 'S' through variadic function; call will abort at runtime}}
+ // since-cxx11-error at -2 {{cannot pass object of non-trivial type 'S' through variadic function; call will abort at runtime}}
}
namespace dr635 { // dr635: yes
template<typename T> struct A { A(); ~A(); };
- template<typename T> A<T>::A<T>() {} // expected-error {{cannot have template arguments}}
+ template<typename T> A<T>::A<T>() {}
+ // expected-error at -1 {{out-of-line constructor for 'A' cannot have template arguments}}
template<typename T> A<T>::~A<T>() {}
template<typename T> struct B { B(); ~B(); };
@@ -349,22 +369,25 @@ namespace dr635 { // dr635: yes
struct C { template<typename T> C(); C(); };
template<typename T> C::C() {}
C::C() {}
- template<> C::C<int>() {} // expected-error {{constructor name}} expected-error {{unqualified-id}}
+ template<> C::C<int>() {}
+ // expected-error at -1 {{qualified reference to 'C' is a constructor name rather than a type in this context}}
+ // expected-error at -2 {{expected unqualified-id}}
/*FIXME: needed for error recovery:*/;
template<typename T> struct D { template<typename U> D(); D(); };
- template<typename T> D<T>::D() {} // expected-note {{previous}}
+ template<typename T> D<T>::D() {} // #dr635-D
template<typename T> template<typename U> D<T>::D() {}
- template<typename T> D<T>::D<T>() {} // expected-error {{redefinition}} expected-error {{cannot have template arg}}
+ template<typename T> D<T>::D<T>() {} // #dr635-D-T
+ // expected-error@#dr635-D-T {{out-of-line constructor for 'D' cannot have template arguments}}
+ // expected-error@#dr635-D-T {{redefinition of 'D<T>'}}
+ // expected-note@#dr635-D {{previous definition is here}}
}
namespace dr637 { // dr637: yes
void f(int i) {
i = ++i + 1;
i = i++ + 1;
-#if __cplusplus < 201703L
- // expected-warning at -2 {{unsequenced}}
-#endif
+ // cxx98-14-warning at -1 {{multiple unsequenced modifications to 'i'}}
}
}
@@ -380,10 +403,14 @@ namespace dr638 { // dr638: no
class X {
typedef int type;
- template<class T> friend struct A<T>::B; // expected-warning {{not supported}}
- template<class T> friend void A<T>::f(); // expected-warning {{not supported}}
- template<class T> friend void A<T>::g(); // expected-warning {{not supported}}
- template<class T> friend void A<T>::C::h(); // expected-warning {{not supported}}
+ template<class T> friend struct A<T>::B;
+ // expected-warning at -1 {{dependent nested name specifier 'A<T>::' for friend class declaration is not supported; turning off access control for 'X'}}
+ template<class T> friend void A<T>::f();
+ // expected-warning at -1 {{dependent nested name specifier 'A<T>::' for friend class declaration is not supported; turning off access control for 'X'}}
+ template<class T> friend void A<T>::g();
+ // expected-warning at -1 {{dependent nested name specifier 'A<T>::' for friend class declaration is not supported; turning off access control for 'X'}}
+ template<class T> friend void A<T>::C::h();
+ // expected-warning at -1 {{dependent nested name specifier 'A<T>::C::' for friend class declaration is not supported; turning off access control for 'X'}}
};
template<> struct A<int> {
@@ -401,7 +428,8 @@ namespace dr638 { // dr638: no
namespace dr639 { // dr639: 3.3
void f(int i) {
- void((i = 0) + (i = 0)); // expected-warning {{unsequenced}}
+ void((i = 0) + (i = 0));
+ // expected-warning at -1 {{multiple unsequenced modifications to 'i'}}
}
}
@@ -410,36 +438,46 @@ namespace dr641 { // dr641: yes
struct abc;
struct xyz {
- xyz(); // expected-note 0-1{{candidate}}
- xyz(xyz &); // expected-note 0-1{{candidate}}
-
- operator xyz &() = delete; // expected-error 0-1{{extension}} expected-warning {{will never be used}}
- operator abc &() = delete; // expected-error 0-1{{extension}}
+ xyz(); // #dr641-xyz-ctor
+ xyz(xyz &); // #dr641-xyz-copy-ctor
+
+ operator xyz &() = delete;
+ // expected-warning at -1 {{conversion function converting 'dr641::std_example::xyz' to itself will never be used}}
+ // cxx98-error at -2 {{deleted function definitions are a C++11 extension}}
+ operator abc &() = delete;
+ // cxx98-error at -1 {{deleted function definitions are a C++11 extension}}
};
struct abc : xyz {};
template<typename T>
- void use(T &); // expected-note {{expects an lvalue}}
+ void use(T &); // #dr641-use
void test() {
- use<xyz>(xyz()); // expected-error {{no match}}
+ use<xyz>(xyz());
+ // expected-error at -1 {{no matching function for call to 'use'}}
+ // expected-note@#dr641-use {{candidate function template not viable: expects an lvalue for 1st argument}}
use<const xyz>(xyz());
-#if __cplusplus < 201103L
- // expected-error-re at -2 {{no viable constructor copying parameter of type '{{.*}}xyz'}}
-#endif
+ // cxx98-error at -1 {{no viable constructor copying parameter of type 'xyz'; C++98 requires a copy constructor when binding a reference to a temporary}}
+ // cxx98-note@#dr641-xyz-copy-ctor {{candidate constructor not viable: expects an lvalue for 1st argument}}
+ // cxx98-note@#dr641-xyz-ctor {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
}
}
template<typename T> struct error { typedef typename T::error type; };
struct A {
- template<typename T, typename error<T>::type = 0> operator T() const; // expected-error 0-1{{extension}}
+ template<typename T, typename error<T>::type = 0> operator T() const;
+ // cxx98-error at -1 {{default template arguments for a function template are a C++11 extension}}
};
A a;
- void f(A&); // expected-note 2{{candidate}}
+ void f(A&); // #dr641-f
void g(const A ca) {
- f(A()); // expected-error {{no match}}
- f(ca); // expected-error {{no match}}
+ f(A());
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr641-f {{candidate function not viable: expects an lvalue for 1st argument}}
+ f(ca);
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr641-f {{candidate function not viable: 1st argument ('const A') would lose const qualifier}}
(void)A();
(void)ca;
}
@@ -450,7 +488,8 @@ namespace dr642 { // dr642: yes
const int i = 2;
{
char i[i];
- _Static_assert(sizeof(i) == 2, ""); // expected-error {{C11}}
+ _Static_assert(sizeof(i) == 2, "");
+ // expected-error at -1 {{'_Static_assert' is a C11 extension}}
}
}
@@ -468,9 +507,12 @@ namespace dr643 { // dr643: 3.2
auto f() -> decltype(this->x);
auto f(A &a) -> decltype(a.x);
auto g() -> decltype(x);
- auto h() -> decltype(this->y); // expected-error {{no member named 'y'}}
- auto h(A &a) -> decltype(a.y); // expected-error {{no member named 'y'}}
- auto i() -> decltype(y); // expected-error {{undeclared identifier 'y'}}
+ auto h() -> decltype(this->y);
+ // since-cxx11-error at -1 {{no member named 'y' in 'dr643::A'}}
+ auto h(A &a) -> decltype(a.y);
+ // since-cxx11-error at -1 {{no member named 'y' in 'dr643::A'}}
+ auto i() -> decltype(y);
+ // since-cxx11-error at -1 {{use of undeclared identifier 'y'}}
int y;
};
}
@@ -527,40 +569,32 @@ namespace dr647 { // dr647: 3.1
struct A {
constexpr virtual void f() const;
constexpr virtual void g() const {}
-#if __cplusplus <= 201703L
- // expected-error at -2 {{virtual function cannot be constexpr}}
-#endif
+ // cxx11-17-error at -1 {{virtual function cannot be constexpr}}
};
- struct X { virtual void f() const; };
-#if __cplusplus <= 201703L
- // expected-note at -2 {{overridden}}
-#endif
+ struct X { virtual void f() const; }; // #dr647-f
struct B : X {
constexpr void f() const {}
-#if __cplusplus <= 201703L
- // expected-error at -2 {{virtual function cannot be constexpr}}
-#endif
+ // cxx11-17-error at -1 {{virtual function cannot be constexpr}}
+ // cxx11-17-note@#dr647-f {{overridden virtual function is here}}
};
- struct NonLiteral { NonLiteral() {} }; // expected-note {{not an aggregate and has no constexpr constructors}}
+ struct NonLiteral { NonLiteral() {} }; // #dr647-NonLiteral
struct C {
constexpr C(NonLiteral);
- constexpr C(NonLiteral, int) {} // expected-error {{not a literal type}}
+ constexpr C(NonLiteral, int) {}
+ // since-cxx11-error at -1 {{constexpr constructor's 1st parameter type 'NonLiteral' is not a literal type}}
+ // since-cxx11-note@#dr647-NonLiteral {{'NonLiteral' is not literal because it is not an aggregate and has no constexpr constructors other than copy or move constructors}}
constexpr C() try {} catch (...) {}
-#if __cplusplus <= 201703L
- // expected-error at -2 {{function try block in constexpr constructor is a C++20 extension}}
-#endif
-#if __cplusplus < 201402L
- // expected-error at -5 {{use of this statement in a constexpr constructor is a C++14 extension}}
-#endif
+ // cxx11-17-error at -1 {{function try block in constexpr constructor is a C++20 extension}}
+ // cxx11-error at -2 {{use of this statement in a constexpr constructor is a C++14 extension}}
...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/74477
More information about the cfe-commits
mailing list