Improve the formatting of static_assert messages

[cor3ntin]

Summary

Display 'static_assert failed: message' instead of
'static_assert failed "message"' to be consistent
with other implementations and be slightly more
readable.

[philnik]

LGTM from the libc++ side of things.

[aaron.ballman]

I agree with the changes in principle, but it looks like the libc++ precommit CI builder is failing with a bunch of failures... but those failures look like the precommit CI isn't testing the Clang built by the patch?

error: 'error' diagnostics expected but not seen:
  File * Line * (directive at /home/libcxx-builder/.buildkite-agent/builds/5d14e636cf69-1/llvm-project/libcxx-ci/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp:22): static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL': linear_congruential_engine invalid parameters
  File * Line * (directive at /home/libcxx-builder/.buildkite-agent/builds/5d14e636cf69-1/llvm-project/libcxx-ci/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp:24): static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL': linear_congruential_engine invalid parameters
  File * Line * (directive at /home/libcxx-builder/.buildkite-agent/builds/5d14e636cf69-1/llvm-project/libcxx-ci/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp:27): static_assert failed due to requirement 'is_unsigned<int>::value': _UIntType must be unsigned type
error: 'error' diagnostics seen but not expected:
  Line 218: static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"
  Line 217: static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"
  Line 219: static_assert failed due to requirement 'is_unsigned<int>::value' "_UIntType must be unsigned type"
6 errors generated.

So I *think* this LG, but am not certain what will happen when you land it. I think the precommit CI failures are not failures that will happen when testing against the just-built clang.

[philnik]

Sorry I missed that. You have to changes the libc++ tests to regex checks to allow both error-styles. This can then be removed once we drop support for LLVM 14 (so after the release of LLVM 16).

[cor3ntin]

Pushing for CI

[Mordante]

In D128844#3622220, @aaron.ballman wrote:

So I *think* this LG, but am not certain what will happen when you land it. I think the precommit CI failures are not failures that will happen when testing against the just-built clang.

Most Linux runner use the apt.llvm.org nightly builds and are updated on an irregular interval. The Bootstrapping build will use the just-built Clang. So when the CI is green all should be fine.

I wanted to suggest a regex, but I see the latest patch already does that.

Thanks for improving the readability of the diagnostics! LGTM when the CI passes.

[cor3ntin]

Missing -re in a few places

[cor3ntin]

@philnik There seems to be an unrelated clang-format issue but otherwise the build looks fine now.

[philnik]

LGTM. (The clang-format if more of a suggestion than anything else currently)

[cor3ntin]

Thanks for the review!

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_messaging_class_with_direct_method : Error<
   "messaging a Class with a method that is possibly direct">;
 
 // C++ declarations
 def err_static_assert_expression_is_not_constant : Error<
   "static_assert expression is not an integral constant expression">;
 def err_constexpr_if_condition_expression_is_not_constant : Error<
   "constexpr if condition is not a constant expression">;
-def err_static_assert_failed : Error<"static_assert failed%select{ %1|}0">;
+def err_static_assert_failed : Error<"static_assert failed%select{: %1|}0">;
 def err_static_assert_requirement_failed : Error<
-  "static_assert failed due to requirement '%0'%select{ %2|}1">;
+  "static_assert failed due to requirement '%0'%select{: %2|}1">;
 
 def warn_consteval_if_always_true : Warning<
   "consteval if is always true in an %select{unevaluated|immediate}0 context">,
   InGroup<DiagGroup<"redundant-consteval-if">>;
 
 def ext_inline_variable : ExtWarn<
   "inline variables are a C++17 extension">, InGroup<CXX17>;
 def warn_cxx14_compat_inline_variable : Warning<

clang/lib/Sema/SemaDeclCXX.cpp

if (!Failed && VerifyIntegerConstantExpression(
       Failed = true;
 
     if (!Failed && !Cond) {
       SmallString<256> MsgBuffer;
       llvm::raw_svector_ostream Msg(MsgBuffer);
       if (AssertMessage) {
         const auto *MsgStr = cast<StringLiteral>(AssertMessage);
         if (MsgStr->isOrdinary())
-          Msg << '"' << MsgStr->getString() << '"';
+          Msg << MsgStr->getString();
         else
           MsgStr->printPretty(Msg, nullptr, getPrintingPolicy());
       }
 
       Expr *InnerCond = nullptr;
       std::string InnerCondDescription;
       std::tie(InnerCond, InnerCondDescription) =
         findFailedBooleanCondition(Converted.get());

clang/test/C/drs/dr0xx.c

 _Static_assert(THIS$AND$THAT(1, 1) == 2, "fail"); /* expected-warning 2 {{'$' in identifier}} */
 
 
 /* WG14 DR029: no
  * Do two types have to have the same tag to be compatible?
  * Note: the rule changed in C99 to be different than the resolution to DR029,
  * so it's not clear there's value in implementing this DR.
  */
-_Static_assert(__builtin_types_compatible_p(struct S { int a; }, union U { int a; }), "fail"); /* expected-error {{static_assert failed due to requirement '__builtin_types_compatible_p(struct S, union U)' "fail"}} */
+_Static_assert(__builtin_types_compatible_p(struct S { int a; }, union U { int a; }), "fail"); /* expected-error {{static_assert failed due to requirement '__builtin_types_compatible_p(struct S, union U)': fail}} */
 
 /* WG14 DR031: yes
  * Can constant expressions overflow?
  */
 void dr031(int i) {
   switch (i) {
   case __INT_MAX__ + 1: break; /* expected-warning {{overflow in expression; result is -2147483648 with type 'int'}} */
   #pragma clang diagnostic push

clang/test/CXX/dcl.dcl/p4-0x.cpp

struct U {
   constexpr operator long() const { return 0; } // expected-note {{candidate}}
 };
 
 static_assert(S(true), "");
 static_assert(S(false), "not so fast"); // expected-error {{not so fast}}
 static_assert(T(), "");
 static_assert(U(), ""); // expected-error {{ambiguous}}
 
-static_assert(false, L"\x14hi" "!" R"x(")x"); // expected-error {{static_assert failed L"\024hi!\""}}
+static_assert(false, L"\x14hi" "!" R"x(")x"); // expected-error {{static_assert failed: L"\024hi!\""}}

clang/test/CXX/expr/expr.prim/expr.prim.id/p3.cpp

 concept Large = sizeof(T) > 100;
 // expected-note@-1 2{{because 'sizeof(small) > 100' (1 > 100) evaluated to false}}
 
 struct small { };
 static_assert(Large<small>);
 // expected-error@-1 {{static_assert failed}}
 // expected-note@-2 {{because 'small' does not satisfy 'Large'}}
 static_assert(Large<small>, "small isn't large");
-// expected-error@-1 {{static_assert failed "small isn't large"}}
+// expected-error@-1 {{static_assert failed: small isn't large}}
 // expected-note@-2 {{because 'small' does not satisfy 'Large'}}
 
 // Make sure access-checking can fail a concept specialization
 
 class T4 { static constexpr bool f = true; };
 template<typename T> concept AccessPrivate = T{}.f;
 // expected-note@-1{{because substituted constraint expression is ill-formed: 'f' is a private member of 'T4'}}
 static_assert(AccessPrivate<T4>);

clang/test/PCH/cxx-static_assert.cpp

 #define HEADER
 
 template<int N> struct T {
     static_assert(N == 2, "N is not 2!");
 };
 
 #else
 
-// expected-error@15 {{static_assert failed due to requirement '1 == 2' "N is not 2!"}}
+// expected-error@15 {{static_assert failed due to requirement '1 == 2': N is not 2!}}
 T<1> t1; // expected-note {{in instantiation of template class 'T<1>' requested here}}
 T<2> t2;
 
 #endif

clang/test/Sema/static-assert.c

 // RUN: %clang_cc1 -std=c11 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fms-compatibility -DMS -fsyntax-only -verify=expected,ms %s
 // RUN: %clang_cc1 -std=c99 -pedantic -fsyntax-only -verify=expected,ext %s
 // RUN: %clang_cc1 -xc++ -std=c++11 -pedantic -fsyntax-only -verify=expected,ext,cxx %s
 
 _Static_assert("foo", "string is nonzero"); // ext-warning {{'_Static_assert' is a C11 extension}}
 #ifndef __cplusplus
 // expected-error@-2 {{static_assert expression is not an integral constant expression}}
 #endif
 
 _Static_assert(1, "1 is nonzero"); // ext-warning {{'_Static_assert' is a C11 extension}}
-_Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed "0 is nonzero"}} \
+_Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed: 0 is nonzero}} \
                                    // ext-warning {{'_Static_assert' is a C11 extension}}
 
 #ifdef MS
 static_assert(1, "1 is nonzero"); // ms-warning {{use of 'static_assert' without inclusion of <assert.h> is a Microsoft extension}}
 #endif
 
 void foo(void) {
   _Static_assert(1, "1 is nonzero"); // ext-warning {{'_Static_assert' is a C11 extension}}
-  _Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed "0 is nonzero"}} \
+  _Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed: 0 is nonzero}} \
                                      // ext-warning {{'_Static_assert' is a C11 extension}}
 #ifdef MS
   static_assert(1, "1 is nonzero"); // ms-warning {{use of 'static_assert' without}}
 #endif
 }
 
 _Static_assert(1, invalid); // expected-error {{expected string literal for diagnostic message in static_assert}} \
                             // ext-warning {{'_Static_assert' is a C11 extension}}
 
 struct A {
   int a;
   _Static_assert(1, "1 is nonzero"); // ext-warning {{'_Static_assert' is a C11 extension}}
-  _Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed "0 is nonzero"}} \
+  _Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed: 0 is nonzero}} \
                                      // ext-warning {{'_Static_assert' is a C11 extension}}
 #ifdef MS
   static_assert(1, "1 is nonzero"); // ms-warning {{use of 'static_assert' without}}
 #endif
 };
 
 #ifdef __cplusplus
 #define ASSERT_IS_TYPE(T) __is_same(T, T)
 #else
 #define ASSERT_IS_TYPE(T) __builtin_types_compatible_p(T, T)
 #endif
 
 #define UNION(T1, T2) union { \
     __typeof__(T1) one; \
     __typeof__(T2) two; \
     _Static_assert(ASSERT_IS_TYPE(T1), "T1 is not a type"); \
     _Static_assert(ASSERT_IS_TYPE(T2), "T2 is not a type"); \
     _Static_assert(sizeof(T1) == sizeof(T2), "type size mismatch"); \
   }
 
 typedef UNION(unsigned, struct A) U1; // ext-warning 3 {{'_Static_assert' is a C11 extension}}
 UNION(char[2], short) u2 = { .one = { 'a', 'b' } }; // ext-warning 3 {{'_Static_assert' is a C11 extension}} cxx-warning {{designated initializers are a C++20 extension}}
-typedef UNION(char, short) U3; // expected-error {{static_assert failed due to requirement 'sizeof(char) == sizeof(short)' "type size mismatch"}} \
+typedef UNION(char, short) U3; // expected-error {{static_assert failed due to requirement 'sizeof(char) == sizeof(short)': type size mismatch}} \
                                // ext-warning 3 {{'_Static_assert' is a C11 extension}}
 typedef UNION(float, 0.5f) U4; // expected-error {{expected a type}} \
                                // ext-warning 3 {{'_Static_assert' is a C11 extension}}
 
 // After defining the assert macro in MS-compatibility mode, we should
 // no longer warn about including <assert.h> under the assumption the
 // user already did that.
 #ifdef MS
 #define assert(expr)
 static_assert(1, "1 is nonzero"); // ok
 
 // But we should still warn if the user did something bonkers.
 #undef static_assert
 static_assert(1, "1 is nonzero"); // ms-warning {{use of 'static_assert' without}}
 #endif

clang/test/SemaCXX/int-ptr-cast-SFINAE.cpp

 
 template<typename T>
 typename select<(sizeof(declval<T>() -= declval<T>(), 1) != 1), true_type, false_type>::type test(...);
 template<typename T> false_type test(...);
 
 template<typename T>
 static const auto has_minus_assign = decltype(test<T>())::value;
 
-static_assert(has_minus_assign<int*>, "failed"); // expected-error {{static_assert failed due to requirement 'has_minus_assign<int *>' "failed"}}
+static_assert(has_minus_assign<int*>, "failed"); // expected-error {{static_assert failed due to requirement 'has_minus_assign<int *>': failed}}

clang/test/SemaCXX/static-assert.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -pedantic -triple=x86_64-linux-gnu
 
 int f(); // expected-note {{declared here}}
 
 static_assert(f(), "f"); // expected-error {{static_assert expression is not an integral constant expression}} expected-note {{non-constexpr function 'f' cannot be used in a constant expression}}
 static_assert(true, "true is not false");
-static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}}
+static_assert(false, "false is false"); // expected-error {{static_assert failed: false is false}}
 
 void g() {
-    static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}}
+    static_assert(false, "false is false"); // expected-error {{static_assert failed: false is false}}
 }
 
 class C {
-    static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}}
+    static_assert(false, "false is false"); // expected-error {{static_assert failed: false is false}}
 };
 
 template<int N> struct T {
-    static_assert(N == 2, "N is not 2!"); // expected-error {{static_assert failed due to requirement '1 == 2' "N is not 2!"}}
+    static_assert(N == 2, "N is not 2!"); // expected-error {{static_assert failed due to requirement '1 == 2': N is not 2!}}
 };
 
 T<1> t1; // expected-note {{in instantiation of template class 'T<1>' requested here}}
 T<2> t2;
 
 template<typename T> struct S {
-    static_assert(sizeof(T) > sizeof(char), "Type not big enough!"); // expected-error {{static_assert failed due to requirement 'sizeof(char) > sizeof(char)' "Type not big enough!"}}
+    static_assert(sizeof(T) > sizeof(char), "Type not big enough!"); // expected-error {{static_assert failed due to requirement 'sizeof(char) > sizeof(char)': Type not big enough!}}
 };
 
 S<char> s1; // expected-note {{in instantiation of template class 'S<char>' requested here}}
 S<int> s2;
 
-static_assert(false, L"\xFFFFFFFF"); // expected-error {{static_assert failed L"\xFFFFFFFF"}}
-static_assert(false, u"\U000317FF"); // expected-error {{static_assert failed u"\U000317FF"}}
+static_assert(false, L"\xFFFFFFFF"); // expected-error {{static_assert failed: L"\xFFFFFFFF"}}
+static_assert(false, u"\U000317FF"); // expected-error {{static_assert failed: u"\U000317FF"}}
 
-static_assert(false, u8"Ω"); // expected-error {{static_assert failed u8"\316\251"}}
-static_assert(false, L"\u1234"); // expected-error {{static_assert failed L"\x1234"}}
-static_assert(false, L"\x1ff" "0\x123" "fx\xfffff" "goop"); // expected-error {{static_assert failed L"\x1FF""0\x123""fx\xFFFFFgoop"}}
+static_assert(false, u8"Ω"); // expected-error {{static_assert failed: u8"\316\251"}}
+static_assert(false, L"\u1234"); // expected-error {{static_assert failed: L"\x1234"}}
+static_assert(false, L"\x1ff" "0\x123" "fx\xfffff" "goop"); // expected-error {{static_assert failed: L"\x1FF""0\x123""fx\xFFFFFgoop"}}
 
 static_assert(false, R"(a
 \tb
 c
-)"); // expected-error@-3 {{static_assert failed "a\n\tb\nc\n"}}
+)"); // expected-error@-3 {{static_assert failed: a\n\tb\nc\n}}
 
 static_assert(false, "\u0080\u0081\u0082\u0083\u0099\u009A\u009B\u009C\u009D\u009E\u009F");
-// expected-error@-1 {{static_assert failed "<U+0080><U+0081><U+0082><U+0083><U+0099><U+009A><U+009B><U+009C><U+009D><U+009E><U+009F>"}}
+// expected-error@-1 {{static_assert failed: <U+0080><U+0081><U+0082><U+0083><U+0099><U+009A><U+009B><U+009C><U+009D><U+009E><U+009F>}}
 
 //! Contains RTL/LTR marks
-static_assert(false, "\u200Eabc\u200Fdef\u200Fgh"); // expected-error {{static_assert failed "‎abc‏def‏gh"}}
+static_assert(false, "\u200Eabc\u200Fdef\u200Fgh"); // expected-error {{static_assert failed: ‎abc‏def‏gh}}
 
 //! Contains ZWJ/regional indicators
-static_assert(false, "🏳️‍🌈 🏴󠁧󠁢󠁥󠁮󠁧󠁿 🇪🇺"); // expected-error {{static_assert failed "🏳️‍🌈 🏴󠁧󠁢󠁥󠁮󠁧󠁿 🇪🇺"}}
+static_assert(false, "🏳️‍🌈 🏴󠁧󠁢󠁥󠁮󠁧󠁿 🇪🇺"); // expected-error {{static_assert failed: 🏳️‍🌈 🏴󠁧󠁢󠁥󠁮󠁧󠁿 🇪🇺}}
 
 template<typename T> struct AlwaysFails {
   // Only give one error here.
   static_assert(false, ""); // expected-error {{static_assert failed}}
 };
 AlwaysFails<int> alwaysFails;
 
 template<typename T> struct StaticAssertProtected {

 struct first_trait<X> {
   static const bool value = true;
 };
 
 template<typename T> struct second_trait {
   static const bool value = false;
 };
 
-static_assert(first_trait<X>::value && second_trait<X>::value, "message"); // expected-error{{static_assert failed due to requirement 'second_trait<X>::value' "message"}}
+static_assert(first_trait<X>::value && second_trait<X>::value, "message"); // expected-error{{static_assert failed due to requirement 'second_trait<X>::value': message}}
 
 namespace std {
 
 template <class Tp, Tp v>
 struct integral_constant {
   static const Tp value = v;
   typedef Tp value_type;
   typedef integral_constant type;

 
 struct ExampleTypes {
   explicit ExampleTypes(int);
   using T = int;
   using U = float;
 };
 
 static_assert(std::is_same<ExampleTypes::T, ExampleTypes::U>::value, "message");
-// expected-error@-1{{static_assert failed due to requirement 'std::is_same<int, float>::value' "message"}}
+// expected-error@-1{{static_assert failed due to requirement 'std::is_same<int, float>::value': message}}
 static_assert(std::is_const<ExampleTypes::T>::value, "message");
-// expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value' "message"}}
+// expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value': message}}
 static_assert(!std::is_const<const ExampleTypes::T>::value, "message");
-// expected-error@-1{{static_assert failed due to requirement '!std::is_const<const int>::value' "message"}}
+// expected-error@-1{{static_assert failed due to requirement '!std::is_const<const int>::value': message}}
 static_assert(!(std::is_const<const ExampleTypes::T>::value), "message");
-// expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>::value)' "message"}}
+// expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>::value)': message}}
 static_assert(std::is_const<const ExampleTypes::T>::value == false, "message");
-// expected-error@-1{{static_assert failed due to requirement 'std::is_const<const int>::value == false' "message"}}
+// expected-error@-1{{static_assert failed due to requirement 'std::is_const<const int>::value == false': message}}
 static_assert(!(std::is_const<const ExampleTypes::T>::value == true), "message");
-// expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>::value == true)' "message"}}
+// expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>::value == true)': message}}
 static_assert(std::is_const<ExampleTypes::T>(), "message");
-// expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>()' "message"}}
+// expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>()': message}}
 static_assert(!(std::is_const<const ExampleTypes::T>()()), "message");
-// expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>()())' "message"}}
+// expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>()())': message}}
 static_assert(std::is_same<decltype(std::is_const<const ExampleTypes::T>()), int>::value, "message");
-// expected-error@-1{{static_assert failed due to requirement 'std::is_same<std::is_const<const int>, int>::value' "message"}}
+// expected-error@-1{{static_assert failed due to requirement 'std::is_same<std::is_const<const int>, int>::value': message}}
 static_assert(std::is_const<decltype(ExampleTypes::T(3))>::value, "message");
-// expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value' "message"}}
+// expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value': message}}
 static_assert(std::is_const<decltype(ExampleTypes::T())>::value, "message");
-// expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value' "message"}}
+// expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value': message}}
 static_assert(std::is_const<decltype(ExampleTypes(3))>::value, "message");
-// expected-error@-1{{static_assert failed due to requirement 'std::is_const<ExampleTypes>::value' "message"}}
+// expected-error@-1{{static_assert failed due to requirement 'std::is_const<ExampleTypes>::value': message}}
 
 struct BI_tag {};
 struct RAI_tag : BI_tag {};
 struct MyIterator {
   using tag = BI_tag;
 };
 struct MyContainer {
   using iterator = MyIterator;
 };
 template <class Container>
 void foo() {
   static_assert(std::is_same<RAI_tag, typename Container::iterator::tag>::value, "message");
-  // expected-error@-1{{static_assert failed due to requirement 'std::is_same<RAI_tag, BI_tag>::value' "message"}}
+  // expected-error@-1{{static_assert failed due to requirement 'std::is_same<RAI_tag, BI_tag>::value': message}}
 }
 template void foo<MyContainer>();
 // expected-note@-1{{in instantiation of function template specialization 'foo<MyContainer>' requested here}}
 
 namespace ns {
 template <typename T, int v>
 struct NestedTemplates1 {
   struct NestedTemplates2 {
     template <typename U>
     struct NestedTemplates3 : public std::is_same<T, U> {};
   };
 };
 } // namespace ns
 
 template <typename T, typename U, int a>
 void foo2() {
   static_assert(::ns::NestedTemplates1<T, a>::NestedTemplates2::template NestedTemplates3<U>::value, "message");
-  // expected-error@-1{{static_assert failed due to requirement '::ns::NestedTemplates1<int, 3>::NestedTemplates2::NestedTemplates3<float>::value' "message"}}
+  // expected-error@-1{{static_assert failed due to requirement '::ns::NestedTemplates1<int, 3>::NestedTemplates2::NestedTemplates3<float>::value': message}}
 }
 template void foo2<int, float, 3>();
 // expected-note@-1{{in instantiation of function template specialization 'foo2<int, float, 3>' requested here}}
 
 template <class T>
 void foo3(T t) {
   static_assert(std::is_const<T>::value, "message");
-  // expected-error-re@-1{{static_assert failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value' "message"}}
+  // expected-error-re@-1{{static_assert failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value': message}}
   static_assert(std::is_const<decltype(t)>::value, "message");
-  // expected-error-re@-1{{static_assert failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value' "message"}}
+  // expected-error-re@-1{{static_assert failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value': message}}
 }
 void callFoo3() {
   foo3([]() {});
   // expected-note@-1{{in instantiation of function template specialization 'foo3<(lambda at }}
 }
 
 template <class T>
 void foo4(T t) {

libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.verify.cpp

void pointer_to_incomplete_type() {
     // expected-error@atomic:* {{incomplete type 'Incomplete' where a complete type is required}}
     std::atomic_fetch_add(&obj, 0);
   }
 }
 
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value' "Pointer to function isn't allowed"}}
+    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value': Pointer to function isn't allowed}}
     std::atomic_fetch_add(&fun, 0);
   }
   {
     std::atomic<void (*)(int)> fun;
-    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value' "Pointer to function isn't allowed"}}
+    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value': Pointer to function isn't allowed}}
     std::atomic_fetch_add(&fun, 0);
   }
 }
 
 struct S {
   void fun(int);
 };
 

libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.verify.cpp

void pointer_to_incomplete_type() {
     // expected-error@atomic:* {{incomplete type 'Incomplete' where a complete type is required}}
     std::atomic_fetch_add_explicit(&obj, 0, std::memory_order_relaxed);
   }
 }
 
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value' "Pointer to function isn't allowed"}}
+    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value': Pointer to function isn't allowed}}
     std::atomic_fetch_add_explicit(&fun, 0, std::memory_order_relaxed);
   }
   {
     std::atomic<void (*)(int)> fun;
-    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value' "Pointer to function isn't allowed"}}
+    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value': Pointer to function isn't allowed}}
     std::atomic_fetch_add_explicit(&fun, 0, std::memory_order_relaxed);
   }
 }
 
 struct S {
   void fun(int);
 };
 

libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.verify.cpp

void pointer_to_incomplete_type() {
     // expected-error@atomic:* {{incomplete type 'Incomplete' where a complete type is required}}
     std::atomic_fetch_sub(&obj, 0);
   }
 }
 
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value' "Pointer to function isn't allowed"}}
+    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value': Pointer to function isn't allowed}}
     std::atomic_fetch_sub(&fun, 0);
   }
   {
     std::atomic<void (*)(int)> fun;
-    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value' "Pointer to function isn't allowed"}}
+    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value': Pointer to function isn't allowed}}
     std::atomic_fetch_sub(&fun, 0);
   }
 }
 
 struct S {
   void fun(int);
 };
 

libcxx/test/libcxx/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.verify.cpp

void pointer_to_incomplete_type() {
     // expected-error@atomic:* {{incomplete type 'Incomplete' where a complete type is required}}
     std::atomic_fetch_sub_explicit(&obj, 0, std::memory_order_relaxed);
   }
 }
 
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value' "Pointer to function isn't allowed"}}
+    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value': Pointer to function isn't allowed}}
     std::atomic_fetch_sub_explicit(&fun, 0, std::memory_order_relaxed);
   }
   {
     std::atomic<void (*)(int)> fun;
-    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value' "Pointer to function isn't allowed"}}
+    // expected-error@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::value': Pointer to function isn't allowed}}
     std::atomic_fetch_sub_explicit(&fun, 0, std::memory_order_relaxed);
   }
 }
 
 struct S {
   void fun(int);
 };
 

libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp

 //
 // The char type of the stream and the char_type of the traits have to match
 
 #include <fstream>
 
 int main(int, char**)
 {
   std::basic_filebuf<char, std::char_traits<wchar_t> > f;
-//  expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+//  expected-error-re@streambuf:* {{static_assert failed{{.*}}: traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp

 
 // The char type of the stream and the char_type of the traits have to match
 
 #include <fstream>
 
 int main(int, char**)
 {
   std::basic_fstream<char, std::char_traits<wchar_t> > f;
-//  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
-//  expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+//  expected-error-re@ios:* {{static_assert failed{{.*}}: traits_type::char_type must be the same type as CharT}}
+//  expected-error-re@streambuf:* {{static_assert failed{{.*}}: traits_type::char_type must be the same type as CharT}}
 
 // FIXME: As of commit r324062 Clang incorrectly generates a diagnostic about mismatching
 // exception specifications for types which are already invalid for one reason or another.
 // For now we tolerate this diagnostic.
 // expected-error@ostream:* 0-1 {{exception specification of overriding function is more lax than base version}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp

 #include <cassert>
 
 struct test_istream
     : public std::basic_istream<char, std::char_traits<wchar_t> > {};
 
 
 int main(int, char**)
 {
-//  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+//  expected-error-re@ios:* {{static_assert failed{{.*}}: traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp

 #include <cassert>
 
 struct test_ostream
     : public std::basic_ostream<char, std::char_traits<wchar_t> > {};
 
 
 int main(int, char**)
 {
-//  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+//  expected-error-re@ios:* {{static_assert failed{{.*}}: traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp

 
 // UNSUPPORTED: no-wide-characters
 
 #include <sstream>
 
 int main(int, char**)
 {
   std::basic_stringbuf<char, std::char_traits<wchar_t> > sb;
-//  expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
-//  expected-error-re@string:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+//  expected-error-re@streambuf:* {{static_assert failed{{.*}}: traits_type::char_type must be the same type as CharT}}
+//  expected-error-re@string:* {{static_assert failed{{.*}}: traits_type::char_type must be the same type as CharT}}
 
   return 0;
 }

libcxx/test/libcxx/iterators/predef.iterators/reverse.iterators/bad_template_argument.verify.cpp

 // reverse_iterator
 
 #include <iterator>
 
 #include "test_iterators.h"
 
 int main(int, char**) {
   using BadIter = std::reverse_iterator<forward_iterator<int*>>;
-  BadIter i; //expected-error-re@*:* {{static_assert failed{{.*}} "reverse_iterator<It> requires It to be a bidirectional iterator."}}
+  BadIter i; //expected-error-re@*:* {{static_assert failed{{.*}}: reverse_iterator<It> requires It to be a bidirectional iterator.}}
 
   return 0;
 }

libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp

 int main(int, char**) {
   {
     SPtr<0> s; // OK
     SPtr<1> s1(nullptr); // OK
     SPtr<2> s2(getFn<2>(), Deleter{}); // OK
     SPtr<3> s3(nullptr, Deleter{}); // OK
   }
 
-  // expected-error-re@*:* {{static_assert failed{{.*}} "default_delete cannot be instantiated for function types"}}
+  // expected-error-re@*:* {{static_assert failed{{.*}}: default_delete cannot be instantiated for function types}}
   std::default_delete<FnType<5>> deleter{}; // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp

 
 template <class ...Args>
 void F(typename CannotDeduce<std::tuple<Args...>>::type const&) {}
 
 
 int main(int, char**) {
 #if TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary)
   // Test that we emit our diagnostic from the library.
-  // expected-error@tuple:* 8 {{"Attempted construction of reference element binds to a temporary whose lifetime has ended"}}
+  // expected-error@tuple:* 8 {{Attempted construction of reference element binds to a temporary whose lifetime has ended}}
 
   // Good news everybody! Clang now diagnoses this for us!
   // expected-error@tuple:* 0+ {{reference member '__value_' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
 
   {
     F<int, const std::string&>(std::make_tuple(1, "abc")); // expected-note 1 {{requested here}}
   }
   {

libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp

 
 #include <utility>
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, double> P;
     std::tuple_element<2, P>::type foo; // expected-note {{requested here}}
-        // expected-error-re@*:* {{static_assert failed{{( due to requirement '2U[L]{0,2} < 2')?}} "Index out of bounds in std::tuple_element<std::pair<T1, T2>>"}}
+        // expected-error-re@*:* {{static_assert failed{{( due to requirement '2U[L]{0,2} < 2')?}}: Index out of bounds in std::tuple_element<std::pair<T1, T2>>}}
     }
 
   return 0;
 }

libcxx/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp

 #include <cassert>
 
 
 int main(int, char**)
 {
     {
         typedef std::variant<int, double> T;
         std::variant_alternative<2, T>::type foo; // expected-note {{requested here}}
-        // expected-error-re@variant:* {{static_assert failed{{( due to requirement '2U[L]{0,2} < sizeof...\(_Types\)')?}} "Index out of bounds in std::variant_alternative<>"}}
+        // expected-error-re@variant:* {{static_assert failed{{( due to requirement '2U[L]{0,2} < sizeof...\(_Types\)')?}}: Index out of bounds in std::variant_alternative<>}}
     }
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp

template <class PopulationIterator, class SampleIterator> void test() {
   const unsigned os = 4;
   int oa[os];
   std::minstd_rand g;
   std::sample(PopulationIterator(ia), PopulationIterator(ia + is),
                             SampleIterator(oa), os, g);
 }
 
 int main(int, char**) {
-  // expected-error-re@*:* {{static_assert failed{{( due to requirement '.*')?}} "SampleIterator must meet the requirements of RandomAccessIterator"}}
+  // expected-error-re@*:* {{static_assert 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_input_iterator<int *>, cpp17_output_iterator<int *> >();
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp

 
 #include "test_iterators.h"
 
 int main(int, char**) {
   int arr[] = {1, 2, 3};
   const int *b = std::begin(arr), *e = std::end(arr);
   typedef cpp17_input_iterator<const int*> Iter;
   {
-    // expected-error@*:* {{"std::min_element requires a ForwardIterator"}}
+    // expected-error@*:* {{std::min_element requires a ForwardIterator}}
     std::min_element(Iter(b), Iter(e));
   }
   {
-    // expected-error@*:* {{"std::max_element requires a ForwardIterator"}}
+    // expected-error@*:* {{std::max_element requires a ForwardIterator}}
     std::max_element(Iter(b), Iter(e));
   }
   {
-    // expected-error@*:* {{"std::minmax_element requires a ForwardIterator"}}
+    // expected-error@*:* {{std::minmax_element requires a ForwardIterator}}
     std::minmax_element(Iter(b), Iter(e));
   }
 
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/deduct.fail.cpp

int main(int, char**)
         // cannot deduce Key and T from just (Allocator)
         std::map m(std::allocator<PC>{});
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
     }
     {
         // 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<P>());
-            // expected-error-re@map:* {{static_assert failed{{( due to requirement '.*')?}} "Allocator::value_type must be same type as value_type"}}
+            // expected-error-re@map:* {{static_assert failed{{( due to requirement '.*')?}}: Allocator::value_type must be same type as value_type}}
     }
     {
         // cannot convert from some arbitrary unrelated type
         NotAnAllocator a;
         std::map m(a); // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'map'}}
     }
     {
         // cannot deduce that the inner braced things should be std::pair and not something else

libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.fail.cpp

int main(int, char**)
         // cannot deduce Key and T from just (Allocator)
         std::multimap m(std::allocator<PC>{});
             // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
     }
     {
         // 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<P>());
-            // expected-error-re@map:* {{static_assert failed{{( due to requirement '.*')?}} "Allocator::value_type must be same type as value_type"}}
+            // expected-error-re@map:* {{static_assert failed{{( due to requirement '.*')?}}: Allocator::value_type must be same type as value_type}}
     }
     {
         // cannot convert from some arbitrary unrelated type
         NotAnAllocator a;
         std::multimap m(a); // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'multimap'}}
     }
     {
         // cannot deduce that the inner braced things should be std::pair and not something else

libcxx/test/std/containers/sequences/array/array.fill/fill.fail.cpp

 #include <array>
 #include <cassert>
 
 int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
     C c = {};
-    // expected-error-re@array:* {{static_assert failed {{.*}}"cannot fill zero-sized array of type 'const T'"}}
+    // expected-error-re@array:* {{static_assert failed {{.*}}: cannot fill zero-sized array of type 'const T'}}
     c.fill(5.5); // expected-note {{requested here}}
   }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.swap/swap.fail.cpp

 #include <cassert>
 
 int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
     C c = {};
     C c2 = {};
-    // expected-error-re@array:* {{static_assert failed {{.*}}"cannot swap zero-sized array of type 'const T'"}}
+    // expected-error-re@array:* {{static_assert failed {{.*}}: cannot swap zero-sized array of type 'const T'}}
     c.swap(c2); // expected-note {{requested here}}
   }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/get.fail.cpp

 
 int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
         std::get<3>(c) = 5.5; // expected-note {{requested here}}
-        // expected-error-re@array:* {{static_assert 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_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}: Index out of bounds in std::get<> (std::array)}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp

 #include <cassert>
 
 int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         std::tuple_element<3, C> foo; // expected-note {{requested here}}
-        // expected-error-re@array:* {{static_assert 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_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}: Index out of bounds in std::tuple_element<> (std::array)}}
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/resize_not_move_insertable.fail.cpp

public:
   BadUserNoCookie(BadUserNoCookie&&) = delete;
   BadUserNoCookie& operator=(BadUserNoCookie&&) = delete;
 
   BadUserNoCookie(const BadUserNoCookie&) = default;
   BadUserNoCookie& operator=(const BadUserNoCookie&) = default;
 };
 
 int main(int, char**) {
-  // expected-error@* 2 {{"The specified type does not meet the requirements of Cpp17MoveInsertable"}}
+  // expected-error@* 2 {{The specified type does not meet the requirements of Cpp17MoveInsertable}}
 
   // Other diagnostics that might be seen as Clang tries to continue compiling:
   // expected-error@* 0-2 {{call to deleted constructor}}
   // expected-error@* 0-2 {{no matching function for call to 'construct_at'}}
   {
 
     std::vector<BadUserNoCookie<1> > x;
     x.emplace_back();
   }
   {
     std::vector<BadUserNoCookie<2> > x;
     BadUserNoCookie<2> c;
     x.push_back(c);
   }
   return 0;
 }

libcxx/test/std/containers/views/views.span/span.sub/subspan.verify.cpp

 #include <span>
 #include <cstddef>
 
 void f() {
   int array[] = {1, 2, 3, 4};
   std::span<const int, 4> sp(array);
 
   //  Offset too large templatized
-  [[maybe_unused]] auto s1 = sp.subspan<5>(); // expected-error@span:* {{span<T, N>::subspan<Offset, Count>(): Offset out of range"}}
+  [[maybe_unused]] auto s1 = sp.subspan<5>(); // expected-error@span:* {{span<T, N>::subspan<Offset, Count>(): Offset out of range}}
 
   //  Count too large templatized
-  [[maybe_unused]] auto s2 = sp.subspan<0, 5>(); // expected-error@span:* {{span<T, N>::subspan<Offset, Count>(): Offset + Count out of range"}}
+  [[maybe_unused]] auto s2 = sp.subspan<0, 5>(); // expected-error@span:* {{span<T, N>::subspan<Offset, Count>(): Offset + Count out of range}}
 
   //  Offset + Count too large templatized
-  [[maybe_unused]] auto s3 = sp.subspan<2, 3>(); // expected-error@span:* {{span<T, N>::subspan<Offset, Count>(): Offset + Count out of range"}}
+  [[maybe_unused]] auto s3 = sp.subspan<2, 3>(); // expected-error@span:* {{span<T, N>::subspan<Offset, Count>(): Offset + Count out of range}}
 
   //  Offset + Count overflow templatized
-  [[maybe_unused]] auto s4 = sp.subspan<3, std::size_t(-2)>(); // expected-error@span:* {{span<T, N>::subspan<Offset, Count>(): Offset + Count out of range"}}, expected-error-re@span:* {{array is too large{{(.* elements)}}}}
+  [[maybe_unused]] auto s4 = sp.subspan<3, std::size_t(-2)>(); // expected-error@span:* {{span<T, N>::subspan<Offset, Count>(): Offset + Count out of range}}, expected-error-re@span:* {{array is too large{{(.* elements)}}}}
 }

libcxx/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp

int main(int, char**)
     using H = coro::coroutine_handle<>;
     // expected-error@experimental/coroutine:* 3 {{coroutine_handle<void>::from_address cannot be called with non-void pointers}}
     H::from_address((int*)nullptr); // expected-note {{requested here}}
     H::from_address((const void*)nullptr); // expected-note {{requested here}}
     H::from_address((const char*)nullptr); // expected-note {{requested here}}
   }
   {
     using H = coro::coroutine_handle<int>;
-    // expected-error@experimental/coroutine:* 1 {{static_assert failed "coroutine_handle<promise_type>::from_address cannot be used with pointers to the coroutine's promise type; use 'from_promise' instead"}}
+    // expected-error@experimental/coroutine:* 1 {{static_assert failed: coroutine_handle<promise_type>::from_address cannot be used with pointers to the coroutine's promise type; use 'from_promise' instead}}
     H::from_address((const char*)nullptr); // expected-note {{requested here}}
     // expected-error@experimental/coroutine:* 1 {{coroutine_handle<promise_type>::from_address cannot be called with non-void pointers}}
     H::from_address((int*)nullptr); // expected-note {{requested here}}
   }
 
   return 0;
 }

libcxx/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp

 void foo() {}
 
 int main(int, char**)
 {
     void *p = nullptr;
     (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 failed{{.*}} "can't launder cv-void"}}
+    (void) std::launder((const volatile void *) nullptr);  // expected-error-re@new:* 4 {{static_assert 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 failed{{.*}} "can't launder functions"}}
+    (void) std::launder(foo);                              // expected-error-re@new:* 1 {{static_assert failed{{.*}}: can't launder functions}}
     // expected-error@new:* 0-1 {{function pointer argument to '__builtin_launder' is not allowed}}
 
   return 0;
 }

libcxx/test/std/numerics/numbers/illformed.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <numbers>
 
 // Initializing the primary template is ill-formed.
 int log2e{std::numbers::log2e_v<
-    int>}; // expected-error-re@numbers:* {{static_assert failed {{.*}} "A program that instantiates a primary template of a mathematical constant variable template is ill-formed."}}
+    int>}; // expected-error-re@numbers:* {{static_assert failed {{.*}}: A program that instantiates a primary template of a mathematical constant variable template is ill-formed.}}
 int log10e{std::numbers::log10e_v<int>};
 int pi{std::numbers::pi_v<int>};
 int inv_pi{std::numbers::inv_pi_v<int>};
 int inv_sqrtpi{std::numbers::inv_sqrtpi_v<int>};
 int ln2{std::numbers::ln2_v<int>};
 int ln10{std::numbers::ln10_v<int>};
 int sqrt2{std::numbers::sqrt2_v<int>};
 int sqrt3{std::numbers::sqrt3_v<int>};
 int inv_sqrt3{std::numbers::inv_sqrt3_v<int>};
 int egamma{std::numbers::egamma_v<int>};
 int phi{std::numbers::phi_v<int>};
 
 int main(int, char**) { return 0; }

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp

 // requirements on parameters
 
 #include <random>
 
 int main(int, char**)
 {
     typedef unsigned long long T;
 
-    // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}}
+    // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL': linear_congruential_engine invalid parameters}}
     std::linear_congruential_engine<T, 0, 0, 0> e2;
-    // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}}
+    // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL': linear_congruential_engine invalid parameters}}
     std::linear_congruential_engine<T, 0, 1, 1> e3;
     std::linear_congruential_engine<T, 1, 0, 1> e4;
-    // expected-error@*:* {{static_assert failed due to requirement 'is_unsigned<int>::value' "_UIntType must be unsigned type"}}
+    // expected-error@*:* {{static_assert failed due to requirement 'is_unsigned<int>::value': _UIntType must be unsigned type}}
     std::linear_congruential_engine<int, 0, 0, 0> e5;
 
     return 0;
 }

libcxx/test/std/strings/basic.string/char.bad.verify.cpp

 };
 
 void f() {
     {
         // array
         typedef char C[3];
         static_assert(std::is_array<C>::value, "");
         std::basic_string<C, test_traits<C> > s;
-        // expected-error-re@string:* {{static_assert failed{{.*}} "Character type of basic_string must not be an array"}}
+        // expected-error-re@string:* {{static_assert failed{{.*}}: Character type of basic_string must not be an array}}
     }
 
     {
         // not trivial
         static_assert(!std::is_trivial<NotTrivial>::value, "");
         std::basic_string<NotTrivial, test_traits<NotTrivial> > s;
-        // expected-error-re@string:* {{static_assert failed{{.*}} "Character type of basic_string must be trivial"}}
+        // expected-error-re@string:* {{static_assert failed{{.*}}: Character type of basic_string must be trivial}}
     }
 
     {
         // not standard layout
         static_assert(!std::is_standard_layout<NotStandardLayout>::value, "");
         std::basic_string<NotStandardLayout, test_traits<NotStandardLayout> > s;
-        // expected-error-re@string:* {{static_assert failed{{.*}} "Character type of basic_string must be standard-layout"}}
+        // expected-error-re@string:* {{static_assert failed{{.*}}: Character type of basic_string must be standard-layout}}
     }
 }

libcxx/test/std/strings/string.view/char.bad.fail.cpp

 
 int main(int, char**)
 {
     {
 //  array
     typedef char C[3];
     static_assert(std::is_array<C>::value, "");
     std::basic_string_view<C, test_traits<C> > sv;
-//  expected-error-re@string_view:* {{static_assert failed{{.*}} "Character type of basic_string_view must not be an array"}}
+//  expected-error-re@string_view:* {{static_assert failed{{.*}}: Character type of basic_string_view must not be an array}}
     }
 
     {
 //  not trivial
     static_assert(!std::is_trivial<NotTrivial>::value, "");
     std::basic_string_view<NotTrivial, test_traits<NotTrivial> > sv;
-//  expected-error-re@string_view:* {{static_assert failed{{.*}} "Character type of basic_string_view must be trivial"}}
+//  expected-error-re@string_view:* {{static_assert failed{{.*}}: Character type of basic_string_view must be trivial}}
     }
 
     {
 //  not standard layout
     static_assert(!std::is_standard_layout<NotStandardLayout>::value, "");
     std::basic_string_view<NotStandardLayout, test_traits<NotStandardLayout> > sv;
-//  expected-error-re@string_view:* {{static_assert failed{{.*}} "Character type of basic_string_view must be standard-layout"}}
+//  expected-error-re@string_view:* {{static_assert failed{{.*}}: Character type of basic_string_view must be standard-layout}}
     }
 
   return 0;
 }

libcxx/test/std/time/time.hms/hhmmss.fail.cpp

 #include <string>
 #include <cassert>
 #include "test_macros.h"
 
 struct A {};
 
 int main(int, char**)
 {
-    std::chrono::hh_mm_ss<void> h0;        // expected-error-re@*:* {{static_assert failed {{.*}} "template parameter of hh_mm_ss must be a std::chrono::duration"}}
-    std::chrono::hh_mm_ss<int> h1;         // expected-error-re@*:* {{static_assert failed {{.*}} "template parameter of hh_mm_ss must be a std::chrono::duration"}}
-    std::chrono::hh_mm_ss<std::string> h2; // expected-error-re@*:* {{static_assert failed {{.*}} "template parameter of hh_mm_ss must be a std::chrono::duration"}}
-    std::chrono::hh_mm_ss<A> h3;           // expected-error-re@*:* {{static_assert failed {{.*}} "template parameter of hh_mm_ss must be a std::chrono::duration"}}
+    std::chrono::hh_mm_ss<void> h0;        // expected-error-re@*:* {{static_assert failed {{.*}}: template parameter of hh_mm_ss must be a std::chrono::duration}}
+    std::chrono::hh_mm_ss<int> h1;         // expected-error-re@*:* {{static_assert failed {{.*}}: template parameter of hh_mm_ss must be a std::chrono::duration}}
+    std::chrono::hh_mm_ss<std::string> h2; // expected-error-re@*:* {{static_assert failed {{.*}}: template parameter of hh_mm_ss must be a std::chrono::duration}}
+    std::chrono::hh_mm_ss<A> h3;           // expected-error-re@*:* {{static_assert failed {{.*}}: template parameter of hh_mm_ss must be a std::chrono::duration}}
 
     return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp

 
 #include <any>
 
 struct TestType {};
 
 void test_const_lvalue_cast_request_non_const_lvalue()
 {
     const std::any a;
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     // expected-error@any:* {{drops 'const' qualifier}}
     std::any_cast<TestType &>(a); // expected-note {{requested here}}
 
     const std::any a2(42);
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     // expected-error@any:* {{drops 'const' qualifier}}
     std::any_cast<int&>(a2); // expected-note {{requested here}}
 }
 
 void test_lvalue_any_cast_request_rvalue()
 {
     std::any a;
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be an lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType &&>(a); // expected-note {{requested here}}
 
     std::any a2(42);
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be an lvalue reference or a CopyConstructible type}}
     std::any_cast<int&&>(a2); // expected-note {{requested here}}
 }
 
 void test_rvalue_any_cast_request_lvalue()
 {
     std::any a;
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert 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<TestType &>(std::move(a)); // expected-note {{requested here}}
 
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert 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<int&>(42);
 }
 
 int main(int, char**)
 {
     test_const_lvalue_cast_request_non_const_lvalue();
     test_lvalue_any_cast_request_rvalue();
     test_rvalue_any_cast_request_lvalue();
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp

 
 struct TestType {};
 struct TestType2 {};
 
 int main(int, char**)
 {
     std::any a;
 
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType &>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType &&>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType2 &>(static_cast<std::any const&&>(a)); // expected-note {{requested here}}
 
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType2 &&>(static_cast<std::any const&&>(a)); // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp

 struct no_move {
   no_move() {}
   no_move(no_move&&) = delete;
   no_move(no_move const&) {}
 };
 
 int main(int, char**) {
     std::any a;
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be an lvalue reference or a CopyConstructible type}}
     std::any_cast<no_copy>(static_cast<std::any&>(a)); // expected-note {{requested here}}
 
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<no_copy>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
     std::any_cast<no_copy>(static_cast<std::any &&>(a)); // OK
 
-    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}}: ValueType is required to be an rvalue reference or a CopyConstructible type}}
     std::any_cast<no_move>(static_cast<std::any &&>(a));
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp

 // ValueType * any_cast(any *) noexcept;
 
 #include <any>
 
 int main(int, char**)
 {
     std::any a = 1;
 
-    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}}: _ValueType may not be a reference.}}
     std::any_cast<int &>(&a); // expected-note {{requested here}}
 
-    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}}: _ValueType may not be a reference.}}
     std::any_cast<int &&>(&a); // expected-note {{requested here}}
 
-    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}}: _ValueType may not be a reference.}}
     std::any_cast<int const &>(&a); // expected-note {{requested here}}
 
-    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}}: _ValueType may not be a reference.}}
     std::any_cast<int const&&>(&a); // expected-note {{requested here}}
 
     const std::any& a2 = a;
 
-    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}}: _ValueType may not be a reference.}}
     std::any_cast<int &>(&a2); // expected-note {{requested here}}
 
-    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}}: _ValueType may not be a reference.}}
     std::any_cast<int &&>(&a2); // expected-note {{requested here}}
 
-    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}}: _ValueType may not be a reference.}}
     std::any_cast<int const &>(&a2); // expected-note {{requested here}}
 
-    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}}: _ValueType may not be a reference.}}
     std::any_cast<int const &&>(&a2); // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp

 {
   typedef std::make_integer_sequence<int, -3> MakeSeqT;
 
   // std::make_integer_sequence is implemented using a compiler builtin if available.
   // this builtin has different diagnostic messages than the fallback implementation.
 #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@*:* {{static_assert failed "std::make_integer_sequence must have a non-negative sequence length"}}
+  MakeSeqT i; // expected-error@*:* {{static_assert failed: std::make_integer_sequence must have a non-negative sequence length}}
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.fail.cpp

 
 #include "test_macros.h"
 
 struct NonDestructible { ~NonDestructible() = delete; };
 
 int main(int, char**)
 {
   {
-  std::optional<char &> o1;          // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a reference type is ill-formed"}}
-  std::optional<NonDestructible> o2;  // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed"}}
-  std::optional<char[20]> o3;          // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with an array type is ill-formed"}}
+  std::optional<char &> o1;          // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with a reference type is ill-formed}}
+  std::optional<NonDestructible> o2;  // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with a non-destructible type is ill-formed}}
+  std::optional<char[20]> o3;          // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with an array type is ill-formed}}
   }
 
   {
-  std::optional<               std::in_place_t> o1;  // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with in_place_t is ill-formed"}}
-  std::optional<const          std::in_place_t> o2;  // expected-error-re@optional:* {{static_assert 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 failed{{.*}} "instantiation of optional with in_place_t is ill-formed"}}
-  std::optional<const volatile std::in_place_t> o4;  // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with in_place_t is ill-formed"}}
+  std::optional<               std::in_place_t> o1;  // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with in_place_t is ill-formed}}
+  std::optional<const          std::in_place_t> o2;  // expected-error-re@optional:* {{static_assert 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 failed{{.*}}: instantiation of optional with in_place_t is ill-formed}}
+  std::optional<const volatile std::in_place_t> o4;  // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with in_place_t is ill-formed}}
   }
 
   {
-  std::optional<               std::nullopt_t> o1;  // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with nullopt_t is ill-formed"}}
-  std::optional<const          std::nullopt_t> o2;  // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with nullopt_t is ill-formed"}}
-  std::optional<      volatile std::nullopt_t> o3;  // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with nullopt_t is ill-formed"}}
-  std::optional<const volatile std::nullopt_t> o4;  // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with nullopt_t is ill-formed"}}
+  std::optional<               std::nullopt_t> o1;  // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with nullopt_t is ill-formed}}
+  std::optional<const          std::nullopt_t> o2;  // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with nullopt_t is ill-formed}}
+  std::optional<      volatile std::nullopt_t> o3;  // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with nullopt_t is ill-formed}}
+  std::optional<const volatile std::nullopt_t> o4;  // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with nullopt_t is ill-formed}}
   }
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp

 //  Test the implicit deduction guides
     {
 //  optional()
     std::optional opt;   // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'optional'}}
     }
 
     {
 //  optional(nullopt_t)
-    std::optional opt(std::nullopt);   // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with nullopt_t is ill-formed"}}
+    std::optional opt(std::nullopt);   // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with nullopt_t is ill-formed}}
     }
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp

 private:
     ~X() {}
 };
 
 int main(int, char**)
 {
     using std::optional;
     {
-        // expected-error-re@optional:* 2 {{static_assert failed{{.*}} "instantiation of optional with a reference type is ill-formed}}
+        // expected-error-re@optional:* 2 {{static_assert failed{{.*}}: instantiation of optional with a reference type is ill-formed}}
         optional<int&> opt1;
         optional<int&&> opt2;
     }
     {
-        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed"}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with a non-destructible type is ill-formed}}
         optional<X> opt3;
     }
     {
-        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-object type is undefined behavior"}}
-        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with a non-object type is undefined behavior}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with a non-destructible type is ill-formed}}
         optional<void()> opt4;
     }
     {
-        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-object type is undefined behavior"}}
-        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with a non-object type is undefined behavior}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}}: instantiation of optional with a non-destructible type is ill-formed}}
         // expected-error@optional:* 1+ {{cannot form a reference to 'void'}}
         optional<const void> opt4;
     }
     // FIXME these are garbage diagnostics that Clang should not produce
     // expected-error@optional:* 0+ {{is not a base class}}
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp

 
 int main(int, char**)
 {
     using std::optional;
     using std::in_place_t;
     using std::in_place;
 
     optional<in_place_t> opt; // expected-note {{requested here}}
-    // expected-error@optional:* {{"instantiation of optional with in_place_t is ill-formed"}}
+    // expected-error@optional:* {{instantiation of optional with in_place_t is ill-formed}}
 
   return 0;
 }

libcxx/test/std/utilities/utility/forward/forward.fail.cpp

 
 A source() {return A();}
 const A csource() {return A();}
 
 int main(int, char**)
 {
     {
         (void)std::forward<A&>(source());  // expected-note {{requested here}}
-        // expected-error-re@*:* 1 {{static_assert failed{{.*}} "cannot forward an rvalue as an lvalue"}}
+        // expected-error-re@*:* 1 {{static_assert failed{{.*}}: cannot forward an rvalue as an lvalue}}
     }
     {
         const A ca = A();
         std::forward<A&>(ca); // expected-error {{no matching function for call to 'forward'}}
     }
     {
         std::forward<A&>(csource());  // expected-error {{no matching function for call to 'forward'}}
     }

libcxx/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp

inline constexpr MyBoolExplicit operator>=(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
   return MyBoolExplicit(LHS.value >= RHS.value);
 }
 
 
 int main(int, char**) {
   using V = std::variant<int, ComparesToMyBoolExplicit>;
   V v1(42);
   V v2(101);
-  // expected-error-re@variant:* 6 {{static_assert failed {{.*}}"the relational operator does not return a type which is implicitly convertible to bool"}}
+  // expected-error-re@variant:* 6 {{static_assert 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}}
   (void)(v1 < v2); // expected-note {{here}}
   (void)(v1 <= v2); // expected-note {{here}}
   (void)(v1 > v2); // expected-note {{here}}
   (void)(v1 >= v2); // expected-note {{here}}
 
   return 0;
 }