Author: Vlad Serebrennikov Date: 2025-01-05T21:29:32+03:00 New Revision: f53abc2db07abfa38af9365bc15572112adbe040
URL: https://github.com/llvm/llvm-project/commit/f53abc2db07abfa38af9365bc15572112adbe040 DIFF: https://github.com/llvm/llvm-project/commit/f53abc2db07abfa38af9365bc15572112adbe040.diff LOG: [clang][NFC] Refactor expected directives in CWG2881 test Added: Modified: clang/test/CXX/drs/cwg28xx.cpp Removed: ################################################################################ diff --git a/clang/test/CXX/drs/cwg28xx.cpp b/clang/test/CXX/drs/cwg28xx.cpp index b0c46ee2d493a2..2cad2814cd6861 100644 --- a/clang/test/CXX/drs/cwg28xx.cpp +++ b/clang/test/CXX/drs/cwg28xx.cpp @@ -174,9 +174,7 @@ void g() { } // namespace cwg2877 namespace cwg2881 { // cwg2881: 19 - #if __cplusplus >= 202302L - template <typename T> struct A : T {}; template <typename T> struct B : T {}; template <typename T> struct C : virtual T { C(T t) : T(t) {} }; @@ -188,12 +186,12 @@ struct O1 : A<Ts>, B<Ts> { using B<Ts>::operator(); }; -template <typename Ts> struct O2 : protected Ts { // expected-note {{declared protected here}} +template <typename Ts> struct O2 : protected Ts { // #cwg2881-O2 using Ts::operator(); O2(Ts ts) : Ts(ts) {} }; -template <typename Ts> struct O3 : private Ts { // expected-note {{declared private here}} +template <typename Ts> struct O3 : private Ts { // #cwg2881-O3 using Ts::operator(); O3(Ts ts) : Ts(ts) {} }; @@ -217,7 +215,7 @@ struct O5 : private C<Ts>, D<Ts> { // This is only invalid if we call T's call operator. template <typename T, typename U> -struct O6 : private T, U { // expected-note {{declared private here}} +struct O6 : private T, U { // #cwg2881-O6 using T::operator(); using U::operator(); O6(T t, U u) : T(t), U(u) {} @@ -227,14 +225,26 @@ void f() { int x; auto L1 = [=](this auto&& self) { (void) &x; }; auto L2 = [&](this auto&& self) { (void) &x; }; - O1<decltype(L1)>{L1, L1}(); // expected-error {{inaccessible due to ambiguity}} - O1<decltype(L2)>{L2, L2}(); // expected-error {{inaccessible due to ambiguity}} - O2{L1}(); // expected-error {{must derive publicly from the lambda}} - O3{L1}(); // expected-error {{must derive publicly from the lambda}} + O1<decltype(L1)>{L1, L1}(); + /* since-cxx23-error-re@-1 {{inaccessible due to ambiguity: + struct cwg2881::O1<class (lambda at {{.+}})> -> A<(lambda at {{.+}})> -> class (lambda at {{.+}}) + struct cwg2881::O1<class (lambda at {{.+}})> -> B<(lambda at {{.+}})> -> class (lambda at {{.+}})}}*/ + O1<decltype(L2)>{L2, L2}(); + /* since-cxx23-error-re@-1 {{inaccessible due to ambiguity: + struct cwg2881::O1<class (lambda at {{.+}})> -> A<(lambda at {{.+}})> -> class (lambda at {{.+}}) + struct cwg2881::O1<class (lambda at {{.+}})> -> B<(lambda at {{.+}})> -> class (lambda at {{.+}})}}*/ + O2{L1}(); + // since-cxx23-error-re@-1 {{invalid explicit object parameter type 'cwg2881::O2<(lambda at {{.+}})>' in lambda with capture; the type must derive publicly from the lambda}} + // since-cxx23-note@#cwg2881-O2 {{declared protected here}} + O3{L1}(); + // since-cxx23-error-re@-1 {{invalid explicit object parameter type 'cwg2881::O3<(lambda at {{.+}})>' in lambda with capture; the type must derive publicly from the lambda}} + // since-cxx23-note@#cwg2881-O3 {{declared private here}} O4{L1}(); O5{L1}(); O6 o{L1, L2}; - o.decltype(L1)::operator()(); // expected-error {{must derive publicly from the lambda}} + o.decltype(L1)::operator()(); + // since-cxx23-error-re@-1 {{invalid explicit object parameter type 'cwg2881::O6<(lambda at {{.+}}), (lambda at {{.+}})>' in lambda with capture; the type must derive publicly from the lambda}} + // since-cxx23-note@#cwg2881-O6 {{declared private here}} o.decltype(L1)::operator()(); // No error here because we've already diagnosed this method. o.decltype(L2)::operator()(); } @@ -243,12 +253,14 @@ void f2() { int x = 0; auto lambda = [x] (this auto self) { return x; }; using Lambda = decltype(lambda); - struct D : private Lambda { // expected-note {{declared private here}} + struct D : private Lambda { // #cwg2881-D D(Lambda l) : Lambda(l) {} using Lambda::operator(); friend Lambda; } d(lambda); - d(); // expected-error {{must derive publicly from the lambda}} + d(); + // since-cxx23-error@-1 {{invalid explicit object parameter type 'D' in lambda with capture; the type must derive publicly from the lambda}} + // since-cxx23-note@#cwg2881-D {{declared private here}} } template <typename L> @@ -263,18 +275,20 @@ struct Indirect : T { }; template<typename T> -struct Ambiguous : Indirect<T>, T { // expected-warning {{is inaccessible due to ambiguity}} +struct Ambiguous : Indirect<T>, T { +/* since-cxx23-warning-re@-1 {{direct base '(lambda at {{.+}})' is inaccessible due to ambiguity: + struct cwg2881::Ambiguous<class (lambda at {{.+}})> -> Indirect<(lambda at {{.+}})> -> class (lambda at {{.+}}) + struct cwg2881::Ambiguous<class (lambda at {{.+}})> -> class (lambda at {{.+}})}}*/ +// since-cxx23-note-re@#cwg2881-f4 {{in instantiation of template class 'cwg2881::Ambiguous<(lambda at {{.+}})>' requested here}} +// since-cxx34-note-re@#cwg2881-f4-call {{while substituting deduced template arguments into function template 'f4' [with L = (lambda at {{.+}})]}} using Indirect<T>::operator(); }; template <typename L> -constexpr auto f3(L l) -> decltype(Private<L>{l}()) { return l(); } -// expected-note@-1 {{must derive publicly from the lambda}} +constexpr auto f3(L l) -> decltype(Private<L>{l}()) { return l(); } // #cwg2881-f3 template <typename L> -constexpr auto f4(L l) -> decltype(Ambiguous<L>{{l}, l}()) { return l(); } -// expected-note@-1 {{is inaccessible due to ambiguity}} -// expected-note@-2 {{in instantiation of template class}} +constexpr auto f4(L l) -> decltype(Ambiguous<L>{{l}, l}()) { return l(); } // #cwg2881-f4 template<typename T> concept is_callable = requires(T t) { { t() }; }; @@ -282,15 +296,19 @@ concept is_callable = requires(T t) { { t() }; }; void g() { int x = 0; auto lambda = [x](this auto self) {}; - f3(lambda); // expected-error {{no matching function for call to 'f3'}} - f4(lambda); // expected-error {{no matching function for call to 'f4'}} - // expected-note@-1 {{while substituting deduced template arguments into function template 'f4'}} + f3(lambda); + // since-cxx23-error@-1 {{no matching function for call to 'f3'}} + // since-cxx23-note-re@#cwg2881-f3 {{candidate template ignored: substitution failure [with L = (lambda at {{.+}})]: invalid explicit object parameter type 'cwg2881::Private<(lambda at {{.+}})>' in lambda with capture; the type must derive publicly from the lambda}} + f4(lambda); // #cwg2881-f4-call + // expected-error@-1 {{no matching function for call to 'f4'}} + // expected-note-re@-2 {{while substituting deduced template arguments into function template 'f4' [with L = (lambda at {{.+}})]}} + /* expected-note-re@#cwg2881-f4 {{candidate template ignored: substitution failure [with L = (lambda at {{.+}})]: lambda '(lambda at {{.+}})' is inaccessible due to ambiguity: + struct cwg2881::Ambiguous<class (lambda at {{.+}})> -> Indirect<(lambda at {{.+}})> -> class (lambda at {{.+}}) + struct cwg2881::Ambiguous<class (lambda at {{.+}})> -> class (lambda at {{.+}})}}*/ static_assert(!is_callable<Private<decltype(lambda)>>); static_assert(!is_callable<Ambiguous<decltype(lambda)>>); } - #endif - } // namespace cwg2881 namespace cwg2882 { // cwg2882: 2.7 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
