[clang][NFC] Refactor expected directives in C++ DRs 1-99 #73879
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This patch converts (almost) every expected directive in `test/CXX/drs/dr0xx.cpp` into either `@-1` form (when directive immediately follow the line diagnostic is pointing out to), or `@#<marker>` form (when directive is placed away from the line diagnostic is pointing out to). It also converts directive to match exactly one diagnostic, as opposed to matching multiple. Error messages are expanded to exactly match compiler output. `#if __cplusplus` guarding directives are replaced with respective prefixes (e.g. `since-cxx17`). All aforementioned changes serve a purpose of making it easier to reconstruct expected compiler output, which should also make it a bit easier to grasp the gist of those already non-trivial tests due to their nature of testing corner cases of the language.
Endilll
added
clang
|
@llvm/pr-subscribers-clang Author: Vlad Serebrennikov (Endilll) ChangesThis patch converts (almost) every expected directive in All aforementioned changes serve a purpose of making it easier to reconstruct expected compiler output, which should also make it a bit easier to grasp the gist of those already non-trivial tests due to their nature of testing corner cases of the language. Patch is 58.25 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/73879.diff 1 Files Affected:
diff --git a/clang/test/CXX/drs/dr0xx.cpp b/clang/test/CXX/drs/dr0xx.cpp
index 1210c7a834e5970..e79ce6daf2655c5 100644
--- a/clang/test/CXX/drs/dr0xx.cpp
+++ b/clang/test/CXX/drs/dr0xx.cpp
@@ -1,9 +1,9 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
-// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
-// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected,cxx98,cxx98-14 -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,since-cxx11,cxx98-14,cxx11-14 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,since-cxx11,cxx98-14,cxx11-14 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
namespace dr1 { // dr1: no
namespace X { extern "C" void dr1_f(int a = 1); }
@@ -26,9 +26,11 @@ namespace dr1 { // dr1: no
namespace X {
void z(int);
}
- void X::z(int = 1) {} // expected-note {{previous}}
+ void X::z(int = 1) {} // #dr1-z
namespace X {
- void z(int = 1); // expected-error {{redefinition of default argument}}
+ void z(int = 1);
+ // expected-error@-1 {{redefinition of default argument}}
+ // expected-note@#dr1-z {{previous definition is here}}
}
void i(int = 1);
@@ -50,17 +52,21 @@ namespace dr1 { // dr1: no
namespace dr3 { // dr3: yes
template<typename T> struct A {};
- template<typename T> void f(T) { A<T> a; } // expected-note {{implicit instantiation}}
+ template<typename T> void f(T) { A<T> a; } // #dr3-f-T
template void f(int);
- template<> struct A<int> {}; // expected-error {{explicit specialization of 'dr3::A<int>' after instantiation}}
+ template<> struct A<int> {};
+ // expected-error@-1 {{explicit specialization of 'dr3::A<int>' after instantiation}}
+ // expected-note@#dr3-f-T {{implicit instantiation first required here}}
}
namespace dr4 { // dr4: yes
extern "C" {
static void dr4_f(int) {}
static void dr4_f(float) {}
- void dr4_g(int) {} // expected-note {{previous}}
- void dr4_g(float) {} // expected-error {{conflicting types}}
+ void dr4_g(int) {} // #dr4-g-int
+ void dr4_g(float) {}
+ // expected-error@-1 {{conflicting types for 'dr4_g'}}
+ // expected-note@#dr4-g-int {{previous definition is here}}
}
}
@@ -80,14 +86,21 @@ namespace dr5 { // dr5: 3.1
namespace dr7 { // dr7: 3.4
class A { public: ~A(); };
- class B : virtual private A {}; // expected-note 2 {{declared private here}}
- class C : public B {} c; // expected-error 2 {{inherited virtual base class 'A' has private destructor}} \
- // expected-note {{implicit default constructor for 'dr7::C' first required here}} \
- // expected-note {{implicit destructor for 'dr7::C' first required here}}
+ class B : virtual private A {}; // #dr7-B
+ class C : public B {} c; // #dr7-C
+ // expected-error@#dr7-C {{inherited virtual base class 'A' has private destructor}}
+ // expected-note@#dr7-C {{in implicit default constructor for 'dr7::C' first required here}}
+ // expected-note@#dr7-B {{declared private here}}
+
+ // expected-error@#dr7-C {{inherited virtual base class 'A' has private destructor}}
+ // expected-note@#dr7-C {{in implicit destructor for 'dr7::C' first required here}}
+ // expected-note@#dr7-B {{declared private here}}
class VeryDerivedC : public B, virtual public A {} vdc;
- class X { ~X(); }; // expected-note {{here}}
- class Y : X { ~Y() {} }; // expected-error {{private destructor}}
+ class X { ~X(); }; // #dr7-X
+ class Y : X { ~Y() {} };
+ // expected-error@-1 {{base class 'X' has private destructor}}
+ // expected-note@#dr7-X {{implicitly declared private here}}
namespace PR16370 { // This regressed the first time DR7 was fixed.
struct S1 { virtual ~S1(); };
@@ -117,13 +130,16 @@ namespace dr8 { // dr8: dup 45
namespace dr9 { // dr9: 2.8
struct B {
protected:
- int m; // expected-note {{here}}
+ int m; // #dr9-m
friend int R1();
};
- struct N : protected B { // expected-note {{protected}}
+ struct N : protected B { // #dr9-N
friend int R2();
} n;
- int R1() { return n.m; } // expected-error {{protected member}}
+ int R1() { return n.m; }
+ // expected-error@-1 {{'m' is a protected member of 'dr9::B'}}
+ // expected-note@#dr9-N {{constrained by protected inheritance here}}
+ // expected-note@#dr9-m {{member is declared here}}
int R2() { return n.m; }
}
@@ -142,7 +158,8 @@ namespace dr11 { // dr11: yes
};
template<typename T> struct B : T {
using T::V;
- V v; // expected-error {{unknown type name}}
+ V v;
+ // expected-error@-1 {{unknown type name 'V'}}
};
struct X { typedef int U; };
A<X> ax;
@@ -190,27 +207,41 @@ namespace dr14 { // dr14: 3.4
extern "C" int dr14_f() { return c.k; }
}
- namespace X { typedef int T; typedef int U; } // expected-note {{candidate}}
- namespace Y { typedef int T; typedef long U; } // expected-note {{candidate}}
+ namespace X { typedef int T; typedef int U; } // #dr14-X-U
+ namespace Y { typedef int T; typedef long U; } // #dr14-Y-U
T t; // ok, same type both times
- U u; // expected-error {{ambiguous}}
+ U u;
+ // expected-error@-1 {{reference to 'U' is ambiguous}}
+ // expected-note@#dr14-X-U {{candidate found by name lookup is 'dr14::X::U'}}
+ // expected-note@#dr14-Y-U {{candidate found by name lookup is 'dr14::Y::U'}}
}
namespace dr15 { // dr15: yes
- template<typename T> void f(int); // expected-note {{previous}}
- template<typename T> void f(int = 0); // expected-error {{default arguments cannot be added}}
+ template<typename T> void f(int); // #dr15-f-decl-first
+ template<typename T> void f(int = 0);
+ // expected-error@-1 {{default arguments cannot be added to a function template that has already been declared}}
+ // expected-note@#dr15-f-decl-first {{previous template declaration is here}}
}
namespace dr16 { // dr16: 2.8
- class A { // expected-note {{here}}
- void f(); // expected-note {{here}}
+ class A { // #dr16-A
+ void f(); // #dr16-A-f-decl
friend class C;
};
- class B : A {}; // expected-note 3{{here}}
+ class B : A {}; // #dr16-B
class C : B {
void g() {
- f(); // expected-error {{private member}}
- A::f(); // expected-error {{private member}} expected-error {{private base}}
+ f();
+ // expected-error@-1 {{'f' is a private member of 'dr16::A'}}
+ // expected-note@#dr16-B {{constrained by implicitly private inheritance here}}
+ // expected-note@#dr16-A-f-decl {{member is declared here}}
+ A::f(); // #dr16-A-f-call
+ // expected-error@#dr16-A-f-call {{'A' is a private member of 'dr16::A'}}
+ // expected-note@#dr16-B {{constrained by implicitly private inheritance here}}
+ // expected-note@#dr16-A {{member is declared here}}
+
+ // expected-error@#dr16-A-f-call {{cannot cast 'dr16::C' to its private base class 'dr16::A'}}
+ // expected-note@#dr16-B {{implicitly declared private here}}
}
};
}
@@ -232,13 +263,16 @@ namespace dr17 { // dr17: yes
namespace dr19 { // dr19: 3.1
struct A {
- int n; // expected-note {{here}}
+ int n; // #dr19-n
};
- struct B : protected A { // expected-note {{here}}
+ struct B : protected A { // #dr19-B
};
struct C : B {} c;
struct D : B {
- int get1() { return c.n; } // expected-error {{protected member}}
+ int get1() { return c.n; }
+ // expected-error@-1 {{'n' is a protected member of 'dr19::A'}}
+ // expected-note@#dr19-B {{constrained by protected inheritance here}}
+ // expected-note@#dr19-n {{member is declared here}}
int get2() { return ((A&)c).n; } // ok, A is an accessible base of B from here
};
}
@@ -248,86 +282,94 @@ namespace dr20 { // dr20: 2.8
public:
X();
private:
- X(const X&); // expected-note {{here}}
+ X(const X&); // #dr20-X-ctor
};
X &f();
- X x = f(); // expected-error {{private}}
+ X x = f();
+ // expected-error@-1 {{calling a private constructor of class 'dr20::X'}}
+ // expected-note@#dr20-X-ctor {{declared private here}}
}
namespace dr21 { // dr21: 3.4
template<typename T> struct A;
struct X {
- template<typename T = int> friend struct A; // expected-error {{default template argument not permitted on a friend template}}
- template<typename T = int> friend struct B; // expected-error {{default template argument not permitted on a friend template}}
+ template<typename T = int> friend struct A;
+ // expected-error@-1 {{default template argument not permitted on a friend template}}
+ template<typename T = int> friend struct B;
+ // expected-error@-1 {{default template argument not permitted on a friend template}}
};
}
namespace dr22 { // dr22: sup 481
- template<typename dr22_T = dr22_T> struct X; // expected-error {{unknown type name 'dr22_T'}}
+ template<typename dr22_T = dr22_T> struct X;
+ // expected-error@-1 {{unknown type name 'dr22_T'}}
typedef int T;
template<typename T = T> struct Y;
}
namespace dr23 { // dr23: yes
- template<typename T> void f(T, T); // expected-note {{candidate}}
- template<typename T> void f(T, int); // expected-note {{candidate}}
- void g() { f(0, 0); } // expected-error {{ambiguous}}
+ template<typename T> void f(T, T); // #dr23-f-T-T
+ template<typename T> void f(T, int); // #dr23-f-T-int
+ void g() { f(0, 0); }
+ // expected-error@-1 {{call to 'f' is ambiguous}}
+ // expected-note@#dr23-f-T-T {{candidate function [with T = int]}}
+ // expected-note@#dr23-f-T-int {{candidate function [with T = int]}}
}
// dr24: na
namespace dr25 { // dr25: yes
struct A {
- void f() throw(int); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ void f() throw(int);
+ // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}
};
- void (A::*f)() throw (int); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ void (A::*f)() throw (int);
+ // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}
void (A::*g)() throw () = f;
-#if __cplusplus <= 201402L
- // expected-error@-2 {{is not superset of source}}
-#else
- // expected-error@-4 {{different exception specifications}}
-#endif
+ // cxx98-14-error@-1 {{target exception specification is not superset of source}}
+ // since-cxx17-error@-2 {{different exception specifications}}
void (A::*g2)() throw () = 0;
- void (A::*h)() throw (int, char) = f; // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ void (A::*h)() throw (int, char) = f;
+ // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}
void (A::*i)() throw () = &A::f;
-#if __cplusplus <= 201402L
- // expected-error@-2 {{is not superset of source}}
-#else
- // expected-error@-4 {{different exception specifications}}
-#endif
+ // cxx98-14-error@-1 {{target exception specification is not superset of source}}
+ // since-cxx17-error@-2 {{different exception specifications}}
void (A::*i2)() throw () = 0;
- void (A::*j)() throw (int, char) = &A::f; // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ void (A::*j)() throw (int, char) = &A::f;
+ // since-cxx17-error@-1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note@-2 {{use 'noexcept(false)' instead}}
void x() {
g2 = f;
-#if __cplusplus <= 201402L
- // expected-error@-2 {{is not superset of source}}
-#else
- // expected-error@-4 {{different exception specifications}}
-#endif
+ // cxx98-14-error@-1 {{target exception specification is not superset of source}}
+ // since-cxx17-error@-2 {{different exception specifications}}
h = f;
i2 = &A::f;
-#if __cplusplus <= 201402L
- // expected-error@-2 {{is not superset of source}}
-#else
- // expected-error@-4 {{different exception specifications}}
-#endif
+ // cxx98-14-error@-1 {{target exception specification is not superset of source}}
+ // since-cxx17-error@-2 {{different exception specifications}}
j = &A::f;
}
}
namespace dr26 { // dr26: yes
- struct A { A(A, const A & = A()); }; // expected-error {{must pass its first argument by reference}}
+ struct A { A(A, const A & = A()); };
+ // expected-error@-1 {{copy constructor must pass its first argument by reference}}
struct B {
B();
// FIXME: In C++98, we diagnose this twice.
B(const B &, B = B());
-#if __cplusplus <= 201402L
- // expected-error@-2 1+{{recursive evaluation of default argument}} expected-note@-2 1+{{used here}}
-#endif
+ // cxx98-14-error@-1 {{recursive evaluation of default argument}}
+ // cxx98-14-note@-2 {{default argument used here}}
+ // cxx98-error@-3 {{recursive evaluation of default argument}}
+ // cxx98-note@-4 {{default argument used here}}
};
struct C {
static C &f();
- C(const C &, C = f()); // expected-error {{recursive evaluation of default argument}} expected-note {{used here}}
+ C(const C &, C = f());
+ // expected-error@-1 {{recursive evaluation of default argument}}
+ // expected-note@-2 {{default argument used here}}
};
}
@@ -339,24 +381,34 @@ namespace dr27 { // dr27: yes
// dr28: na lib
namespace dr29 { // dr29: 3.4
- void dr29_f0(); // expected-note {{here}}
+ void dr29_f0(); // #dr29-f0
void g0() { void dr29_f0(); }
extern "C++" void g0_cxx() { void dr29_f0(); }
- extern "C" void g0_c() { void dr29_f0(); } // expected-error {{different language linkage}}
+ extern "C" void g0_c() { void dr29_f0(); }
+ // expected-error@-1 {{declaration of 'dr29_f0' has a different language linkage}}
+ // expected-note@#dr29-f0 {{previous declaration is here}}
- extern "C" void dr29_f1(); // expected-note {{here}}
+ extern "C" void dr29_f1(); // #dr29-f1
void g1() { void dr29_f1(); }
extern "C" void g1_c() { void dr29_f1(); }
- extern "C++" void g1_cxx() { void dr29_f1(); } // expected-error {{different language linkage}}
+ extern "C++" void g1_cxx() { void dr29_f1(); }
+ // expected-error@-1 {{declaration of 'dr29_f1' has a different language linkage}}
+ // expected-note@#dr29-f1 {{previous declaration is here}}
- void g2() { void dr29_f2(); } // expected-note {{here}}
- extern "C" void dr29_f2(); // expected-error {{different language linkage}}
+ void g2() { void dr29_f2(); } // #dr29-f2
+ extern "C" void dr29_f2();
+ // expected-error@-1 {{declaration of 'dr29_f2' has a different language linkage}}
+ // expected-note@#dr29-f2 {{previous declaration is here}}
- extern "C" void g3() { void dr29_f3(); } // expected-note {{here}}
- extern "C++" void dr29_f3(); // expected-error {{different language linkage}}
+ extern "C" void g3() { void dr29_f3(); } // #dr29-f3
+ extern "C++" void dr29_f3();
+ // expected-error@-1 {{declaration of 'dr29_f3' has a different language linkage}}
+ // expected-note@#dr29-f3 {{previous declaration is here}}
- extern "C++" void g4() { void dr29_f4(); } // expected-note {{here}}
- extern "C" void dr29_f4(); // expected-error {{different language linkage}}
+ extern "C++" void g4() { void dr29_f4(); } // #dr29-f4
+ extern "C" void dr29_f4();
+ // expected-error@-1 {{declaration of 'dr29_f4' has a different language linkage}}
+ // expected-note@#dr29-f4 {{previous declaration is here}}
extern "C" void g5();
extern "C++" void dr29_f5();
@@ -371,15 +423,19 @@ namespace dr29 { // dr29: 3.4
}
extern "C" void g7();
- extern "C++" void dr29_f7(); // expected-note {{here}}
+ extern "C++" void dr29_f7(); // #dr29-f7
extern "C" void g7() {
- void dr29_f7(); // expected-error {{different language linkage}}
+ void dr29_f7();
+ // expected-error@-1 {{declaration of 'dr29_f7' has a different language linkage}}
+ // expected-note@#dr29-f7 {{previous declaration is here}}
}
extern "C++" void g8();
- extern "C" void dr29_f8(); // expected-note {{here}}
+ extern "C" void dr29_f8(); // #dr29-f8
extern "C++" void g8() {
- void dr29_f8(); // expected-error {{different language linkage}}
+ void dr29_f8();
+ // expected-error@-1 {{declaration of 'dr29_f8' has a different language linkage}}
+ // expected-note@#dr29-f8 {{previous declaration is here}}
}
}
@@ -387,38 +443,42 @@ namespace dr30 { // dr30: sup 468 c++11
struct A {
template<int> static int f();
} a, *p = &a;
+ // FIXME: It's not clear whether DR468 applies to C++98 too.
int x = A::template f<0>();
+ // cxx98-error@-1 {{'template' keyword outside of a template}}
int y = a.template f<0>();
+ // cxx98-error@-1 {{'template' keyword outside of a template}}
int z = p->template f<0>();
-#if __cplusplus < 201103L
- // FIXME: It's not clear whether DR468 applies to C++98 too.
- // expected-error@-5 {{'template' keyword outside of a template}}
- // expected-error@-5 {{'template' keyword outside of a template}}
- // expected-error@-5 {{'template' keyword outside of a template}}
-#endif
+ // cxx98-error@-1 {{'template' keyword outside of a template}}
}
namespace dr31 { // dr31: 2.8
class X {
private:
- void operator delete(void*); // expected-note {{here}}
+ void operator delete(void*); // #dr31-delete
};
// We would call X::operator delete if X() threw (even though it can't,
// and even though we allocated the X using ::operator delete).
- X *p = new X; // expected-error {{private}}
+ X *p = new X;
+ // expected-error@-1 {{'operator delete' is a private member of 'dr31::X'}}
+ // expected-note@#dr31-delete {{declared private here}}
}
// dr32: na
namespace dr33 { // dr33: 9
- namespace X { struct S; void f(void (*)(S)); } // expected-note {{candidate}}
- namespace Y { struct T; void f(void (*)(T)); } // expected-note {{candidate}}
+ namespace X { struct S; void f(void (*)(S)); } // #dr33-f-S
+ namespace Y { struct T; void f(void (*)(T)); } // #dr33-f-T
void g(X::S);
template<typename Z> Z g(Y::T);
- void h() { f(&g); } // expected-error {{ambiguous}}
+ void h() { f(&g); }
+ // expected-error@-1 {{call to 'f' is ambiguous}}
+ // expected-note@#dr33-f-S {{candidate function}}
+ // expected-note@#dr33-f-T {{candidate function}}
template<typename T> void t(X::S);
- template<typename T, typename U = void> void u(X::S); // expected-error 0-1{{default template argument}}
+ template<typename T, typename U = void> void u(X::S);
+ // expected-error@-1 0-1 {{default template arguments for a function template are a C++11 extension}}
void templ() { f(t<int>); f(u<int>); }
// Even though v<int> cannot select the first overload, ADL considers it
@@ -436,7 +496,8 @@ namespace dr33 { // dr33: 9
};
template<typename T> void f(Y<T>);
- int use = X() + f<int>; // expected-error {{invalid operands}}
+ int use = X() + f<int>;
+ // expected-error@-1 {{invalid operands to binary expression ('X' and 'void (Y<int>)')}}
}
namespace member {
@@ -481,17 +542,25 @@ namespace example2 {
struct D : virtual B, virtual C
{
- using B::i; // expected-note {{previous using decla...
[truncated]
|
|
I'm putting this NFC for a review, because that's the direction I'd like our DR test suite to take. If it goes well, I'll go on and refactor the rest of the test suite in this manner. |
shafik
reviewed
Nov 30, 2023
| class C : public B {} c; // #dr7-C | ||
| // expected-error@#dr7-C {{inherited virtual base class 'A' has private destructor}} | ||
| // expected-note@#dr7-C {{in implicit default constructor for 'dr7::C' first required here}} | ||
| // expected-note@#dr7-B {{declared private here}} |
There was a problem hiding this comment.
I have to say, it is kind of messing with me that we have -C before -B but I then realized that B and C are the class names here and don't imply some sort of ordering.
I wanted to point that out in case others also felt that way.
There was a problem hiding this comment.
I had a thought of naming those markers dr7-struct-C, but decided to prioritize shorter markers. If you find this more accessible, we can do it this way.
There was a problem hiding this comment.
I thought that lower case vs upper case makes enough distinction, but I don't insist.
There was a problem hiding this comment.
I think the shorter markers are OK. This is already vastly more readable, and we can blame CWG for making the tokens confusing :)
There was a problem hiding this comment.
This is not a sticking point for me, just an observation and to see how others felt.
erichkeane
reviewed
Nov 30, 2023
There was a problem hiding this comment.
I did a quick scroll-through and believe this is definitely a direction I want us to take.
I could nit on the naming conventions here or there, but I think this overall is such a vast improvement that I'd rather get 'this', then argue on names in future files, and let this one lie.
| class C : public B {} c; // #dr7-C | ||
| // expected-error@#dr7-C {{inherited virtual base class 'A' has private destructor}} | ||
| // expected-note@#dr7-C {{in implicit default constructor for 'dr7::C' first required here}} | ||
| // expected-note@#dr7-B {{declared private here}} |
There was a problem hiding this comment.
I think the shorter markers are OK. This is already vastly more readable, and we can blame CWG for making the tokens confusing :)
@erichkeane Now is the best time to bring those nits on, unless you want changes in C++ code (this is out of scope of this PR and my current efforts, which is focused on |
I am ok with the bookmark names, but the 'verify' names seem really confusing. I don't really have a better suggestion unfortunately, so my response would be mostly grumbling that they're not all the same format. Perhaps a 'standardized' 'set' that we use everywhere would be less confusing. |
Endilll
added a commit
that referenced
this pull request
Jan 13, 2024
Refactoring started in #73879 has unfortunately missed to add indentation to `expected-note` directives. This patch is a follow-up to that refactoring.
justinfargnoli
pushed a commit
to justinfargnoli/llvm-project
that referenced
this pull request
Jan 28, 2024
Refactoring started in llvm#73879 has unfortunately missed to add indentation to `expected-note` directives. This patch is a follow-up to that refactoring.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This patch converts (almost) every expected directive in
test/CXX/drs/dr0xx.cppinto either@-1form (when directive immediately follow the line diagnostic is pointing out to), or@#<marker>form (when directive is placed away from the line diagnostic is pointing out to). It also converts directive to match exactly one diagnostic, as opposed to matching multiple. Error messages are expanded to exactly match compiler output.#if __cplusplusguarding directives are replaced with respective prefixes (e.g.since-cxx17).All aforementioned changes serve a purpose of making it easier to reconstruct expected compiler output, which should also make it a bit easier to grasp the gist of those already non-trivial tests due to their nature of testing corner cases of the language.