diff --git a/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.verify.cpp b/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.verify.cpp --- a/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.verify.cpp +++ b/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.verify.cpp @@ -46,12 +46,12 @@ void function_pointer() { { volatile std::atomic fun; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} + // expected-error@*:* {{static assertion failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} std::atomic_fetch_add(&fun, 0); } { std::atomic fun; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} + // expected-error@*:* {{static assertion failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} std::atomic_fetch_add(&fun, 0); } } diff --git a/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.verify.cpp b/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.verify.cpp --- a/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.verify.cpp +++ b/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.verify.cpp @@ -49,12 +49,12 @@ void function_pointer() { { volatile std::atomic fun; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} + // expected-error@*:* {{static assertion failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} std::atomic_fetch_add_explicit(&fun, 0, std::memory_order_relaxed); } { std::atomic fun; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} + // expected-error@*:* {{static assertion failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} std::atomic_fetch_add_explicit(&fun, 0, std::memory_order_relaxed); } } diff --git a/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.verify.cpp b/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.verify.cpp --- a/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.verify.cpp +++ b/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.verify.cpp @@ -46,12 +46,12 @@ void function_pointer() { { volatile std::atomic fun; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} + // expected-error@*:* {{static assertion failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} std::atomic_fetch_sub(&fun, 0); } { std::atomic fun; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} + // expected-error@*:* {{static assertion failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} std::atomic_fetch_sub(&fun, 0); } } diff --git a/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.verify.cpp b/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.verify.cpp --- a/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.verify.cpp +++ b/libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.verify.cpp @@ -49,12 +49,12 @@ void function_pointer() { { volatile std::atomic fun; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} + // expected-error@*:* {{static assertion failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} std::atomic_fetch_sub_explicit(&fun, 0, std::memory_order_relaxed); } { std::atomic fun; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} + // expected-error@*:* {{static assertion failed due to requirement '!is_function::value'{{.*}}Pointer to function isn't allowed}} std::atomic_fetch_sub_explicit(&fun, 0, std::memory_order_relaxed); } } diff --git a/libcxx/test/libcxx/containers/sequences/vector/invalid_allocator.verify.cpp b/libcxx/test/libcxx/containers/sequences/vector/invalid_allocator.verify.cpp --- a/libcxx/test/libcxx/containers/sequences/vector/invalid_allocator.verify.cpp +++ b/libcxx/test/libcxx/containers/sequences/vector/invalid_allocator.verify.cpp @@ -24,5 +24,5 @@ }; void func() { - std::vector v; //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}This allocator has to implement rebind}} + std::vector v; //expected-error@*:* {{static assertion failed {{.*}}This allocator has to implement rebind}} } diff --git a/libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp b/libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp --- a/libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp +++ b/libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp @@ -20,7 +20,7 @@ int main(int, char**) { std::basic_filebuf > f; - // expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}} + // expected-error-re@streambuf:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} // expected-error@fstream:* {{only virtual member functions can be marked 'override'}} // expected-error@fstream:* {{only virtual member functions can be marked 'override'}} // expected-error@fstream:* {{only virtual member functions can be marked 'override'}} diff --git a/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp b/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp --- a/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp +++ b/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp @@ -20,8 +20,8 @@ int main(int, char**) { std::basic_fstream > f; -// expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}} -// expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}} +// expected-error-re@ios:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} +// expected-error-re@streambuf:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} // expected-error@fstream:* {{only virtual member functions can be marked 'override'}} // expected-error@fstream:* {{only virtual member functions can be marked 'override'}} diff --git a/libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp b/libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp --- a/libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp +++ b/libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp @@ -25,7 +25,7 @@ int main(int, char**) { -// expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}} +// expected-error-re@ios:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} // expected-error@istream:* {{only virtual member functions can be marked 'override'}} return 0; diff --git a/libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp b/libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp --- a/libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp +++ b/libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp @@ -25,7 +25,7 @@ int main(int, char**) { -// expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}} +// expected-error-re@ios:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} // expected-error@ostream:* {{only virtual member functions can be marked 'override'}} return 0; diff --git a/libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp b/libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp --- a/libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp +++ b/libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp @@ -21,8 +21,8 @@ int main(int, char**) { std::basic_stringbuf > sb; -// expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}} -// expected-error-re@string:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}} +// expected-error-re@streambuf:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} +// expected-error-re@string:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} // expected-error@sstream:* {{only virtual member functions can be marked 'override'}} // expected-error@sstream:* {{only virtual member functions can be marked 'override'}} diff --git a/libcxx/test/libcxx/iterators/predef.iterators/reverse.iterators/bad_template_argument.verify.cpp b/libcxx/test/libcxx/iterators/predef.iterators/reverse.iterators/bad_template_argument.verify.cpp --- a/libcxx/test/libcxx/iterators/predef.iterators/reverse.iterators/bad_template_argument.verify.cpp +++ b/libcxx/test/libcxx/iterators/predef.iterators/reverse.iterators/bad_template_argument.verify.cpp @@ -18,5 +18,5 @@ void f() { using BadIter = std::reverse_iterator>; - BadIter i; //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}reverse_iterator requires It to be a bidirectional iterator.}} + BadIter i; //expected-error@*:* {{static assertion failed{{.*}}reverse_iterator requires It to be a bidirectional iterator.}} } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/bad_engine.verify.cpp @@ -26,6 +26,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 7 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 7 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/bad_engine.verify.cpp @@ -26,6 +26,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 7 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 7 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 3 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 3 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/bad_engine.verify.cpp @@ -26,6 +26,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 4 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 4 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 5 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 5 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 3 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 3 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/bad_engine.verify.cpp @@ -26,6 +26,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 4 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 4 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/bad_engine.verify.cpp @@ -26,6 +26,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/bad_engine.verify.cpp b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/bad_engine.verify.cpp --- a/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/bad_engine.verify.cpp +++ b/libcxx/test/libcxx/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/bad_engine.verify.cpp @@ -25,6 +25,6 @@ G badg; G okg; - dist(badg); //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed}} //expected-note {{in instantiation}} + dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}} dist(okg); } diff --git a/libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp @@ -52,7 +52,7 @@ { std::expected f1(1); f1.and_then(lval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::and_then' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(value()) must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(value()) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -61,7 +61,7 @@ { std::expected f1(1); f1.and_then(lval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::and_then (&)(int &)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(value()) must have the same error_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(value()) must have the same error_type as this expected}} } } @@ -71,7 +71,7 @@ { const std::expected f1(1); f1.and_then(clval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::and_then' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(value()) must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(value()) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -80,7 +80,7 @@ { const std::expected f1(1); f1.and_then(clval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::and_then (&)(const int &)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(value()) must have the same error_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(value()) must have the same error_type as this expected}} } } @@ -91,7 +91,7 @@ { std::expected f1(1); std::move(f1).and_then(rval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::and_then' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -100,7 +100,7 @@ { std::expected f1(1); std::move(f1).and_then(rval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::and_then (&)(int &&)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}} } } @@ -110,7 +110,7 @@ { const std::expected f1(1); std::move(f1).and_then(crval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::and_then' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -119,7 +119,7 @@ { const std::expected f1(1); std::move(f1).and_then(crval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::and_then (&)(const int &&)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}} } } } diff --git a/libcxx/test/libcxx/utilities/expected/expected.expected/error_or.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.expected/error_or.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.expected/error_or.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.expected/error_or.mandates.verify.cpp @@ -37,7 +37,7 @@ { const std::expected f1(std::unexpect, 0); f1.error_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::error_or' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}error_type has to be copy constructible}} + // expected-error-re@*:* {{static assertion failed {{.*}}error_type has to be copy constructible}} // expected-error-re@*:* {{call to deleted constructor of{{.*}}}} } @@ -46,7 +46,7 @@ { const std::expected f1(std::unexpect, NotConvertibleFromInt{}); f1.error_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::error_or' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}argument has to be convertible to error_type}} + // expected-error-re@*:* {{static assertion failed {{.*}}argument has to be convertible to error_type}} // expected-error-re@*:* {{no viable conversion from returned value of type{{.*}}}} } @@ -56,7 +56,7 @@ { std::expected f1(std::unexpect, 0); std::move(f1).error_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::error_or' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}error_type has to be move constructible}} + // expected-error-re@*:* {{static assertion failed {{.*}}error_type has to be move constructible}} // expected-error-re@*:* {{call to deleted constructor of{{.*}}}} } @@ -65,7 +65,7 @@ { std::expected f1(std::unexpect, NotConvertibleFromInt{}); std::move(f1).error_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::error_or' requested here}} - //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}argument has to be convertible to error_type}} + //expected-error-re@*:* {{static assertion failed {{.*}}argument has to be convertible to error_type}} // expected-error-re@*:* {{no viable conversion from returned value of type{{.*}}}} } } diff --git a/libcxx/test/libcxx/utilities/expected/expected.expected/or_else.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.expected/or_else.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.expected/or_else.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.expected/or_else.mandates.verify.cpp @@ -52,7 +52,7 @@ { std::expected f1(std::unexpected(1)); f1.or_else(lval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::or_else' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(error()) must be a specialization of std::expected}} + // expected-error-re@*:* {{{static assertion failed {{.*}}The result of f(error()) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -61,7 +61,7 @@ { std::expected f1(std::unexpected(1)); f1.or_else(lval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::or_else (&)(int &)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(error()) must have the same value_type as this expected}} + // expected-error-re@*:* {{{static assertion failed {{.*}}The result of f(error()) must have the same value_type as this expected}} } } @@ -71,7 +71,7 @@ { const std::expected f1(std::unexpected(1)); f1.or_else(clval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::or_else' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(error()) must be a specialization of std::expected}} + // expected-error-re@*:* {{{static assertion failed {{.*}}The result of f(error()) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -80,7 +80,7 @@ { const std::expected f1(std::unexpected(1)); f1.or_else(clval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::or_else (&)(const int &)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(error()) must have the same value_type as this expected}} + // expected-error-re@*:* {{{static assertion failed {{.*}}The result of f(error()) must have the same value_type as this expected}} } } @@ -90,7 +90,7 @@ { std::expected f1(std::unexpected(1)); std::move(f1).or_else(rval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::or_else' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(error())) must be a specialization of std::expected}} + // expected-error-re@*:* {{{static assertion failed {{.*}}The result of f(std::move(error())) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -99,7 +99,7 @@ { std::expected f1(std::unexpected(1)); std::move(f1).or_else(rval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::or_else (&)(int &&)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(error())) must have the same value_type as this expected}} + // expected-error-re@*:* {{{static assertion failed {{.*}}The result of f(std::move(error())) must have the same value_type as this expected}} } } @@ -109,7 +109,7 @@ { const std::expected f1(std::unexpected(1)); std::move(f1).or_else(crval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::or_else' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(error())) must be a specialization of std::expected}} + // expected-error-re@*:* {{{static assertion failed {{.*}}The result of f(std::move(error())) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -118,7 +118,7 @@ { const std::expected f1(std::unexpected(1)); std::move(f1).or_else(crval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::or_else (&)(const int &&)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(error())) must have the same value_type as this expected}} + // expected-error-re@*:* {{{static assertion failed {{.*}}The result of f(std::move(error())) must have the same value_type as this expected}} } } } diff --git a/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.expected/transform_error.mandates.verify.cpp @@ -45,39 +45,39 @@ // Test & overload { std::expected e; - e.transform_error(return_unexpected); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + e.transform_error(return_unexpected); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}[expected.object.general] A program that instantiates the definition of template expected for {{.*}} is ill-formed.}} + // expected-error-re@*:* {{static assertion failed {{.*}}[expected.object.general] A program that instantiates the definition of template expected for {{.*}} is ill-formed.}} - e.transform_error(return_no_object); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + e.transform_error(return_no_object); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}[expected.object.general] A program that instantiates the definition of template expected for {{.*}} is ill-formed.}} + // expected-error-re@*:* {{static assertion failed {{.*}}[expected.object.general] A program that instantiates the definition of template expected for {{.*}} is ill-formed.}} } // Test const& overload { const std::expected e; - e.transform_error(return_unexpected); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + e.transform_error(return_unexpected); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* 2 {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - e.transform_error(return_no_object); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + e.transform_error(return_no_object); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* 2 {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} } // Test && overload { std::expected e; - std::move(e).transform_error(return_unexpected); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + std::move(e).transform_error(return_unexpected); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* 2 {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - std::move(e).transform_error(return_no_object); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + std::move(e).transform_error(return_no_object); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* 2 {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} } // Test const&& overload { const std::expected e; - std::move(e).transform_error(return_unexpected); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + std::move(e).transform_error(return_unexpected); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* 2 {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - std::move(e).transform_error(return_no_object); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + std::move(e).transform_error(return_no_object); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* 2 {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} } } diff --git a/libcxx/test/libcxx/utilities/expected/expected.expected/value_or.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.expected/value_or.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.expected/value_or.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.expected/value_or.mandates.verify.cpp @@ -37,7 +37,7 @@ { const std::expected f1{5}; f1.value_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::value_or' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}value_type has to be copy constructible}} + // expected-error-re@*:* {{static assertion failed {{.*}}value_type has to be copy constructible}} } // const & overload @@ -45,7 +45,7 @@ { const std::expected f1{std::in_place}; f1.value_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::value_or' requested here}} - //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}argument has to be convertible to value_type}} + //expected-error-re@*:* {{static assertion failed {{.*}}argument has to be convertible to value_type}} } // && overload @@ -53,7 +53,7 @@ { std::expected f1{5}; std::move(f1).value_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::value_or' requested here}} - //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}value_type has to be move constructible}} + //expected-error-re@*:* {{static assertion failed {{.*}}value_type has to be move constructible}} } // && overload @@ -61,6 +61,6 @@ { std::expected f1{std::in_place}; std::move(f1).value_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::value_or' requested here}} - //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}argument has to be convertible to value_type}} + //expected-error-re@*:* {{static assertion failed {{.*}}argument has to be convertible to value_type}} } } diff --git a/libcxx/test/libcxx/utilities/expected/expected.unexpected/class.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.unexpected/class.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.unexpected/class.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.unexpected/class.mandates.verify.cpp @@ -14,12 +14,12 @@ -template class std::unexpected; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}[expected.un.general]}} +template class std::unexpected; // expected-error-re@*:* {{static assertion failed {{.*}}[expected.un.general]}} -template class std::unexpected; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}[expected.un.general]}} +template class std::unexpected; // expected-error-re@*:* {{static assertion failed {{.*}}[expected.un.general]}} -template class std::unexpected; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}[expected.un.general]}} +template class std::unexpected; // expected-error-re@*:* {{static assertion failed {{.*}}[expected.un.general]}} -template class std::unexpected>; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}[expected.un.general]}} +template class std::unexpected>; // expected-error-re@*:* {{static assertion failed {{.*}}[expected.un.general]}} -template class std::unexpected; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}[expected.un.general]}} +template class std::unexpected; // expected-error-re@*:* {{static assertion failed {{.*}}[expected.un.general]}} diff --git a/libcxx/test/libcxx/utilities/expected/expected.unexpected/swap.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.unexpected/swap.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.unexpected/swap.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.unexpected/swap.mandates.verify.cpp @@ -22,5 +22,5 @@ void test() { std::unexpected f1{Foo{}}; f1.swap(f1); // expected-note{{in instantiation of member function 'std::unexpected::swap' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}unexpected::swap requires is_swappable_v to be true}} + // expected-error-re@*:* {{static assertion failed {{.*}}unexpected::swap requires is_swappable_v to be true}} } diff --git a/libcxx/test/libcxx/utilities/expected/expected.void/and_then.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.void/and_then.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.void/and_then.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.void/and_then.mandates.verify.cpp @@ -52,7 +52,7 @@ { std::expected f1; f1.and_then(lval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::and_then' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f() must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f() must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -61,7 +61,7 @@ { std::expected f1; f1.and_then(lval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::and_then (&)()>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f() must have the same error_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f() must have the same error_type as this expected}} } } @@ -71,7 +71,7 @@ { const std::expected f1; f1.and_then(clval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::and_then' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f() must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f() must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -80,7 +80,7 @@ { const std::expected f1; f1.and_then(clval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::and_then (&)()>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f() must have the same error_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f() must have the same error_type as this expected}} } } @@ -90,7 +90,7 @@ { std::expected f1; std::move(f1).and_then(rval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::and_then' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f() must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f() must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -99,7 +99,7 @@ { std::expected f1; std::move(f1).and_then(rval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::and_then (&)()>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f() must have the same error_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f() must have the same error_type as this expected}} } } @@ -109,7 +109,7 @@ { const std::expected f1; std::move(f1).and_then(crval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::and_then' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f() must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f() must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}} } @@ -118,7 +118,7 @@ { const std::expected f1; std::move(f1).and_then(crval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::and_then (&)()>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f() must have the same error_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f() must have the same error_type as this expected}} } } } diff --git a/libcxx/test/libcxx/utilities/expected/expected.void/error_or.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.void/error_or.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.void/error_or.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.void/error_or.mandates.verify.cpp @@ -37,7 +37,7 @@ { const std::expected f1(std::unexpect, 0); f1.error_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::error_or' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}error_type has to be copy constructible}} + // expected-error-re@*:* {{static assertion failed {{.*}}error_type has to be copy constructible}} // expected-error-re@*:* {{call to deleted constructor of{{.*}}}} } @@ -46,7 +46,7 @@ { const std::expected f1(std::unexpect, NotConvertibleFromInt{}); f1.error_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::error_or' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}argument has to be convertible to error_type}} + // expected-error-re@*:* {{static assertion failed {{.*}}argument has to be convertible to error_type}} // expected-error-re@*:* {{no viable conversion from returned value of type{{.*}}}} } @@ -55,7 +55,7 @@ { std::expected f1(std::unexpect, 0); std::move(f1).error_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::error_or' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}error_type has to be move constructible}} + // expected-error-re@*:* {{static assertion failed {{.*}}error_type has to be move constructible}} // expected-error-re@*:* {{call to deleted constructor of{{.*}}}} } @@ -64,7 +64,7 @@ { std::expected f1(std::unexpect, NotConvertibleFromInt{}); std::move(f1).error_or(5); // expected-note{{in instantiation of function template specialization 'std::expected::error_or' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}argument has to be convertible to error_type}} + // expected-error-re@*:* {{static assertion failed {{.*}}argument has to be convertible to error_type}} // expected-error-re@*:* {{no viable conversion from returned value of type{{.*}}}} } } diff --git a/libcxx/test/libcxx/utilities/expected/expected.void/or_else.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.void/or_else.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.void/or_else.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.void/or_else.mandates.verify.cpp @@ -52,7 +52,7 @@ { std::expected f1(std::unexpected(1)); f1.or_else(lval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::or_else' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(error()) must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(error()) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} } @@ -60,7 +60,7 @@ { std::expected f1(std::unexpected(1)); f1.or_else(lval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::or_else (&)(int &)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(error()) must have the same value_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(error()) must have the same value_type as this expected}} } } @@ -70,7 +70,7 @@ { const std::expected f1(std::unexpected(1)); f1.or_else(clval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::or_else' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(error()) must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(error()) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} } @@ -78,7 +78,7 @@ { const std::expected f1(std::unexpected(1)); f1.or_else(clval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::or_else (&)(const int &)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(error()) must have the same value_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(error()) must have the same value_type as this expected}} } } @@ -88,7 +88,7 @@ { std::expected f1(std::unexpected(1)); std::move(f1).or_else(rval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::or_else' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(error())) must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(error())) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} } @@ -96,7 +96,7 @@ { std::expected f1(std::unexpected(1)); std::move(f1).or_else(rval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::or_else (&)(int &&)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(error())) must have the same value_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(error())) must have the same value_type as this expected}} } } @@ -106,7 +106,7 @@ { const std::expected f1(std::unexpected(1)); std::move(f1).or_else(crval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected::or_else' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(error())) must be a specialization of std::expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(error())) must be a specialization of std::expected}} // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}} } @@ -114,7 +114,7 @@ { const std::expected f1(std::unexpected(1)); std::move(f1).or_else(crval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected::or_else (&)(const int &&)>' requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of f(std::move(error())) must have the same value_type as this expected}} + // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(error())) must have the same value_type as this expected}} } } } diff --git a/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp --- a/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp +++ b/libcxx/test/libcxx/utilities/expected/expected.void/transform_error.mandates.verify.cpp @@ -45,39 +45,39 @@ // Test & overload { std::expected e; - e.transform_error(return_unexpected); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + e.transform_error(return_unexpected); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}A program that instantiates expected with a E that is not a valid argument for unexpected is ill-formed}} + // expected-error-re@*:* {{static assertion failed {{.*}}A program that instantiates expected with a E that is not a valid argument for unexpected is ill-formed}} - e.transform_error(return_no_object); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + e.transform_error(return_no_object); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}A program that instantiates expected with a E that is not a valid argument for unexpected is ill-formed}} + // expected-error-re@*:* {{static assertion failed {{.*}}A program that instantiates expected with a E that is not a valid argument for unexpected is ill-formed}} } // Test const& overload { const std::expected e; - e.transform_error(return_unexpected); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + e.transform_error(return_unexpected); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - e.transform_error(return_no_object); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + e.transform_error(return_no_object); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} } // Test && overload { std::expected e; - std::move(e).transform_error(return_unexpected); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + std::move(e).transform_error(return_unexpected); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - std::move(e).transform_error(return_no_object); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + std::move(e).transform_error(return_no_object); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} } // Test const&& overload { const std::expected e; - std::move(e).transform_error(return_unexpected); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + std::move(e).transform_error(return_unexpected); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} - std::move(e).transform_error(return_no_object); // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} + std::move(e).transform_error(return_no_object); // expected-error-re@*:* {{static assertion failed {{.*}}The result of {{.*}} must be a valid template argument for unexpected}} // expected-error-re@*:* {{{{(excess elements in struct initializer|no matching constructor for initialization of)}}{{.*}}}} } } diff --git a/libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp b/libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp --- a/libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp +++ b/libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp @@ -46,7 +46,7 @@ SPtr<3> s3(nullptr, Deleter{}); // OK } - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}default_delete cannot be instantiated for function types}} + // expected-error-re@*:* {{static assertion failed{{.*}}default_delete cannot be instantiated for function types}} std::default_delete> deleter{}; // expected-note {{requested here}} return 0; diff --git a/libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp b/libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp --- a/libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp +++ b/libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp @@ -19,7 +19,7 @@ { typedef std::pair P; std::tuple_element<2, P>::type foo; // expected-note {{requested here}} - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '2U[L]{0,2} < 2')?}}{{.*}}Index out of bounds in std::tuple_element>}} + // expected-error-re@*:* {{static assertion failed{{( due to requirement '2U[L]{0,2} < 2')?}}{{.*}}Index out of bounds in std::tuple_element>}} } return 0; diff --git a/libcxx/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp b/libcxx/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp --- a/libcxx/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp +++ b/libcxx/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp @@ -30,7 +30,7 @@ { typedef std::variant T; std::variant_alternative<2, T>::type foo; // expected-note {{requested here}} - // expected-error-re@variant:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '2U[L]{0,2} < sizeof...\(_Types\)')?}}{{.*}}Index out of bounds in std::variant_alternative<>}} + // expected-error-re@variant:* {{static assertion failed{{( due to requirement '2U[L]{0,2} < sizeof...\(_Types\)')?}}{{.*}}Index out of bounds in std::variant_alternative<>}} } return 0; diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp --- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp +++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp @@ -33,7 +33,7 @@ } int main(int, char**) { - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '.*')?}}{{.*}}SampleIterator must meet the requirements of RandomAccessIterator}} + // expected-error-re@*:* {{static assertion failed{{( due to requirement '.*')?}}{{.*}}SampleIterator must meet the requirements of RandomAccessIterator}} // expected-error@*:* 2 {{does not provide a subscript operator}} // expected-error@*:* {{invalid operands}} test, cpp17_output_iterator >(); diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.three.way/lexicographical_compare_three_way_comp.verify.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.three.way/lexicographical_compare_three_way_comp.verify.cpp --- a/libcxx/test/std/algorithms/alg.sorting/alg.three.way/lexicographical_compare_three_way_comp.verify.cpp +++ b/libcxx/test/std/algorithms/alg.sorting/alg.three.way/lexicographical_compare_three_way_comp.verify.cpp @@ -29,19 +29,19 @@ auto test_incorrect_comparator() { std::array a{90, 81}; std::array b{10, 11}; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}The comparator passed to lexicographical_compare_three_way must return a comparison category type}} + // expected-error-re@*:* {{static assertion failed{{.*}}The comparator passed to lexicographical_compare_three_way must return a comparison category type}} // expected-error@*:* {{no viable conversion}} return std::lexicographical_compare_three_way(a.begin(), a.end(), b.begin(), b.end(), incorrect_comparator); } auto test_invalid_difference_type_first( RandomAccessIteratorBadDifferenceType a, RandomAccessIteratorBadDifferenceType b, int* c, int* d) { - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Using a non-integral difference_type is undefined behavior}}}} + // expected-error-re@*:* {{static assertion failed{{.*}}Using a non-integral difference_type is undefined behavior}}}} return std::lexicographical_compare_three_way(a, b, c, d, std::compare_three_way()); } auto test_invalid_difference_type_second( int* a, int* b, RandomAccessIteratorBadDifferenceType c, RandomAccessIteratorBadDifferenceType d) { - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Using a non-integral difference_type is undefined behavior}}}} + // expected-error-re@*:* {{static assertion failed{{.*}}Using a non-integral difference_type is undefined behavior}}}} return std::lexicographical_compare_three_way(a, b, c, d, std::compare_three_way()); } diff --git a/libcxx/test/std/containers/associative/map/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/associative/map/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/associative/map/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/associative/map/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::map, std::allocator > m; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/associative/map/map.cons/deduct.fail.cpp b/libcxx/test/std/containers/associative/map/map.cons/deduct.fail.cpp --- a/libcxx/test/std/containers/associative/map/map.cons/deduct.fail.cpp +++ b/libcxx/test/std/containers/associative/map/map.cons/deduct.fail.cpp @@ -63,7 +63,7 @@ // refuse to rebind the allocator if Allocator::value_type is not exactly what we expect const P arr[] = { {1,1L}, {2,2L}, {3,3L} }; std::map m(arr, arr + 3, std::allocator

()); - // expected-error-re@map:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '.*')?}}{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@map:* {{static assertion failed{{( due to requirement '.*')?}}{{.*}}Allocator::value_type must be same type as value_type}} } { // cannot convert from some arbitrary unrelated type diff --git a/libcxx/test/std/containers/associative/multimap/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/associative/multimap/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/associative/multimap/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/associative/multimap/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::multimap, std::allocator > m; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.fail.cpp b/libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.fail.cpp --- a/libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.fail.cpp +++ b/libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.fail.cpp @@ -63,7 +63,7 @@ // refuse to rebind the allocator if Allocator::value_type is not exactly what we expect const P arr[] = { {1,1L}, {2,2L}, {3,3L} }; std::multimap m(arr, arr + 3, std::allocator

()); - // expected-error-re@map:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '.*')?}}{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@map:* {{static assertion failed{{( due to requirement '.*')?}}{{.*}}Allocator::value_type must be same type as value_type}} } { // cannot convert from some arbitrary unrelated type diff --git a/libcxx/test/std/containers/associative/multiset/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/associative/multiset/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/associative/multiset/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/associative/multiset/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::multiset, std::allocator > m; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/associative/set/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/associative/set/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/associative/set/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/associative/set/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::set, std::allocator > m; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/sequences/array/array.fill/fill.fail.cpp b/libcxx/test/std/containers/sequences/array/array.fill/fill.fail.cpp --- a/libcxx/test/std/containers/sequences/array/array.fill/fill.fail.cpp +++ b/libcxx/test/std/containers/sequences/array/array.fill/fill.fail.cpp @@ -18,7 +18,7 @@ typedef double T; typedef std::array C; C c = {}; - // expected-error-re@array:* {{{{(static_assert|static assertion)}} failed{{.*}}cannot fill zero-sized array of type 'const T'}} + // expected-error-re@array:* {{static assertion failed{{.*}}cannot fill zero-sized array of type 'const T'}} c.fill(5.5); // expected-note {{requested here}} } diff --git a/libcxx/test/std/containers/sequences/array/array.swap/swap.fail.cpp b/libcxx/test/std/containers/sequences/array/array.swap/swap.fail.cpp --- a/libcxx/test/std/containers/sequences/array/array.swap/swap.fail.cpp +++ b/libcxx/test/std/containers/sequences/array/array.swap/swap.fail.cpp @@ -19,7 +19,7 @@ typedef std::array C; C c = {}; C c2 = {}; - // expected-error-re@array:* {{{{(static_assert|static assertion)}} failed{{.*}}cannot swap zero-sized array of type 'const T'}} + // expected-error-re@array:* {{static assertion failed{{.*}}cannot swap zero-sized array of type 'const T'}} c.swap(c2); // expected-note {{requested here}} } diff --git a/libcxx/test/std/containers/sequences/array/array.tuple/get.fail.cpp b/libcxx/test/std/containers/sequences/array/array.tuple/get.fail.cpp --- a/libcxx/test/std/containers/sequences/array/array.tuple/get.fail.cpp +++ b/libcxx/test/std/containers/sequences/array/array.tuple/get.fail.cpp @@ -25,7 +25,7 @@ typedef std::array C; C c = {1, 2, 3.5}; std::get<3>(c) = 5.5; // expected-note {{requested here}} - // expected-error-re@array:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::get<> (std::array)}} + // expected-error-re@array:* {{static assertion failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::get<> (std::array)}} } return 0; diff --git a/libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp b/libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp --- a/libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp +++ b/libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp @@ -19,7 +19,7 @@ typedef double T; typedef std::array C; std::tuple_element<3, C> foo; // expected-note {{requested here}} - // expected-error-re@array:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::tuple_element<> (std::array)}} + // expected-error-re@array:* {{static assertion failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::tuple_element<> (std::array)}} } return 0; diff --git a/libcxx/test/std/containers/sequences/deque/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/sequences/deque/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/sequences/deque/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/sequences/deque/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::deque > d; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/sequences/forwardlist/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/sequences/forwardlist/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/sequences/forwardlist/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/sequences/forwardlist/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::forward_list > fl; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/sequences/list/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/sequences/list/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/sequences/list/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/sequences/list/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::list > l; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/sequences/vector/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/sequences/vector/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/sequences/vector/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/sequences/vector/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::vector > v; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/unord/unord.map/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/unord/unord.map/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/unord/unord.map/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/unord/unord.map/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::unordered_map, std::less, std::allocator > m; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/unord/unord.multimap/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/unord/unord.multimap/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/unord/unord.multimap/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/unord/unord.multimap/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::unordered_multimap, std::less, std::allocator > m; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/unord/unord.multiset/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/unord/unord.multiset/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/unord/unord.multiset/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/unord/unord.multiset/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::unordered_multiset, std::less, std::allocator > v; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/containers/unord/unord.set/allocator_mismatch.verify.cpp b/libcxx/test/std/containers/unord/unord.set/allocator_mismatch.verify.cpp --- a/libcxx/test/std/containers/unord/unord.set/allocator_mismatch.verify.cpp +++ b/libcxx/test/std/containers/unord/unord.set/allocator_mismatch.verify.cpp @@ -12,4 +12,4 @@ #include std::unordered_set, std::less, std::allocator > v; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}} + // expected-error-re@*:* {{static assertion failed{{.*}}Allocator::value_type must be same type as value_type}} diff --git a/libcxx/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp b/libcxx/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp --- a/libcxx/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp +++ b/libcxx/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp @@ -26,10 +26,10 @@ (void) std::launder(( void *) nullptr); (void) std::launder((const void *) nullptr); (void) std::launder(( volatile void *) nullptr); - (void) std::launder((const volatile void *) nullptr); // expected-error-re@new:* 4 {{{{(static_assert|static assertion)}} failed{{.*}}can't launder cv-void}} + (void) std::launder((const volatile void *) nullptr); // expected-error-re@new:* 4 {{static assertion failed{{.*}}can't launder cv-void}} // expected-error@new:* 0-4 {{void pointer argument to '__builtin_launder' is not allowed}} - (void) std::launder(foo); // expected-error-re@new:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}can't launder functions}} + (void) std::launder(foo); // expected-error-re@new:* 1 {{static assertion failed{{.*}}can't launder functions}} // expected-error@new:* 0-1 {{function pointer argument to '__builtin_launder' is not allowed}} return 0; diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp --- a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp +++ b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp @@ -33,19 +33,19 @@ int main(int, char**) { // Make sure we generate a compile-time error for UB - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - static_assert(toobig(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(toobig(), ""); // expected-error {{static assertion expression is not an integral constant expression}} return 0; } diff --git a/libcxx/test/std/numerics/numbers/illformed.verify.cpp b/libcxx/test/std/numerics/numbers/illformed.verify.cpp --- a/libcxx/test/std/numerics/numbers/illformed.verify.cpp +++ b/libcxx/test/std/numerics/numbers/illformed.verify.cpp @@ -11,7 +11,7 @@ #include // Initializing the primary template is ill-formed. -int log2e{std::numbers::log2e_v}; // expected-error-re@numbers:* {{{{(static_assert|static assertion)}} failed{{.*}}A program that instantiates a primary template of a mathematical constant variable template is ill-formed.}} +int log2e{std::numbers::log2e_v}; // expected-error-re@numbers:* {{static assertion failed{{.*}}A program that instantiates a primary template of a mathematical constant variable template is ill-formed.}} int log10e{std::numbers::log10e_v}; int pi{std::numbers::pi_v}; int inv_pi{std::numbers::inv_pi_v}; diff --git a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp --- a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp +++ b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp @@ -19,12 +19,12 @@ { typedef unsigned long long T; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}} + // expected-error-re@*:* {{static assertion failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}} std::linear_congruential_engine e2; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}} + // expected-error-re@*:* {{static assertion failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}} std::linear_congruential_engine e3; std::linear_congruential_engine e4; - // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed due to requirement 'is_unsigned::value'{{.*}}_UIntType must be unsigned type}} + // expected-error-re@*:* {{static assertion failed due to requirement 'is_unsigned::value'{{.*}}_UIntType must be unsigned type}} std::linear_congruential_engine e5; return 0; diff --git a/libcxx/test/std/strings/basic.string/char.bad.verify.cpp b/libcxx/test/std/strings/basic.string/char.bad.verify.cpp --- a/libcxx/test/std/strings/basic.string/char.bad.verify.cpp +++ b/libcxx/test/std/strings/basic.string/char.bad.verify.cpp @@ -32,20 +32,20 @@ typedef char C[3]; static_assert(std::is_array::value, ""); std::basic_string > s; - // expected-error-re@string:* {{{{(static_assert|static assertion)}} failed{{.*}}Character type of basic_string must not be an array}} + // expected-error-re@string:* {{static assertion failed{{.*}}Character type of basic_string must not be an array}} } { // not trivial static_assert(!std::is_trivial::value, ""); std::basic_string > s; - // expected-error-re@string:* {{{{(static_assert|static assertion)}} failed{{.*}}Character type of basic_string must be trivial}} + // expected-error-re@string:* {{static assertion failed{{.*}}Character type of basic_string must be trivial}} } { // not standard layout static_assert(!std::is_standard_layout::value, ""); std::basic_string > s; - // expected-error-re@string:* {{{{(static_assert|static assertion)}} failed{{.*}}Character type of basic_string must be standard-layout}} + // expected-error-re@string:* {{static assertion failed{{.*}}Character type of basic_string must be standard-layout}} } } diff --git a/libcxx/test/std/strings/string.view/char.bad.fail.cpp b/libcxx/test/std/strings/string.view/char.bad.fail.cpp --- a/libcxx/test/std/strings/string.view/char.bad.fail.cpp +++ b/libcxx/test/std/strings/string.view/char.bad.fail.cpp @@ -35,21 +35,21 @@ typedef char C[3]; static_assert(std::is_array::value, ""); std::basic_string_view > sv; -// expected-error-re@string_view:* {{{{(static_assert|static assertion)}} failed{{.*}}Character type of basic_string_view must not be an array}} +// expected-error-re@string_view:* {{static assertion failed{{.*}}Character type of basic_string_view must not be an array}} } { // not trivial static_assert(!std::is_trivial::value, ""); std::basic_string_view > sv; -// expected-error-re@string_view:* {{{{(static_assert|static assertion)}} failed{{.*}}Character type of basic_string_view must be trivial}} +// expected-error-re@string_view:* {{static assertion failed{{.*}}Character type of basic_string_view must be trivial}} } { // not standard layout static_assert(!std::is_standard_layout::value, ""); std::basic_string_view > sv; -// expected-error-re@string_view:* {{{{(static_assert|static assertion)}} failed{{.*}}Character type of basic_string_view must be standard-layout}} +// expected-error-re@string_view:* {{static assertion failed{{.*}}Character type of basic_string_view must be standard-layout}} } return 0; diff --git a/libcxx/test/std/strings/string.view/string.view.comparison/comparison.verify.cpp b/libcxx/test/std/strings/string.view/string.view.comparison/comparison.verify.cpp --- a/libcxx/test/std/strings/string.view/string.view.comparison/comparison.verify.cpp +++ b/libcxx/test/std/strings/string.view/string.view.comparison/comparison.verify.cpp @@ -62,13 +62,13 @@ // These diagnostics are issued for // - Every invalid ordering // - Every type - // expected-error-re@string_view:* 15 {{{{(static_assert|static assertion)}} failed{{.*}}return type is not a comparison category type}} + // expected-error-re@string_view:* 15 {{static assertion failed{{.*}}return type is not a comparison category type}} // This diagnostic is not issued for Ordering == void. // expected-error@string_view:* 10 {{no matching conversion for static_cast from}} #else // One less test run when wchar_t is unavailable. - // expected-error-re@string_view:* 12 {{{{(static_assert|static assertion)}} failed{{.*}}return type is not a comparison category type}} + // expected-error-re@string_view:* 12 {{static assertion failed{{.*}}return type is not a comparison category type}} // expected-error@string_view:* 8 {{no matching conversion for static_cast from}} #endif type{} <=> type{}; diff --git a/libcxx/test/std/time/time.hms/hhmmss.fail.cpp b/libcxx/test/std/time/time.hms/hhmmss.fail.cpp --- a/libcxx/test/std/time/time.hms/hhmmss.fail.cpp +++ b/libcxx/test/std/time/time.hms/hhmmss.fail.cpp @@ -21,10 +21,10 @@ int main(int, char**) { - std::chrono::hh_mm_ss h0; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}} - std::chrono::hh_mm_ss h1; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}} - std::chrono::hh_mm_ss h2; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}} - std::chrono::hh_mm_ss h3; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}} + std::chrono::hh_mm_ss h0; // expected-error-re@*:* {{static assertion failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}} + std::chrono::hh_mm_ss h1; // expected-error-re@*:* {{static assertion failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}} + std::chrono::hh_mm_ss h2; // expected-error-re@*:* {{static assertion failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}} + std::chrono::hh_mm_ss h3; // expected-error-re@*:* {{static assertion failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}} return 0; } diff --git a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp --- a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp +++ b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp @@ -24,12 +24,12 @@ void test_const_lvalue_cast_request_non_const_lvalue() { const std::any a; - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} // expected-error@any:* {{drops 'const' qualifier}} std::any_cast(a); // expected-note {{requested here}} const std::any a2(42); - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} // expected-error@any:* {{drops 'const' qualifier}} std::any_cast(a2); // expected-note {{requested here}} } @@ -37,22 +37,22 @@ void test_lvalue_any_cast_request_rvalue() { std::any a; - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}} std::any_cast(a); // expected-note {{requested here}} std::any a2(42); - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}} std::any_cast(a2); // expected-note {{requested here}} } void test_rvalue_any_cast_request_lvalue() { std::any a; - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}} // expected-error@any:* {{non-const lvalue reference to type 'TestType' cannot bind to a temporary}} std::any_cast(std::move(a)); // expected-note {{requested here}} - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}} // expected-error@any:* {{non-const lvalue reference to type 'int' cannot bind to a temporary}} std::any_cast(42); } diff --git a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp --- a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp +++ b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp @@ -32,15 +32,15 @@ void f() { std::any a; - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} std::any_cast(static_cast(a)); // expected-note {{requested here}} - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} std::any_cast(static_cast(a)); // expected-note {{requested here}} - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} std::any_cast(static_cast(a)); // expected-note {{requested here}} - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} std::any_cast(static_cast(a)); // expected-note {{requested here}} } diff --git a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp --- a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp +++ b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp @@ -46,14 +46,14 @@ void f() { std::any a; - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}} std::any_cast(static_cast(a)); // expected-note {{requested here}} - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}} std::any_cast(static_cast(a)); // expected-note {{requested here}} std::any_cast(static_cast(a)); // OK - // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}} + // expected-error-re@any:* {{static assertion failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}} std::any_cast(static_cast(a)); } diff --git a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp --- a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp +++ b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp @@ -22,30 +22,30 @@ { std::any a = 1; - // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}} + // expected-error-re@any:* 1 {{static assertion failed{{.*}}_ValueType may not be a reference.}} std::any_cast(&a); // expected-note {{requested here}} - // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}} + // expected-error-re@any:* 1 {{static assertion failed{{.*}}_ValueType may not be a reference.}} std::any_cast(&a); // expected-note {{requested here}} - // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}} + // expected-error-re@any:* 1 {{static assertion failed{{.*}}_ValueType may not be a reference.}} std::any_cast(&a); // expected-note {{requested here}} - // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}} + // expected-error-re@any:* 1 {{static assertion failed{{.*}}_ValueType may not be a reference.}} std::any_cast(&a); // expected-note {{requested here}} const std::any& a2 = a; - // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}} + // expected-error-re@any:* 1 {{static assertion failed{{.*}}_ValueType may not be a reference.}} std::any_cast(&a2); // expected-note {{requested here}} - // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}} + // expected-error-re@any:* 1 {{static assertion failed{{.*}}_ValueType may not be a reference.}} std::any_cast(&a2); // expected-note {{requested here}} - // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}} + // expected-error-re@any:* 1 {{static assertion failed{{.*}}_ValueType may not be a reference.}} std::any_cast(&a2); // expected-note {{requested here}} - // expected-error-re@any:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}_ValueType may not be a reference.}} + // expected-error-re@any:* 1 {{static assertion failed{{.*}}_ValueType may not be a reference.}} std::any_cast(&a2); // expected-note {{requested here}} return 0; diff --git a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.verify.cpp b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.verify.cpp --- a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.verify.cpp +++ b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.verify.cpp @@ -23,6 +23,6 @@ } void f() { - // expected-error-re@+1 {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} + // expected-error-re@+1 {{static assertion expression is not an integral constant expression}} static_assert(test()); } diff --git a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.verify.cpp b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.verify.cpp --- a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.verify.cpp +++ b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.verify.cpp @@ -24,6 +24,6 @@ } void f() { - // expected-error-re@+1 {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} + // expected-error-re@+1 {{static assertion expression is not an integral constant expression}} static_assert(test()); } diff --git a/libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.verify.cpp b/libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.verify.cpp --- a/libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.verify.cpp +++ b/libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.verify.cpp @@ -37,7 +37,7 @@ const int c = 1; auto p = std::bind_front(pass, c); - static_assert(p() == 1); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} + static_assert(p() == 1); // expected-error-re {{static assertion expression is not an integral constant expression}} auto d = std::bind_front(do_nothing, n); // expected-error {{no matching function for call to 'bind_front'}} diff --git a/libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp b/libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp --- a/libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp +++ b/libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp @@ -31,7 +31,7 @@ #if TEST_HAS_BUILTIN(__make_integer_seq) && !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE) MakeSeqT i; // expected-error@*:* {{integer sequences must have non-negative sequence length}} #else - MakeSeqT i; // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}std::make_integer_sequence must have a non-negative sequence length}} + MakeSeqT i; // expected-error-re@*:* {{static assertion failed{{.*}}std::make_integer_sequence must have a non-negative sequence length}} #endif return 0; diff --git a/libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.constexpr.size.verify.cpp b/libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.constexpr.size.verify.cpp --- a/libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.constexpr.size.verify.cpp +++ b/libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.constexpr.size.verify.cpp @@ -33,6 +33,6 @@ } void f() { - static_assert(test()); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} - LIBCPP_STATIC_ASSERT(test()); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}} + static_assert(test()); // expected-error-re {{static assertion expression is not an integral constant expression}} + LIBCPP_STATIC_ASSERT(test()); // expected-error-re {{static assertion expression is not an integral constant expression}} } diff --git a/libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.fail.cpp b/libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.fail.cpp --- a/libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.fail.cpp +++ b/libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.fail.cpp @@ -22,7 +22,7 @@ // expected-error@+1 {{no member named 'is_constant_evaluated' in namespace 'std'}} bool b = std::is_constant_evaluated(); #else - // expected-error-re@+1 {{{{(static_assert|static assertion)}} failed}} + // expected-error-re@+1 {{static assertion failed}} static_assert(!std::is_constant_evaluated(), ""); // expected-warning@-1 0-1 {{'std::is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression}} #endif diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.fail.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.fail.cpp --- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.fail.cpp +++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.fail.cpp @@ -24,23 +24,23 @@ int main(int, char**) { { - std::optional o1; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a reference type is ill-formed}} - std::optional o2; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}} - std::optional o3; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with an array type is ill-formed}} + std::optional o1; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}} + std::optional o2; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}} + std::optional o3; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with an array type is ill-formed}} } { - std::optional< std::in_place_t> o1; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}} - std::optional o2; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}} - std::optional< volatile std::in_place_t> o3; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}} - std::optional o4; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with in_place_t is ill-formed}} + std::optional< std::in_place_t> o1; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}} + std::optional o2; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}} + std::optional< volatile std::in_place_t> o3; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}} + std::optional o4; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}} } { - std::optional< std::nullopt_t> o1; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} - std::optional o2; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} - std::optional< volatile std::nullopt_t> o3; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} - std::optional o4; // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} + std::optional< std::nullopt_t> o1; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} + std::optional o2; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} + std::optional< volatile std::nullopt_t> o3; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} + std::optional o4; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} } return 0; diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp --- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp +++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp @@ -30,7 +30,7 @@ { // optional(nullopt_t) - std::optional opt(std::nullopt); // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} + std::optional opt(std::nullopt); // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}} } return 0; diff --git a/libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp b/libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp --- a/libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp +++ b/libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp @@ -25,22 +25,22 @@ { using std::optional; { - // expected-error-re@optional:* 2 {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a reference type is ill-formed}} + // expected-error-re@optional:* 2 {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}} optional opt1; optional opt2; } { - // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}} + // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}} optional opt3; } { - // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-object type is undefined behavior}} - // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}} + // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-object type is undefined behavior}} + // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}} optional opt4; } { - // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-object type is undefined behavior}} - // expected-error-re@optional:* {{{{(static_assert|static assertion)}} failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}} + // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-object type is undefined behavior}} + // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}} // expected-error@optional:* 1+ {{cannot form a reference to 'void'}} optional opt4; } diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp --- a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp +++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp @@ -27,7 +27,7 @@ using E1 = typename std::tuple_element<1, T &>::type; // expected-error{{undefined template}} using E2 = typename std::tuple_element<3, T>::type; using E3 = typename std::tuple_element<4, T const>::type; - // expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}} + // expected-error@*:* 2 {{static assertion failed}} return 0; } diff --git a/libcxx/test/std/utilities/utility/forward/forward.fail.cpp b/libcxx/test/std/utilities/utility/forward/forward.fail.cpp --- a/libcxx/test/std/utilities/utility/forward/forward.fail.cpp +++ b/libcxx/test/std/utilities/utility/forward/forward.fail.cpp @@ -23,7 +23,7 @@ { { (void)std::forward(source()); // expected-note {{requested here}} - // expected-error-re@*:* 1 {{{{(static_assert|static assertion)}} failed{{.*}}cannot forward an rvalue as an lvalue}} + // expected-error-re@*:* 1 {{static assertion failed{{.*}}cannot forward an rvalue as an lvalue}} } { const A ca = A(); diff --git a/libcxx/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp b/libcxx/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp --- a/libcxx/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp +++ b/libcxx/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp @@ -75,7 +75,7 @@ using V = std::variant; V v1(42); V v2(101); - // expected-error-re@variant:* 6 {{{{(static_assert|static assertion)}} failed{{.*}}the relational operator does not return a type which is implicitly convertible to bool}} + // expected-error-re@variant:* 6 {{static assertion failed{{.*}}the relational operator does not return a type which is implicitly convertible to bool}} // expected-error@variant:* 6 {{no viable conversion}} (void)(v1 == v2); // expected-note {{here}} (void)(v1 != v2); // expected-note {{here}} diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant_array.fail.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant_array.fail.cpp --- a/libcxx/test/std/utilities/variant/variant.variant/variant_array.fail.cpp +++ b/libcxx/test/std/utilities/variant/variant.variant/variant_array.fail.cpp @@ -24,7 +24,7 @@ int main(int, char**) { - // expected-error-re@variant:* 3 {{{{(static_assert|static assertion)}} failed}} + // expected-error-re@variant:* 3 {{static assertion failed}} std::variant v; // expected-note {{requested here}} std::variant v2; // expected-note {{requested here}} std::variant v3; // expected-note {{requested here}} diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp --- a/libcxx/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp +++ b/libcxx/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp @@ -19,7 +19,7 @@ int main(int, char**) { - // expected-error-re@variant:* 1 {{{{(static_assert|static assertion)}} failed}} + // expected-error-re@variant:* 1 {{static assertion failed}} std::variant<> v; // expected-note {{requested here}} return 0; diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp --- a/libcxx/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp +++ b/libcxx/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp @@ -19,7 +19,7 @@ int main(int, char**) { - // expected-error-re@variant:* 3 {{{{(static_assert|static assertion)}} failed}} + // expected-error-re@variant:* 3 {{static assertion failed}} std::variant v; // expected-note {{requested here}} std::variant v2; // expected-note {{requested here}} std::variant v3; // expected-note {{requested here}} diff --git a/libcxx/test/std/utilities/variant/variant.variant/variant_void.fail.cpp b/libcxx/test/std/utilities/variant/variant.variant/variant_void.fail.cpp --- a/libcxx/test/std/utilities/variant/variant.variant/variant_void.fail.cpp +++ b/libcxx/test/std/utilities/variant/variant.variant/variant_void.fail.cpp @@ -24,7 +24,7 @@ int main(int, char**) { - // expected-error-re@variant:* 3 {{{{(static_assert|static assertion)}} failed}} + // expected-error@variant:* 3 {{static assertion failed}} std::variant v; // expected-note {{requested here}} std::variant v2; // expected-note {{requested here}} std::variant v3; // expected-note {{requested here}}