Revert "Rewording the "static_assert" to static assertion"

Looks like we again are going to have problems with libcxx tests that
are overly specific in their dependency on clang's diagnostics.

This reverts commit 6542cb55a3eb115b1c3592514590a19987ffc498.

68 files changed, 129 insertions, 129 deletions

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
index eb13fb1fae31..6c4ac602ce72 100644
--- 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 pointer_to_incomplete_type() {
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@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-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::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
index 0c4952a9941a..bb45929a5041 100644
--- 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 pointer_to_incomplete_type() {
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@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-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@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);
   }
 }
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
index 35e2b4ffaef7..f996110f4977 100644
--- 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 pointer_to_incomplete_type() {
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@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-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@atomic:* {{static_assert failed due to requirement '!is_function<void (int)>::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
index b7e899ee0bfa..97416428433d 100644
--- 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 pointer_to_incomplete_type() {
 void function_pointer() {
   {
     volatile std::atomic<void (*)(int)> fun;
-    // expected-error-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@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-re@atomic:* {{static assertion failed due to requirement '!is_function<void (int)>::value'{{.*}}Pointer to function isn't allowed}}
+    // expected-error-re@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);
   }
 }
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
index af0af0a14e3a..1615cc9869e7 100644
--- 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
@@ -18,7 +18,7 @@
 int main(int, char**)
 {
 	std::basic_filebuf<char, std::char_traits<wchar_t> > f;
-//  expected-error-re@streambuf:* {{static assertion 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;
 }
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
index 6c60efc98ff8..b8475f193c85 100644
--- 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
@@ -18,8 +18,8 @@
 int main(int, char**)
 {
 	std::basic_fstream<char, std::char_traits<wchar_t> > f;
-//  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-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.
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
index 37c32ff44106..55998289eb83 100644
--- 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 @@ struct test_istream
 
 int main(int, char**)
 {
-//  expected-error-re@ios:* {{static assertion 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;
 }
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
index cfafa746a383..54878a2c9972 100644
--- 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 @@ struct test_ostream
 
 int main(int, char**)
 {
-//  expected-error-re@ios:* {{static assertion 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;
 }
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
index 6e93e30b542d..a0df8bb4cd01 100644
--- 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<char, std::char_traits<wchar_t> > sb;
-//  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-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;
 }
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
index 82e95978c69e..564831fff4c7 100644
--- 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,7 +18,7 @@
 
 int main(int, char**) {
   using BadIter = std::reverse_iterator<forward_iterator<int*>>;
-  BadIter i; //expected-error-re@*:* {{static assertion 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;
 }
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
index 9855d8ae6f86..822411415d6e 100644
--- 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 @@ void test(std::bernoulli_distribution dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static_assert 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
index 1b1bb4428f80..6680ea80d822 100644
--- 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 @@ void test(std::binomial_distribution<int> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static_assert 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
index d9b692ec9472..01287f4160bf 100644
--- 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 @@ void test(std::geometric_distribution<int> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 7 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 7 {{static_assert 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
index e526168d6d4e..fec66efe7364 100644
--- 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 @@ void test(std::negative_binomial_distribution<int> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 7 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 7 {{static_assert 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
index 59e5b50a862d..76d50e9eae3a 100644
--- 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 @@ void test(std::cauchy_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static_assert 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
index b0265148debf..7ef4c2869c8b 100644
--- 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 @@ void test(std::chi_squared_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 3 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 3 {{static_assert 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
index 77c97fb3351a..1f12398093c8 100644
--- 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 @@ void test(std::fisher_f_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 4 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 4 {{static_assert 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
index 80c34580bc40..c78ae61cf016 100644
--- 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 @@ void test(std::lognormal_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static_assert 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
index cc697ab5e7ae..d865ab150a19 100644
--- 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 @@ void test(std::normal_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static_assert 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
index 151a2bd954c8..71bc832581b8 100644
--- 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 @@ void test(std::student_t_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 5 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 5 {{static_assert 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
index b1241214de76..9214a83fc755 100644
--- 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 @@ void test(std::exponential_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* {{static_assert 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
index c002716a5316..4b4bdd067300 100644
--- 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 @@ void test(std::extreme_value_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static_assert 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
index 8bf87dd8615c..e0552616087d 100644
--- 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 @@ void test(std::gamma_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 3 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 3 {{static_assert 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
index ef56d9635fc4..12551fa60b11 100644
--- 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 @@ void test(std::poisson_distribution<int> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 4 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 4 {{static_assert 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
index e40c1972abeb..8d1f11376c90 100644
--- 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 @@ void test(std::weibull_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* {{static_assert 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
index a4def062f83f..d4172e770f72 100644
--- 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 @@ void test(std::discrete_distribution<int> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static_assert 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
index 002071129d03..47f1caa34f77 100644
--- 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 @@ void test(std::piecewise_constant_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static_assert 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
index 0fb54a403ac9..9f0422d45b7e 100644
--- 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 @@ void test(std::piecewise_linear_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* 2 {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* 2 {{static_assert 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
index 2432843942e2..5ad27576e980 100644
--- 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 @@ void test(std::uniform_int_distribution<int> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* {{static_assert 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
index fa5c3a3ebb48..38f91f9267cd 100644
--- 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 @@ void test(std::uniform_real_distribution<double> dist)
   G<int> badg;
   G<unsigned> okg;
 
-  dist(badg); //expected-error@*:* {{static assertion failed}} //expected-note {{in instantiation}}
+  dist(badg); //expected-error@*:* {{static_assert failed}} //expected-note {{in instantiation}}
   dist(okg);
 }
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
index 8cc51da013dc..44824c3c140c 100644
--- 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
@@ -45,7 +45,7 @@ int main(int, char**) {
     SPtr<3> s3(nullptr, Deleter{}); // OK
   }
 
-  // expected-error-re@*:* {{static assertion 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;
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
index 8806c967b2e3..5e7b99b8fa16 100644
--- 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 @@ 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 assertion 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;
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
index 29f9ace51ca8..5473e65d9094 100644
--- 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 @@ 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 assertion 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;
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
index f979d72933d5..3e21576afc85 100644
--- 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 @@ template <class PopulationIterator, class SampleIterator> void test() {
 }
 
 int main(int, char**) {
-  // expected-error-re@*:* {{static assertion 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 *> >();
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
index 70e200cda324..ab77167c3741 100644
--- 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 @@ int main(int, char**)
         // 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 assertion 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
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
index 1fda02638ef6..47d32d7e1f4c 100644
--- 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 @@ int main(int, char**)
         // 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 assertion 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
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
index da16fd462663..9aea551dc653 100644
--- 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 @@ int main(int, char**) {
     typedef double T;
     typedef std::array<const T, 0> C;
     C c = {};
-    // expected-error-re@array:* {{static assertion 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}}
   }
 
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
index 03cfccac80b7..d7726164d4b2 100644
--- 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 @@ int main(int, char**) {
     typedef std::array<const T, 0> C;
     C c = {};
     C c2 = {};
-    // expected-error-re@array:* {{static assertion 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}}
   }
 
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
index cf933e5c0d69..cd74522c92ce 100644
--- 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 @@ int main(int, char**)
         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 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_assert 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
index 7a5532eaea09..26360790bf4d 100644
--- 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 @@ 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 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_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;
diff --git a/libcxx/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp b/libcxx/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
index 85e3df149f83..8a9a64ef1b41 100644
--- a/libcxx/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
+++ b/libcxx/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
@@ -36,7 +36,7 @@ int main(int, char**)
   }
   {
     using H = coro::coroutine_handle<int>;
-    // expected-error-re@experimental/coroutine:* 1 {{static assertion failed{{.*}}coroutine_handle<promise_type>::from_address cannot be used with pointers to the coroutine's promise type; use 'from_promise' instead}}
+    // expected-error-re@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}}
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
index f8f04112fa82..396053c8d78b 100644
--- 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 @@ int main(int, char**)
     (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 assertion 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 assertion 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;
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
index e9c8506f9fad..ff6f29e8817f 100644
--- 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
@@ -34,19 +34,19 @@ constexpr bool toobig()
 int main(int, char**)
 {
 //	Make sure we generate a compile-time error for UB
-	static_assert(toobig<unsigned char>(),      ""); // expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<unsigned short>(),     ""); // expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<unsigned>(),           ""); // expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<unsigned long>(),      ""); // expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<unsigned long long>(), ""); // expected-error {{static assertion expression is not an integral constant expression}}
-
-	static_assert(toobig<uint8_t>(), ""); 	// expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<uint16_t>(), ""); 	// expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<uint32_t>(), ""); 	// expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<uint64_t>(), ""); 	// expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<size_t>(), ""); 	// expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<uintmax_t>(), "");	// expected-error {{static assertion expression is not an integral constant expression}}
-	static_assert(toobig<uintptr_t>(), "");	// expected-error {{static assertion expression is not an integral constant expression}}
+	static_assert(toobig<unsigned char>(),      ""); // expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<unsigned short>(),     ""); // expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<unsigned>(),           ""); // expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<unsigned long>(),      ""); // expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<unsigned long long>(), ""); // expected-error {{static_assert expression is not an integral constant expression}}
+
+	static_assert(toobig<uint8_t>(), ""); 	// expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<uint16_t>(), ""); 	// expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<uint32_t>(), ""); 	// expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<uint64_t>(), ""); 	// expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<size_t>(), ""); 	// expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<uintmax_t>(), "");	// expected-error {{static_assert expression is not an integral constant expression}}
+	static_assert(toobig<uintptr_t>(), "");	// expected-error {{static_assert 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
index db8795740300..85e8f2dcb7cd 100644
--- a/libcxx/test/std/numerics/numbers/illformed.verify.cpp
+++ b/libcxx/test/std/numerics/numbers/illformed.verify.cpp
@@ -12,7 +12,7 @@
 
 // Initializing the primary template is ill-formed.
 int log2e{std::numbers::log2e_v<
-    int>}; // expected-error-re@numbers:* {{static assertion 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>};
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
index bc9b5636e415..c8df9927b072 100644
--- 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 @@ int main(int, char**)
 {
     typedef unsigned long long T;
 
-    // expected-error-re@*:* {{static assertion failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}}
+    // expected-error-re@*:* {{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-re@*:* {{static assertion failed due to requirement '1ULL == 0 || 1ULL < 1ULL'{{.*}}linear_congruential_engine invalid parameters}}
+    // expected-error-re@*:* {{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-re@*:* {{static assertion failed due to requirement 'is_unsigned<int>::value'{{.*}}_UIntType must be unsigned type}}
+    // expected-error-re@*:* {{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;
diff --git a/libcxx/test/std/strings/basic.string/char.bad.verify.cpp b/libcxx/test/std/strings/basic.string/char.bad.verify.cpp
index d414d9a7005d..a3ab207f420a 100644
--- 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 @@ void f() {
         typedef char C[3];
         static_assert(std::is_array<C>::value, "");
         std::basic_string<C, test_traits<C> > s;
-        // expected-error-re@string:* {{static assertion 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 assertion 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 assertion 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}}
     }
 }
diff --git a/libcxx/test/std/strings/string.view/char.bad.fail.cpp b/libcxx/test/std/strings/string.view/char.bad.fail.cpp
index ad460f341f7b..d8b8878b19d7 100644
--- 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 @@ int main(int, char**)
     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 assertion 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 assertion 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 assertion 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;
diff --git a/libcxx/test/std/time/time.hms/hhmmss.fail.cpp b/libcxx/test/std/time/time.hms/hhmmss.fail.cpp
index 70bd45f56f8f..c9d4788d7ad3 100644
--- a/libcxx/test/std/time/time.hms/hhmmss.fail.cpp
+++ b/libcxx/test/std/time/time.hms/hhmmss.fail.cpp
@@ -21,10 +21,10 @@ struct A {};
 
 int main(int, char**)
 {
-    std::chrono::hh_mm_ss<void> h0;        // expected-error-re@*:* {{static assertion failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}}
-    std::chrono::hh_mm_ss<int> h1;         // expected-error-re@*:* {{static assertion 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 assertion failed{{.*}}template parameter of hh_mm_ss must be a std::chrono::duration}}
-    std::chrono::hh_mm_ss<A> h3;           // expected-error-re@*:* {{static assertion 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;
 }
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
index 6d90210ff03e..aa56b6d9cf25 100644
--- 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
@@ -25,12 +25,12 @@ struct TestType {};
 void test_const_lvalue_cast_request_non_const_lvalue()
 {
     const std::any a;
-    // expected-error-re@any:* {{static assertion 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 assertion 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}}
 }
@@ -38,22 +38,22 @@ void test_const_lvalue_cast_request_non_const_lvalue()
 void test_lvalue_any_cast_request_rvalue()
 {
     std::any a;
-    // expected-error-re@any:* {{static assertion 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 assertion 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 assertion 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 assertion 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);
 }
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
index ce0f82f7fda3..83fd47d95b51 100644
--- 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
@@ -34,16 +34,16 @@ int main(int, char**)
 {
     std::any a;
 
-    // expected-error-re@any:* {{static assertion 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 assertion 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 assertion 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 assertion 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;
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
index 0c09959de778..c3cdfe7f9458 100644
--- 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
@@ -48,15 +48,15 @@ struct no_move {
 
 int main(int, char**) {
     std::any a;
-    // expected-error-re@any:* {{static assertion 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 assertion 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 assertion 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;
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
index 0a13fdf0c6d8..f362dd08645c 100644
--- 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 @@ int main(int, char**)
 {
     std::any a = 1;
 
-    // expected-error-re@any:* 1 {{static assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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;
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
index e0c0eb018da5..5ab74bed2728 100644
--- 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
@@ -25,7 +25,7 @@ constexpr bool test() {
 }
 
 int main(int, char**) {
-  // expected-error@+1 {{static assertion expression is not an integral constant expression}}
+  // expected-error@+1 {{static_assert expression is not an integral constant expression}}
   static_assert(test());
 
   return 0;
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
index 5d97ddaf557c..729045961e1c 100644
--- 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
@@ -40,7 +40,7 @@ int main(int, char**)
     const int c = 1;
 
     auto p = std::bind_front(pass, c);
-    static_assert(p() == 1); // expected-error {{static assertion expression is not an integral constant expression}}
+    static_assert(p() == 1); // expected-error {{static_assert 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
index 8a6a768b73ba..1394ff0c9d62 100644
--- 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 @@ int main(int, char**)
 #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 assertion 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;
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
index 8baf22447e77..f12b6808edeb 100644
--- 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
@@ -34,7 +34,7 @@ constexpr bool test()
 
 int main(int, char**)
 {
-    static_assert(test<double>()); // expected-error {{static assertion expression is not an integral constant expression}}
-    LIBCPP_STATIC_ASSERT(test<const double>()); // expected-error {{static assertion expression is not an integral constant expression}}
+    static_assert(test<double>()); // expected-error {{static_assert expression is not an integral constant expression}}
+    LIBCPP_STATIC_ASSERT(test<const double>()); // expected-error {{static_assert expression is not an integral constant expression}}
     return 0;
 }
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
index 9d2e78715f81..8b995a1784ef 100644
--- 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 @@ int main(int, char**)
   // expected-error@+1 {{no member named 'is_constant_evaluated' in namespace 'std'}}
   bool b = std::is_constant_evaluated();
 #else
-  // expected-error@+1 {{static assertion failed}}
+  // expected-error@+1 {{static_assert 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
index 8e8da18ad7b7..bb2483ecd2ca 100644
--- 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 @@ struct NonDestructible { ~NonDestructible() = delete; };
 int main(int, char**)
 {
 	{
-	std::optional<char &> o1;	        // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}}
-	std::optional<NonDestructible> o2;  // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
-	std::optional<char[20]> o3;	        // expected-error-re@optional:* {{static assertion 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 assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
-	std::optional<const          std::in_place_t> 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<const volatile std::in_place_t> o4;  // expected-error-re@optional:* {{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_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 assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-	std::optional<const          std::nullopt_t> 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<const volatile std::nullopt_t> o4;	// expected-error-re@optional:* {{static assertion 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;
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
index 0c887c683a81..9b28b766be44 100644
--- 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 @@ int main(int, char**)
 
     {
 //  optional(nullopt_t)
-    std::optional opt(std::nullopt);   // expected-error-re@optional:* {{static assertion 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;
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
index 85bef2a7c657..e6b48b53b218 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
@@ -48,6 +48,6 @@ constexpr bool test() // expected-error {{constexpr function never produces a co
 int main(int, char**)
 {
     static_assert (!std::is_trivially_move_constructible_v<S>, "" );
-    static_assert (test(), "");  // expected-error {{static assertion expression is not an integral constant expression}}
+    static_assert (test(), "");  // expected-error {{static_assert expression is not an integral constant expression}}
     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
index a96c3c648f93..3149e5a900db 100644
--- 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 @@ int main(int, char**)
 {
     using std::optional;
     {
-        // expected-error-re@optional:* 2 {{static assertion 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 assertion 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 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-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 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-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;
     }
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
index 63a8b26dfa21..2599ec033cc7 100644
--- 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 @@ int main(int, char**)
     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@__tuple:* 2 {{static assertion failed}}
+        // expected-error@__tuple:* 2 {{static_assert 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
index 64c20ae6f526..44ecddf74482 100644
--- a/libcxx/test/std/utilities/utility/forward/forward.fail.cpp
+++ b/libcxx/test/std/utilities/utility/forward/forward.fail.cpp
@@ -23,7 +23,7 @@ int main(int, char**)
 {
     {
         (void)std::forward<A&>(source());  // expected-note {{requested here}}
-        // expected-error-re@*:* 1 {{static assertion 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();
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
index 64248171d114..eaf7e79b971e 100644
--- 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 @@ int main(int, char**) {
   using V = std::variant<int, ComparesToMyBoolExplicit>;
   V v1(42);
   V v2(101);
-  // expected-error-re@variant:* 6 {{static assertion 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}}
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
index 471fa158ed57..0c531d0e0f84 100644
--- 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@variant:* 3 {{static assertion failed}}
+    // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, int[]> v; // expected-note {{requested here}}
     std::variant<int, int[42]> v2; // expected-note {{requested here}}
     std::variant<int, int[][42]> 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
index 3d985e09c49b..e57a6c8f38ae 100644
--- 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@variant:* 1 {{static assertion failed}}
+    // expected-error@variant:* 1 {{static_assert 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
index 56b4e23dd232..193db411ec70 100644
--- 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@variant:* 3 {{static assertion failed}}
+    // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, int&> v; // expected-note {{requested here}}
     std::variant<int, const int &> v2; // expected-note {{requested here}}
     std::variant<int, int&&> 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
index 106f8af0ecd3..ae7982069cd3 100644
--- 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@variant:* 3 {{static assertion failed}}
+    // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, void> v; // expected-note {{requested here}}
     std::variant<int, const void> v2; // expected-note {{requested here}}
     std::variant<const volatile void, int> v3; // expected-note {{requested here}}