rewording static_assert to more generic static assertion

[xgupta]

Running check-clang after applying the patch, results into 36 failed test cases. Please update them all.
Also add a description of patch motivation(via the Edit Revision option on the top) for why you are making the changes (like any wrong behavior you are seeing etc).

[Codesbyusman]

Ok ... I am working on the tests I will update it

[Codesbyusman]

*ERR_CLOSED: <differential.updaterevision> This revision has already been
closed*

@Shivam Gupta <[e-mail]> can
not update the patch. it seems it is closed.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_messaging_unqualified_id_with_direct_method : Error<
   "messaging unqualified id with a method that is possibly direct">;
 def err_messaging_super_with_direct_method : Error<
   "messaging super with a direct method">;
 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">;
+  "static assertion 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 assertion failed%select{ %1|}0">;
 def err_static_assert_requirement_failed : Error<
-  "static_assert failed due to requirement '%0'%select{ %2|}1">;
+  "static assertion 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/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(f(), "f"); // expected-error {{static assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion failed L"\xFFFFFFFF"}}
+static_assert(false, u"\U000317FF"); // expected-error {{static assertion failed u"\U000317FF"}}
 // FIXME: render this as u8"\u03A9"
-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 assertion failed u8"\316\251"}}
+static_assert(false, L"\u1234"); // expected-error {{static assertion failed L"\x1234"}}
+static_assert(false, L"\x1ff" "0\x123" "fx\xfffff" "goop"); // expected-error {{static assertion failed L"\x1FF""0\x123""fx\xFFFFFgoop"}}
 
 template<typename T> struct AlwaysFails {
   // Only give one error here.
-  static_assert(false, ""); // expected-error {{static_assert failed}}
+  static_assert(false, ""); // expected-error {{static assertion failed}}
 };
 AlwaysFails<int> alwaysFails;
 
 template<typename T> struct StaticAssertProtected {
-  static_assert(__is_literal(T), ""); // expected-error {{static_assert failed}}
+  static_assert(__is_literal(T), ""); // expected-error {{static assertion failed}}
   static constexpr T t = {}; // no error here
 };
 struct X { ~X(); };
 StaticAssertProtected<int> sap1;
 StaticAssertProtected<X> sap2; // expected-note {{instantiation}}
 
 static_assert(true); // expected-warning {{C++17 extension}}
 static_assert(false); // expected-error-re {{failed{{$}}}} expected-warning {{extension}}
 
 
 // Diagnostics for static_assert with multiple conditions
 template<typename T> struct first_trait {
   static const bool value = false;
 };
 
 template<>
 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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) {
   static_assert(std::is_const<typename T::iterator>::value, "message");
   // expected-error@-1{{type 'int' cannot be used prior to '::' because it has no members}}
 }
 void callFoo4() { foo4(42); }
 // expected-note@-1{{in instantiation of function template specialization 'foo4<int>' requested here}}
 
 static_assert(42, "message");
 static_assert(42.0, "message"); // expected-warning {{implicit conversion from 'double' to 'bool' changes value from 42 to true}}
 constexpr int *p = 0;
-static_assert(p, "message"); // expected-error {{static_assert failed}}
+static_assert(p, "message"); // expected-error {{static assertion failed}}
 
 struct NotBool {
 } notBool;
 constexpr NotBool constexprNotBool;
 static_assert(notBool, "message");          // expected-error {{value of type 'struct NotBool' is not contextually convertible to 'bool'}}
 static_assert(constexprNotBool, "message"); // expected-error {{value of type 'const NotBool' is not contextually convertible to 'bool'}}