llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang Author: Vlad Serebrennikov (Endilll) <details> <summary>Changes</summary> 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. --- 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: - (modified) clang/test/CXX/drs/dr0xx.cpp (+496-290) ``````````diff 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] `````````` </details> https://github.com/llvm/llvm-project/pull/73879 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
