[clang] 041d401 - Revert "Rewording "static_assert" diagnostics"
Mitch Phillips via cfe-commits
cfe-commits at lists.llvm.org
Thu Jul 14 10:59:36 PDT 2022
Author: Mitch Phillips
Date: 2022-07-14T10:59:20-07:00
New Revision: 041d4012e4c0898bb4e31ffb75655d8163e3ee89
URL: https://github.com/llvm/llvm-project/commit/041d4012e4c0898bb4e31ffb75655d8163e3ee89
DIFF: https://github.com/llvm/llvm-project/commit/041d4012e4c0898bb4e31ffb75655d8163e3ee89.diff
LOG: Revert "Rewording "static_assert" diagnostics"
This reverts commit b7e77ff25fb2412f6ab6d6cc756666b0e2f97bd3.
Reason: Broke sanitizer builds bots + libcxx. 'static assertion
expression is not an integral constant expression'. More details
available in the Phabricator review: https://reviews.llvm.org/D129048
Added:
Modified:
clang/include/clang/Basic/DiagnosticParseKinds.td
clang/include/clang/Basic/DiagnosticSemaKinds.td
clang/include/clang/Parse/Parser.h
clang/lib/Parse/ParseDeclCXX.cpp
clang/lib/Parse/Parser.cpp
clang/test/C/drs/dr0xx.c
clang/test/CXX/dcl.dcl/p4-0x.cpp
clang/test/CXX/drs/dr19xx.cpp
clang/test/CXX/expr/expr.prim/expr.prim.id/p3.cpp
clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp
clang/test/CXX/temp/temp.constr/temp.constr.constr/partial-specializations.cpp
clang/test/PCH/cxx-static_assert.cpp
clang/test/PCH/cxx-templates.cpp
clang/test/Parser/objc-static-assert.m
clang/test/Parser/objc-static-assert.mm
clang/test/Sema/builtin-align.c
clang/test/Sema/sizeless-1.c
clang/test/Sema/static-assert.c
clang/test/SemaCXX/access-base-class.cpp
clang/test/SemaCXX/alias-template.cpp
clang/test/SemaCXX/builtin-is-constant-evaluated.cpp
clang/test/SemaCXX/builtin-std-move.cpp
clang/test/SemaCXX/builtins.cpp
clang/test/SemaCXX/complex-folding.cpp
clang/test/SemaCXX/constant-expression-cxx11.cpp
clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
clang/test/SemaCXX/coroutines-exp-namespace.cpp
clang/test/SemaCXX/coroutines.cpp
clang/test/SemaCXX/cxx2a-template-lambdas.cpp
clang/test/SemaCXX/cxx98-compat.cpp
clang/test/SemaCXX/delete-and-function-templates.cpp
clang/test/SemaCXX/int-ptr-cast-SFINAE.cpp
clang/test/SemaCXX/recovery-expr-type.cpp
clang/test/SemaCXX/sizeless-1.cpp
clang/test/SemaCXX/static-assert-cxx17.cpp
clang/test/SemaCXX/static-assert.cpp
clang/test/SemaCXX/using-decl-templates.cpp
clang/test/SemaCXX/weak-init.cpp
clang/test/SemaTemplate/instantiate-var-template.cpp
clang/test/SemaTemplate/pr52909.cpp
clang/test/SemaTemplate/pr52970.cpp
clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td
index cca251cab801e..352a050ba5cf1 100644
--- a/clang/include/clang/Basic/DiagnosticParseKinds.td
+++ b/clang/include/clang/Basic/DiagnosticParseKinds.td
@@ -282,7 +282,7 @@ def err_inline_nested_namespace_definition : Error<
def err_expected_semi_after_attribute_list : Error<
"expected ';' after attribute list">;
def err_expected_semi_after_static_assert : Error<
- "expected ';' after '%0'">;
+ "expected ';' after static_assert">;
def err_expected_semi_for : Error<"expected ';' in 'for' statement specifier">;
def err_single_decl_assign_in_for_range : Error<
"range-based 'for' statement uses ':', not '='">;
@@ -425,7 +425,7 @@ def err_unexpected_token_in_nested_name_spec : Error<
def err_bool_redeclaration : Error<
"redeclaration of C++ built-in type 'bool'">;
def warn_cxx98_compat_static_assert : Warning<
- "'static_assert' declarations are incompatible with C++98">,
+ "static_assert declarations are incompatible with C++98">,
InGroup<CXX98Compat>, DefaultIgnore;
def ext_ms_static_assert : ExtWarn<
"use of 'static_assert' without inclusion of <assert.h> is a Microsoft "
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index bd02659c9c9dc..550029f58b546 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -1526,12 +1526,12 @@ def err_messaging_class_with_direct_method : Error<
// C++ declarations
def err_static_assert_expression_is_not_constant : Error<
- "static assertion expression is not an integral constant expression">;
+ "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 assertion failed%select{: %1|}0">;
+def err_static_assert_failed : Error<"static_assert failed%select{: %1|}0">;
def err_static_assert_requirement_failed : Error<
- "static assertion 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">,
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
index a9c85ceb434c4..76e1c9db5284e 100644
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -1043,7 +1043,7 @@ class Parser : public CodeCompletionHandler {
/// If the next token is not a semicolon, this emits the specified diagnostic,
/// or, if there's just some closing-delimiter noise (e.g., ')' or ']') prior
/// to the semicolon, consumes that extra token.
- bool ExpectAndConsumeSemi(unsigned DiagID , StringRef TokenUsed = "");
+ bool ExpectAndConsumeSemi(unsigned DiagID);
/// The kind of extra semi diagnostic to emit.
enum ExtraSemiKind {
diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp
index 9886481e587d5..143b373e9ea54 100644
--- a/clang/lib/Parse/ParseDeclCXX.cpp
+++ b/clang/lib/Parse/ParseDeclCXX.cpp
@@ -926,9 +926,6 @@ Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){
assert(Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert) &&
"Not a static_assert declaration");
- // Save the token used for static assertion.
- Token SavedTok = Tok;
-
if (Tok.is(tok::kw__Static_assert) && !getLangOpts().C11)
Diag(Tok, diag::ext_c11_feature) << Tok.getName();
if (Tok.is(tok::kw_static_assert)) {
@@ -992,9 +989,7 @@ Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){
T.consumeClose();
DeclEnd = Tok.getLocation();
- // Passing the token used to the error message.
- ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert,
- SavedTok.getName());
+ ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert);
return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc,
AssertExpr.get(),
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index fd044660845be..ab8748c2c63da 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -153,7 +153,7 @@ bool Parser::ExpectAndConsume(tok::TokenKind ExpectedTok, unsigned DiagID,
return true;
}
-bool Parser::ExpectAndConsumeSemi(unsigned DiagID, StringRef TokenUsed) {
+bool Parser::ExpectAndConsumeSemi(unsigned DiagID) {
if (TryConsumeToken(tok::semi))
return false;
@@ -172,7 +172,7 @@ bool Parser::ExpectAndConsumeSemi(unsigned DiagID, StringRef TokenUsed) {
return false;
}
- return ExpectAndConsume(tok::semi, DiagID , TokenUsed);
+ return ExpectAndConsume(tok::semi, DiagID);
}
void Parser::ConsumeExtraSemi(ExtraSemiKind Kind, DeclSpec::TST TST) {
diff --git a/clang/test/C/drs/dr0xx.c b/clang/test/C/drs/dr0xx.c
index 78816011078cf..4f0a505ec4f03 100644
--- a/clang/test/C/drs/dr0xx.c
+++ b/clang/test/C/drs/dr0xx.c
@@ -203,7 +203,7 @@ _Static_assert(THIS$AND$THAT(1, 1) == 2, "fail"); /* expected-warning 2 {{'$' in
* Note: the rule changed in C99 to be
diff erent 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 assertion 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?
diff --git a/clang/test/CXX/dcl.dcl/p4-0x.cpp b/clang/test/CXX/dcl.dcl/p4-0x.cpp
index 925dea9d471f4..f3988b31df3a2 100644
--- a/clang/test/CXX/dcl.dcl/p4-0x.cpp
+++ b/clang/test/CXX/dcl.dcl/p4-0x.cpp
@@ -18,4 +18,4 @@ 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 assertion failed: L"\024hi!\""}}
+static_assert(false, L"\x14hi" "!" R"x(")x"); // expected-error {{static_assert failed: L"\024hi!\""}}
diff --git a/clang/test/CXX/drs/dr19xx.cpp b/clang/test/CXX/drs/dr19xx.cpp
index 08ee2ee77a84f..38d3ca589eca7 100644
--- a/clang/test/CXX/drs/dr19xx.cpp
+++ b/clang/test/CXX/drs/dr19xx.cpp
@@ -83,7 +83,7 @@ namespace dr1940 { // dr1940: yes
#if __cplusplus >= 201103L
static union {
static_assert(true, ""); // ok
- static_assert(false, ""); // expected-error {{static assertion failed}}
+ static_assert(false, ""); // expected-error {{static_assert failed}}
int not_empty;
};
#endif
diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.id/p3.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.id/p3.cpp
index 28b5d0adcf054..ed26bcbf6b944 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.id/p3.cpp
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.id/p3.cpp
@@ -161,10 +161,10 @@ concept Large = sizeof(T) > 100;
struct small { };
static_assert(Large<small>);
-// expected-error at -1 {{static assertion failed}}
+// expected-error at -1 {{static_assert failed}}
// expected-note at -2 {{because 'small' does not satisfy 'Large'}}
static_assert(Large<small>, "small isn't large");
-// expected-error at -1 {{static assertion failed: small isn't large}}
+// expected-error at -1 {{static_assert failed: small isn't large}}
// expected-note at -2 {{because 'small' does not satisfy 'Large'}}
// Make sure access-checking can fail a concept specialization
@@ -173,7 +173,7 @@ class T4 { static constexpr bool f = true; };
template<typename T> concept AccessPrivate = T{}.f;
// expected-note at -1{{because substituted constraint expression is ill-formed: 'f' is a private member of 'T4'}}
static_assert(AccessPrivate<T4>);
-// expected-error at -1{{static assertion failed}}
+// expected-error at -1{{static_assert failed}}
// expected-note at -2{{because 'T4' does not satisfy 'AccessPrivate'}}
template<typename T, typename U>
diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp
index 02c1a9dcaf3b3..b45b57f6b9242 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp
@@ -43,5 +43,5 @@ namespace std_example {
requires sizeof(a) == 4; // OK
requires a == 0; // expected-note{{because 'a == 0' would be invalid: constraint variable 'a' cannot be used in an evaluated context}}
};
- static_assert(C2<int>); // expected-note{{because 'int' does not satisfy 'C2'}} expected-error{{static assertion failed}}
-}
+ static_assert(C2<int>); // expected-note{{because 'int' does not satisfy 'C2'}} expected-error{{static_assert failed}}
+}
\ No newline at end of file
diff --git a/clang/test/CXX/temp/temp.constr/temp.constr.constr/partial-specializations.cpp b/clang/test/CXX/temp/temp.constr/temp.constr.constr/partial-specializations.cpp
index 309a434b7fb34..7d5c8c40da057 100644
--- a/clang/test/CXX/temp/temp.constr/temp.constr.constr/partial-specializations.cpp
+++ b/clang/test/CXX/temp/temp.constr/temp.constr.constr/partial-specializations.cpp
@@ -79,6 +79,6 @@ namespace variable_templates
// expected-note at -1{{while checking constraint satisfaction for variable template partial specialization 'v1<int>' required here}}
// expected-note at -2{{during template argument deduction for variable template partial specialization 'v1<T *>' [with T = int *]}}
// expected-note at -3{{during template argument deduction for variable template partial specialization 'v1<T **>' [with T = int]}}
- // expected-error at -4{{static assertion failed due to requirement 'v1<int **>'}}
+ // expected-error at -4{{static_assert failed due to requirement 'v1<int **>'}}
-}
+}
\ No newline at end of file
diff --git a/clang/test/PCH/cxx-static_assert.cpp b/clang/test/PCH/cxx-static_assert.cpp
index 5cbde183bb6dc..d2cf8926a88f0 100644
--- a/clang/test/PCH/cxx-static_assert.cpp
+++ b/clang/test/PCH/cxx-static_assert.cpp
@@ -17,7 +17,7 @@ template<int N> struct T {
#else
-// expected-error at 15 {{static assertion failed due to requirement '1 == 2': N is not 2!}}
+// expected-error at 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;
diff --git a/clang/test/PCH/cxx-templates.cpp b/clang/test/PCH/cxx-templates.cpp
index 804c42e6760b2..c5694425585db 100644
--- a/clang/test/PCH/cxx-templates.cpp
+++ b/clang/test/PCH/cxx-templates.cpp
@@ -167,7 +167,7 @@ namespace DependentMemberExpr {
// This used to mark 'f' invalid without producing any diagnostic. That's a
// little hard to detect, but we can make sure that constexpr evaluation
// fails when it should.
- static_assert(A<int>().f() == 1); // expected-error {{static assertion failed}}
+ static_assert(A<int>().f() == 1); // expected-error {{static_assert failed}}
#endif
}
diff --git a/clang/test/Parser/objc-static-assert.m b/clang/test/Parser/objc-static-assert.m
index b16405787d57b..138b4fce2058d 100644
--- a/clang/test/Parser/objc-static-assert.m
+++ b/clang/test/Parser/objc-static-assert.m
@@ -15,7 +15,7 @@
@interface A {
int a;
_Static_assert(1, "");
- _Static_assert(0, ""); // expected-error {{static assertion failed}}
+ _Static_assert(0, ""); // expected-error {{static_assert failed}}
_Static_assert(a, ""); // expected-error {{use of undeclared identifier 'a'}}
_Static_assert(sizeof(a), ""); // expected-error {{use of undeclared identifier 'a'}}
@@ -44,7 +44,7 @@ @interface A {
@interface A {
int a;
_Static_assert(1, "");
- _Static_assert(0, ""); // expected-error {{static assertion failed}}
+ _Static_assert(0, ""); // expected-error {{static_assert failed}}
}
_Static_assert(1, "");
diff --git a/clang/test/Parser/objc-static-assert.mm b/clang/test/Parser/objc-static-assert.mm
index 936e484909f53..125dd4856a5e3 100644
--- a/clang/test/Parser/objc-static-assert.mm
+++ b/clang/test/Parser/objc-static-assert.mm
@@ -21,12 +21,12 @@ @interface A {
static_assert(1, "");
_Static_assert(1, "");
- static_assert(0, ""); // expected-error {{static assertion failed}}
- _Static_assert(0, ""); // expected-error {{static assertion failed}}
+ static_assert(0, ""); // expected-error {{static_assert failed}}
+ _Static_assert(0, ""); // expected-error {{static_assert failed}}
- static_assert(a, ""); // expected-error {{static assertion expression is not an integral constant expression}}
+ static_assert(a, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert(sizeof(a) == 4, "");
- static_assert(sizeof(a) == 3, ""); // expected-error {{static assertion failed}}
+ static_assert(sizeof(a) == 3, ""); // expected-error {{static_assert failed}}
}
static_assert(1, "");
@@ -40,7 +40,7 @@ @implementation A {
static_assert(1, "");
_Static_assert(1, "");
static_assert(sizeof(b) == 4, "");
- static_assert(sizeof(b) == 3, ""); // expected-error {{static assertion failed}}
+ static_assert(sizeof(b) == 3, ""); // expected-error {{static_assert failed}}
}
static_assert(1, "");
@@ -56,7 +56,7 @@ @interface B
@interface B () {
int b;
static_assert(sizeof(b) == 4, "");
- static_assert(sizeof(b) == 3, ""); // expected-error {{static assertion failed}}
+ static_assert(sizeof(b) == 3, ""); // expected-error {{static_assert failed}}
}
@end
@@ -71,7 +71,7 @@ @interface A {
int a;
static_assert(1, ""); // expected-error {{type name requires a specifier or qualifier}} expected-error{{expected parameter declarator}} expected-error {{expected ')'}} expected-note {{to match this '('}}
_Static_assert(1, "");
- _Static_assert(0, ""); // expected-error {{static assertion failed}}
+ _Static_assert(0, ""); // expected-error {{static_assert failed}}
}
@end
#endif
diff --git a/clang/test/Sema/builtin-align.c b/clang/test/Sema/builtin-align.c
index 9c73218f70c23..d4cdc230e914f 100644
--- a/clang/test/Sema/builtin-align.c
+++ b/clang/test/Sema/builtin-align.c
@@ -113,8 +113,8 @@ void constant_expression(int x) {
_Static_assert(__builtin_align_down(33, 32) == 32, "");
// But not if one of the arguments isn't constant:
- _Static_assert(ALIGN_BUILTIN(33, x) != 100, ""); // expected-error {{static assertion expression is not an integral constant expression}}
- _Static_assert(ALIGN_BUILTIN(x, 4) != 100, ""); // expected-error {{static assertion expression is not an integral constant expression}}
+ _Static_assert(ALIGN_BUILTIN(33, x) != 100, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+ _Static_assert(ALIGN_BUILTIN(x, 4) != 100, ""); // expected-error {{static_assert expression is not an integral constant expression}}
}
// Check that it is a constant expression that can be assigned to globals:
diff --git a/clang/test/Sema/sizeless-1.c b/clang/test/Sema/sizeless-1.c
index 5e7e3be772e8c..d50d1c629d13d 100644
--- a/clang/test/Sema/sizeless-1.c
+++ b/clang/test/Sema/sizeless-1.c
@@ -69,7 +69,7 @@ void func(int sel) {
// Using pointers to sizeless data isn't wrong here, but because the
// type is incomplete, it doesn't provide any alignment guarantees.
_Static_assert(__atomic_is_lock_free(1, &local_int8) == __atomic_is_lock_free(1, incomplete_ptr), "");
- _Static_assert(__atomic_is_lock_free(2, &local_int8) == __atomic_is_lock_free(2, incomplete_ptr), ""); // expected-error {{static assertion expression is not an integral constant expression}}
+ _Static_assert(__atomic_is_lock_free(2, &local_int8) == __atomic_is_lock_free(2, incomplete_ptr), ""); // expected-error {{static_assert expression is not an integral constant expression}}
_Static_assert(__atomic_always_lock_free(1, &local_int8) == __atomic_always_lock_free(1, incomplete_ptr), "");
local_int8; // expected-warning {{expression result unused}}
diff --git a/clang/test/Sema/static-assert.c b/clang/test/Sema/static-assert.c
index 60a45af3d1d2a..3958aeaaa77e7 100644
--- a/clang/test/Sema/static-assert.c
+++ b/clang/test/Sema/static-assert.c
@@ -5,11 +5,11 @@
_Static_assert("foo", "string is nonzero"); // ext-warning {{'_Static_assert' is a C11 extension}}
#ifndef __cplusplus
-// expected-error at -2 {{static assertion expression is not an integral constant expression}}
+// expected-error at -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 assertion 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
@@ -18,7 +18,7 @@ static_assert(1, "1 is nonzero"); // ms-warning {{use of 'static_assert' without
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 assertion 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}}
@@ -31,7 +31,7 @@ _Static_assert(1, invalid); // expected-error {{expected string literal for diag
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 assertion 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}}
@@ -54,7 +54,7 @@ struct A {
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 assertion 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}}
@@ -70,6 +70,3 @@ static_assert(1, "1 is nonzero"); // ok
#undef static_assert
static_assert(1, "1 is nonzero"); // ms-warning {{use of 'static_assert' without}}
#endif
-
-_Static_assert(1 , "") // expected-error {{expected ';' after '_Static_assert'}} \
- // ext-warning {{'_Static_assert' is a C11 extension}}
diff --git a/clang/test/SemaCXX/access-base-class.cpp b/clang/test/SemaCXX/access-base-class.cpp
index 8273f2f378385..2ed40ed536c5f 100644
--- a/clang/test/SemaCXX/access-base-class.cpp
+++ b/clang/test/SemaCXX/access-base-class.cpp
@@ -109,7 +109,7 @@ class b {
template <int>
struct Impossible {
- static_assert(false, ""); // expected-error {{static assertion failed}}
+ static_assert(false, ""); // expected-error {{static_assert failed}}
};
// verify "no member named 'value'" bogus diagnostic is not emitted.
diff --git a/clang/test/SemaCXX/alias-template.cpp b/clang/test/SemaCXX/alias-template.cpp
index c27c79ebd7cb6..0e5d9dae7bb7f 100644
--- a/clang/test/SemaCXX/alias-template.cpp
+++ b/clang/test/SemaCXX/alias-template.cpp
@@ -174,7 +174,7 @@ struct S {
using T = X[J];
using U = T<I>;
};
-static_assert(__is_same(S<3>::U, X[2]), ""); // expected-error {{static assertion failed}}
+static_assert(__is_same(S<3>::U, X[2]), ""); // expected-error {{static_assert failed}}
}
namespace PR39623 {
diff --git a/clang/test/SemaCXX/builtin-is-constant-evaluated.cpp b/clang/test/SemaCXX/builtin-is-constant-evaluated.cpp
index a1c003c85f732..c54d7c1b7aa84 100644
--- a/clang/test/SemaCXX/builtin-is-constant-evaluated.cpp
+++ b/clang/test/SemaCXX/builtin-is-constant-evaluated.cpp
@@ -26,7 +26,7 @@ static_assert(cn == 11);
constexpr int bn = __builtin_is_constant_evaluated() ? dummy : 42; // expected-note {{non-const variable 'dummy' is not allowed}}
const int n2 = __builtin_is_constant_evaluated() ? dummy : 42; // expected-note {{declared here}}
-static_assert(n2 == 42); // expected-error {{static assertion expression is not an integral constant}}
+static_assert(n2 == 42); // expected-error {{static_assert expression is not an integral constant}}
// expected-note at -1 {{initializer of 'n2' is not a constant expression}}
template <bool V, bool Default = std::is_constant_evaluated()>
diff --git a/clang/test/SemaCXX/builtin-std-move.cpp b/clang/test/SemaCXX/builtin-std-move.cpp
index eb2b85e8e7c7f..f220be972a350 100644
--- a/clang/test/SemaCXX/builtin-std-move.cpp
+++ b/clang/test/SemaCXX/builtin-std-move.cpp
@@ -39,7 +39,7 @@ namespace std {
return static_cast<T&&>(x);
}
template<typename T> CONSTEXPR T &&forward(typename remove_reference<T>::type &&x) {
- static_assert(!is_lvalue_reference<T>::value, "should not forward rval as lval"); // expected-error {{static assertion failed}}
+ static_assert(!is_lvalue_reference<T>::value, "should not forward rval as lval"); // expected-error {{static_assert failed}}
return static_cast<T&&>(x);
}
diff --git a/clang/test/SemaCXX/builtins.cpp b/clang/test/SemaCXX/builtins.cpp
index 27f9267bbeea5..50e0fb42b403d 100644
--- a/clang/test/SemaCXX/builtins.cpp
+++ b/clang/test/SemaCXX/builtins.cpp
@@ -47,7 +47,7 @@ namespace function_start {
void a(void) {}
int n;
void *p = __builtin_function_start(n); // expected-error {{argument must be a function}}
-static_assert(__builtin_function_start(a) == a, ""); // expected-error {{static assertion expression is not an integral constant expression}}
+static_assert(__builtin_function_start(a) == a, ""); // expected-error {{static_assert expression is not an integral constant expression}}
} // namespace function_start
void no_ms_builtins() {
diff --git a/clang/test/SemaCXX/complex-folding.cpp b/clang/test/SemaCXX/complex-folding.cpp
index 8c56cf0e5d984..1c2f9c73eb313 100644
--- a/clang/test/SemaCXX/complex-folding.cpp
+++ b/clang/test/SemaCXX/complex-folding.cpp
@@ -3,7 +3,7 @@
// Test the constant folding of builtin complex numbers.
static_assert((0.0 + 0.0j) == (0.0 + 0.0j));
-static_assert((0.0 + 0.0j) != (0.0 + 0.0j)); // expected-error {{static assertion}}
+static_assert((0.0 + 0.0j) != (0.0 + 0.0j)); // expected-error {{static_assert}}
static_assert((0.0 + 0.0j) == 0.0);
static_assert(0.0 == (0.0 + 0.0j));
@@ -14,21 +14,21 @@ static_assert(0.0 != 1.0j);
// Walk around the complex plane stepping between angular
diff erences and
// equality.
-static_assert((1.0 + 0.0j) == (0.0 + 0.0j)); // expected-error {{static assertion}}
+static_assert((1.0 + 0.0j) == (0.0 + 0.0j)); // expected-error {{static_assert}}
static_assert((1.0 + 0.0j) == (1.0 + 0.0j));
-static_assert((1.0 + 1.0j) == (1.0 + 0.0j)); // expected-error {{static assertion}}
+static_assert((1.0 + 1.0j) == (1.0 + 0.0j)); // expected-error {{static_assert}}
static_assert((1.0 + 1.0j) == (1.0 + 1.0j));
-static_assert((0.0 + 1.0j) == (1.0 + 1.0j)); // expected-error {{static assertion}}
+static_assert((0.0 + 1.0j) == (1.0 + 1.0j)); // expected-error {{static_assert}}
static_assert((0.0 + 1.0j) == (0.0 + 1.0j));
-static_assert((-1.0 + 1.0j) == (0.0 + 1.0j)); // expected-error {{static assertion}}
+static_assert((-1.0 + 1.0j) == (0.0 + 1.0j)); // expected-error {{static_assert}}
static_assert((-1.0 + 1.0j) == (-1.0 + 1.0j));
-static_assert((-1.0 + 0.0j) == (-1.0 + 1.0j)); // expected-error {{static assertion}}
+static_assert((-1.0 + 0.0j) == (-1.0 + 1.0j)); // expected-error {{static_assert}}
static_assert((-1.0 + 0.0j) == (-1.0 + 0.0j));
-static_assert((-1.0 - 1.0j) == (-1.0 + 0.0j)); // expected-error {{static assertion}}
+static_assert((-1.0 - 1.0j) == (-1.0 + 0.0j)); // expected-error {{static_assert}}
static_assert((-1.0 - 1.0j) == (-1.0 - 1.0j));
-static_assert((0.0 - 1.0j) == (-1.0 - 1.0j)); // expected-error {{static assertion}}
+static_assert((0.0 - 1.0j) == (-1.0 - 1.0j)); // expected-error {{static_assert}}
static_assert((0.0 - 1.0j) == (0.0 - 1.0j));
-static_assert((1.0 - 1.0j) == (0.0 - 1.0j)); // expected-error {{static assertion}}
+static_assert((1.0 - 1.0j) == (0.0 - 1.0j)); // expected-error {{static_assert}}
static_assert((1.0 - 1.0j) == (1.0 - 1.0j));
// Test basic mathematical folding of both complex and real operands.
diff --git a/clang/test/SemaCXX/constant-expression-cxx11.cpp b/clang/test/SemaCXX/constant-expression-cxx11.cpp
index aaca34cd65839..b03cb7696aae5 100644
--- a/clang/test/SemaCXX/constant-expression-cxx11.cpp
+++ b/clang/test/SemaCXX/constant-expression-cxx11.cpp
@@ -580,7 +580,7 @@ constexpr int fail(const int &p) {
return (&p)[64]; // expected-note {{cannot refer to element 64 of array of 2 elements}}
}
static_assert(fail(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2)) == 11, ""); // \
-expected-error {{static assertion expression is not an integral constant expression}} \
+expected-error {{static_assert expression is not an integral constant expression}} \
expected-note {{in call to 'fail(zs[1][0][1][0])'}}
constexpr int arr[40] = { 1, 2, 3, [8] = 4 };
@@ -1596,11 +1596,11 @@ namespace CompoundLiteral {
// Matching GCC, file-scope array compound literals initialized by constants
// are lifetime-extended.
constexpr int *p = (int*)(int[1]){3}; // expected-warning {{C99}}
- static_assert(*p == 3, ""); // expected-error {{static assertion expression is not an integral constant expression}}
+ static_assert(*p == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
// expected-note at -1 {{subexpression not valid}}
// expected-note at -3 {{declared here}}
static_assert((int[2]){1, 2}[1] == 2, ""); // expected-warning {{C99}}
- // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-error at -1 {{static_assert expression is not an integral constant expression}}
// expected-note at -2 {{subexpression not valid}}
// expected-note at -3 {{declared here}}
@@ -1912,12 +1912,12 @@ namespace VirtualFromBase {
static_assert(p->f() == sizeof(X<S1>), "");
// cxx11-error at -1 {{not an integral constant expression}}
// cxx11-note at -2 {{call to virtual function}}
- // cxx20_2b-error at -3 {{static assertion failed}}
+ // cxx20_2b-error at -3 {{static_assert failed}}
// Non-virtual f(), OK.
constexpr X<X<S2>> xxs2;
constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2);
- static_assert(q->f() == sizeof(S2), ""); // cxx20_2b-error {{static assertion failed}}
+ static_assert(q->f() == sizeof(S2), ""); // cxx20_2b-error {{static_assert failed}}
}
namespace ConstexprConstructorRecovery {
diff --git a/clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp b/clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
index 36ced2e298c69..cb1812905d3d2 100644
--- a/clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
+++ b/clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
@@ -446,7 +446,7 @@ constexpr bool f(bool read_uninit) {
}
static_assert(f(/*read_uninit=*/false), "");
-static_assert(f(/*read_uninit=*/true), ""); // expected-error{{static assertion expression is not an integral constant expression}} expected-note{{in call to 'f(true)'}}
+static_assert(f(/*read_uninit=*/true), ""); // expected-error{{static_assert expression is not an integral constant expression}} expected-note{{in call to 'f(true)'}}
constexpr bytes ld539 = {
0x0, 0x0, 0x0, 0x0,
diff --git a/clang/test/SemaCXX/constexpr-function-recovery-crash.cpp b/clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
index 07bc5e57ae13c..77e22a911cb49 100644
--- a/clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
+++ b/clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
@@ -68,7 +68,7 @@ constexpr int test9(int x) {
}
constexpr int test10() { return undef(); } // expected-error {{use of undeclared identifier 'undef'}}
-static_assert(test10() <= 1, "should not crash"); // expected-error {{static assertion expression is not an integral constant expression}}
+static_assert(test10() <= 1, "should not crash"); // expected-error {{static_assert expression is not an integral constant expression}}
struct X {} array[] = {undef()}; // expected-error {{use of undeclared identifier 'undef'}}
constexpr void test11() {
diff --git a/clang/test/SemaCXX/coroutines-exp-namespace.cpp b/clang/test/SemaCXX/coroutines-exp-namespace.cpp
index 48f0dd0126345..534d47dfa776e 100644
--- a/clang/test/SemaCXX/coroutines-exp-namespace.cpp
+++ b/clang/test/SemaCXX/coroutines-exp-namespace.cpp
@@ -1109,8 +1109,8 @@ struct TestType {
CoroMemberTag test_asserts(int *) const {
auto TC = co_yield 0;
- static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static assertion failed}}
- static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static assertion failed}}
+ static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
+ static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
static_assert(TC.MatchesArgs<const TestType &, int *>, "");
}
@@ -1201,8 +1201,8 @@ struct DepTestType {
CoroMemberTag test_asserts(int *) const {
auto TC = co_yield 0;
- static_assert(TC.template MatchesArgs<const DepTestType &>, ""); // expected-error {{static assertion failed}}
- static_assert(TC.template MatchesArgs<>, ""); // expected-error {{static assertion failed}}
+ static_assert(TC.template MatchesArgs<const DepTestType &>, ""); // expected-error {{static_assert failed}}
+ static_assert(TC.template MatchesArgs<>, ""); // expected-error {{static_assert failed}}
static_assert(TC.template MatchesArgs<const DepTestType &, int *>, "");
}
@@ -1265,7 +1265,7 @@ struct DepTestType {
static_assert(!TCT::MatchesArgs<DepTestType *>, "");
// Ensure diagnostics are actually being generated here
- static_assert(TCT::MatchesArgs<int>, ""); // expected-error {{static assertion failed}}
+ static_assert(TCT::MatchesArgs<int>, ""); // expected-error {{static_assert failed}}
}
static CoroMemberTag test_static(volatile void *const, char &&) {
diff --git a/clang/test/SemaCXX/coroutines.cpp b/clang/test/SemaCXX/coroutines.cpp
index b646810809a06..5d6ef7f73cfd7 100644
--- a/clang/test/SemaCXX/coroutines.cpp
+++ b/clang/test/SemaCXX/coroutines.cpp
@@ -1130,8 +1130,8 @@ struct TestType {
CoroMemberTag test_asserts(int *) const {
auto TC = co_yield 0;
- static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static assertion failed}}
- static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static assertion failed}}
+ static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
+ static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
static_assert(TC.MatchesArgs<const TestType &, int *>, "");
}
@@ -1222,8 +1222,8 @@ struct DepTestType {
CoroMemberTag test_asserts(int *) const {
auto TC = co_yield 0;
- static_assert(TC.template MatchesArgs<const DepTestType &>, ""); // expected-error {{static assertion failed}}
- static_assert(TC.template MatchesArgs<>, ""); // expected-error {{static assertion failed}}
+ static_assert(TC.template MatchesArgs<const DepTestType &>, ""); // expected-error {{static_assert failed}}
+ static_assert(TC.template MatchesArgs<>, ""); // expected-error {{static_assert failed}}
static_assert(TC.template MatchesArgs<const DepTestType &, int *>, "");
}
@@ -1286,7 +1286,7 @@ struct DepTestType {
static_assert(!TCT::MatchesArgs<DepTestType *>, "");
// Ensure diagnostics are actually being generated here
- static_assert(TCT::MatchesArgs<int>, ""); // expected-error {{static assertion failed}}
+ static_assert(TCT::MatchesArgs<int>, ""); // expected-error {{static_assert failed}}
}
static CoroMemberTag test_static(volatile void *const, char &&) {
diff --git a/clang/test/SemaCXX/cxx2a-template-lambdas.cpp b/clang/test/SemaCXX/cxx2a-template-lambdas.cpp
index 65baf29718f06..6d22be44d836d 100644
--- a/clang/test/SemaCXX/cxx2a-template-lambdas.cpp
+++ b/clang/test/SemaCXX/cxx2a-template-lambdas.cpp
@@ -11,19 +11,19 @@ struct DummyTemplate { };
void func() {
auto L0 = []<typename T>(T arg) {
- static_assert(is_same<T, int>); // expected-error {{static assertion failed}}
+ static_assert(is_same<T, int>); // expected-error {{static_assert failed}}
};
L0(0);
L0(0.0); // expected-note {{in instantiation}}
auto L1 = []<int I> {
- static_assert(I == 5); // expected-error {{static assertion failed}}
+ static_assert(I == 5); // expected-error {{static_assert failed}}
};
L1.operator()<5>();
L1.operator()<6>(); // expected-note {{in instantiation}}
auto L2 = []<template<typename> class T, class U>(T<U> &&arg) {
- static_assert(is_same<T<U>, DummyTemplate<float>>); // // expected-error {{static assertion failed}}
+ static_assert(is_same<T<U>, DummyTemplate<float>>); // // expected-error {{static_assert failed}}
};
L2(DummyTemplate<float>());
L2(DummyTemplate<double>()); // expected-note {{in instantiation}}
diff --git a/clang/test/SemaCXX/cxx98-compat.cpp b/clang/test/SemaCXX/cxx98-compat.cpp
index f12d7c2d3f051..581b620c70727 100644
--- a/clang/test/SemaCXX/cxx98-compat.cpp
+++ b/clang/test/SemaCXX/cxx98-compat.cpp
@@ -152,7 +152,7 @@ __decltype(const_expr) decl_type2 = 0; // ok
void no_except() noexcept; // expected-warning {{noexcept specifications are incompatible with C++98}}
bool no_except_expr = noexcept(1 + 1); // expected-warning {{noexcept expressions are incompatible with C++98}}
void *null = nullptr; // expected-warning {{'nullptr' is incompatible with C++98}}
-static_assert(true, "!"); // expected-warning {{'static_assert' declarations are incompatible with C++98}}
+static_assert(true, "!"); // expected-warning {{static_assert declarations are incompatible with C++98}}
struct InhCtorBase {
InhCtorBase(int);
diff --git a/clang/test/SemaCXX/delete-and-function-templates.cpp b/clang/test/SemaCXX/delete-and-function-templates.cpp
index 0232b5bc6f12f..22e95cb7937a4 100644
--- a/clang/test/SemaCXX/delete-and-function-templates.cpp
+++ b/clang/test/SemaCXX/delete-and-function-templates.cpp
@@ -12,7 +12,7 @@ namespace ns1 {
template<class T> double f(T) = delete; //expected-note{{candidate}}
char f(...); //expected-note{{candidate}}
-static_assert(is_same<decltype(f(3)),char>::value, ""); //expected-error{{call to deleted function}} expected-error{{static assertion failed}}
+static_assert(is_same<decltype(f(3)),char>::value, ""); //expected-error{{call to deleted function}} expected-error{{static_assert failed}}
template<class T> decltype(f(T{})) g(T); // this one sfinae's out.
template<class T> int *g(T);
diff --git a/clang/test/SemaCXX/int-ptr-cast-SFINAE.cpp b/clang/test/SemaCXX/int-ptr-cast-SFINAE.cpp
index 736c09d68b523..a3a38d42818b7 100644
--- a/clang/test/SemaCXX/int-ptr-cast-SFINAE.cpp
+++ b/clang/test/SemaCXX/int-ptr-cast-SFINAE.cpp
@@ -19,4 +19,4 @@ 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 assertion 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}}
diff --git a/clang/test/SemaCXX/recovery-expr-type.cpp b/clang/test/SemaCXX/recovery-expr-type.cpp
index 920cf35fee153..3db11466529e1 100644
--- a/clang/test/SemaCXX/recovery-expr-type.cpp
+++ b/clang/test/SemaCXX/recovery-expr-type.cpp
@@ -149,7 +149,7 @@ enum Circular { // expected-note {{not complete until the closing '}
Circular_A = Circular(1), // expected-error {{'test13::Circular' is an incomplete type}}
};
// Enumerators can be evaluated (they evaluate as zero, but we don't care).
-static_assert(Circular_A == 0 && Circular_A != 0, ""); // expected-error {{static assertion failed}}
+static_assert(Circular_A == 0 && Circular_A != 0, ""); // expected-error {{static_assert failed}}
}
namespace test14 {
diff --git a/clang/test/SemaCXX/sizeless-1.cpp b/clang/test/SemaCXX/sizeless-1.cpp
index 80e74db49c0f4..5986be91233f2 100644
--- a/clang/test/SemaCXX/sizeless-1.cpp
+++ b/clang/test/SemaCXX/sizeless-1.cpp
@@ -78,7 +78,7 @@ void func(int sel) {
// Using pointers to sizeless data isn't wrong here, but because the
// type is incomplete, it doesn't provide any alignment guarantees.
_Static_assert(__atomic_is_lock_free(1, &local_int8) == __atomic_is_lock_free(1, incomplete_ptr), "");
- _Static_assert(__atomic_is_lock_free(2, &local_int8) == __atomic_is_lock_free(2, incomplete_ptr), ""); // expected-error {{static assertion expression is not an integral constant expression}}
+ _Static_assert(__atomic_is_lock_free(2, &local_int8) == __atomic_is_lock_free(2, incomplete_ptr), ""); // expected-error {{static_assert expression is not an integral constant expression}}
_Static_assert(__atomic_always_lock_free(1, &local_int8) == __atomic_always_lock_free(1, incomplete_ptr), "");
local_int8; // expected-warning {{expression result unused}}
diff --git a/clang/test/SemaCXX/static-assert-cxx17.cpp b/clang/test/SemaCXX/static-assert-cxx17.cpp
index 888117d9f27c7..ce9826795d5de 100644
--- a/clang/test/SemaCXX/static-assert-cxx17.cpp
+++ b/clang/test/SemaCXX/static-assert-cxx17.cpp
@@ -22,7 +22,7 @@ inline constexpr bool constexpr_return_false() {
template <typename U, typename V>
void foo() {
static_assert(S1<U, V>::value);
- // expected-error at -1{{static assertion failed due to requirement 'S1<int, float>::value'}}
+ // expected-error at -1{{static_assert failed due to requirement 'S1<int, float>::value'}}
}
template void foo<int, float>();
// expected-note at -1{{in instantiation of function template specialization 'foo<int, float>' requested here}}
@@ -30,7 +30,7 @@ template void foo<int, float>();
template <typename U, typename V>
void foo2() {
static_assert(global_inline_var<U, V>);
- // expected-error at -1{{static assertion failed due to requirement 'global_inline_var<int, float>'}}
+ // expected-error at -1{{static_assert failed due to requirement 'global_inline_var<int, float>'}}
}
template void foo2<int, float>();
// expected-note at -1{{in instantiation of function template specialization 'foo2<int, float>' requested here}}
@@ -38,7 +38,7 @@ template void foo2<int, float>();
template <typename T, typename U, typename V>
void foo3() {
static_assert(T::template var<U, V>);
- // expected-error at -1{{static assertion failed due to requirement 'S2<long>::var<int, float>'}}
+ // expected-error at -1{{static_assert failed due to requirement 'S2<long>::var<int, float>'}}
}
template void foo3<S2<long>, int, float>();
// expected-note at -1{{in instantiation of function template specialization 'foo3<S2<long>, int, float>' requested here}}
@@ -46,7 +46,7 @@ template void foo3<S2<long>, int, float>();
template <typename T>
void foo4() {
static_assert(S1<T[sizeof(T)], int[4]>::value, "");
- // expected-error at -1{{static assertion failed due to requirement 'S1<float[4], int[4]>::value'}}
+ // expected-error at -1{{static_assert failed due to requirement 'S1<float[4], int[4]>::value'}}
};
template void foo4<float>();
// expected-note at -1{{in instantiation of function template specialization 'foo4<float>' requested here}}
@@ -55,7 +55,7 @@ template void foo4<float>();
template <typename U, typename V>
void foo5() {
static_assert(!!(global_inline_var<U, V>));
- // expected-error at -1{{static assertion failed due to requirement '!!(global_inline_var<int, float>)'}}
+ // expected-error at -1{{static_assert failed due to requirement '!!(global_inline_var<int, float>)'}}
}
template void foo5<int, float>();
// expected-note at -1{{in instantiation of function template specialization 'foo5<int, float>' requested here}}
@@ -76,29 +76,29 @@ struct X {
template <class T>
void foo6() {
static_assert(X<typename T::T>());
- // expected-error at -1{{static assertion failed due to requirement 'X<int>()'}}
+ // expected-error at -1{{static_assert failed due to requirement 'X<int>()'}}
static_assert(X<typename T::T>{});
- // expected-error at -1{{static assertion failed due to requirement 'X<int>{}'}}
+ // expected-error at -1{{static_assert failed due to requirement 'X<int>{}'}}
static_assert(X<typename T::T>{1, 2});
- // expected-error at -1{{static assertion failed due to requirement 'X<int>{1, 2}'}}
+ // expected-error at -1{{static_assert failed due to requirement 'X<int>{1, 2}'}}
static_assert(X<typename T::T>({1, 2}));
- // expected-error at -1{{static assertion failed due to requirement 'X<int>({1, 2})'}}
+ // expected-error at -1{{static_assert failed due to requirement 'X<int>({1, 2})'}}
static_assert(typename T::T{0});
- // expected-error at -1{{static assertion failed due to requirement 'int{0}'}}
+ // expected-error at -1{{static_assert failed due to requirement 'int{0}'}}
static_assert(typename T::T(0));
- // expected-error at -1{{static assertion failed due to requirement 'int(0)'}}
+ // expected-error at -1{{static_assert failed due to requirement 'int(0)'}}
static_assert(sizeof(X<typename T::T>) == 0);
- // expected-error at -1{{static assertion failed due to requirement 'sizeof(X<int>) == 0'}}
+ // expected-error at -1{{static_assert failed due to requirement 'sizeof(X<int>) == 0'}}
static_assert((const X<typename T::T> *)nullptr);
- // expected-error at -1{{static assertion failed due to requirement '(const X<int> *)nullptr'}}
+ // expected-error at -1{{static_assert failed due to requirement '(const X<int> *)nullptr'}}
static_assert(static_cast<const X<typename T::T> *>(nullptr));
- // expected-error at -1{{static assertion failed due to requirement 'static_cast<const X<int> *>(nullptr)'}}
+ // expected-error at -1{{static_assert failed due to requirement 'static_cast<const X<int> *>(nullptr)'}}
static_assert((const X<typename T::T>[]){} == nullptr);
- // expected-error at -1{{static assertion failed due to requirement '(const X<int>[0]){} == nullptr'}}
+ // expected-error at -1{{static_assert failed due to requirement '(const X<int>[0]){} == nullptr'}}
static_assert(sizeof(X<decltype(X<typename T::T>().X<typename T::T>::~X())>) == 0);
- // expected-error at -1{{static assertion failed due to requirement 'sizeof(X<void>) == 0'}}
+ // expected-error at -1{{static_assert failed due to requirement 'sizeof(X<void>) == 0'}}
static_assert(constexpr_return_false<typename T::T, typename T::U>());
- // expected-error at -1{{static assertion failed due to requirement 'constexpr_return_false<int, float>()'}}
+ // expected-error at -1{{static_assert failed due to requirement 'constexpr_return_false<int, float>()'}}
}
template void foo6<ExampleTypes>();
// expected-note at -1{{in instantiation of function template specialization 'foo6<ExampleTypes>' requested here}}
diff --git a/clang/test/SemaCXX/static-assert.cpp b/clang/test/SemaCXX/static-assert.cpp
index 7e1ffb325a1b3..2ac0dfdea9eae 100644
--- a/clang/test/SemaCXX/static-assert.cpp
+++ b/clang/test/SemaCXX/static-assert.cpp
@@ -2,61 +2,61 @@
int f(); // expected-note {{declared here}}
-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(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 assertion 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 assertion 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 assertion 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 assertion 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 assertion 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 assertion failed: L"\xFFFFFFFF"}}
-static_assert(false, u"\U000317FF"); // expected-error {{static assertion 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 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"}}
+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 at -3 {{static assertion failed: a\n\tb\nc\n}}
+)"); // expected-error at -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 at -1 {{static assertion 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 at -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 assertion failed: abcdefgh}}
+static_assert(false, "\u200Eabc\u200Fdef\u200Fgh"); // expected-error {{static_assert failed: abcdefgh}}
//! Contains ZWJ/regional indicators
-static_assert(false, "🏳️🌈 🏴 🇪🇺"); // expected-error {{static assertion 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 assertion failed}}
+ static_assert(false, ""); // expected-error {{static_assert failed}}
};
AlwaysFails<int> alwaysFails;
template<typename T> struct StaticAssertProtected {
- static_assert(__is_literal(T), ""); // expected-error {{static assertion failed}}
+ static_assert(__is_literal(T), ""); // expected-error {{static_assert failed}}
static constexpr T t = {}; // no error here
};
struct X { ~X(); };
@@ -81,7 +81,7 @@ 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 assertion 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 {
@@ -125,29 +125,29 @@ struct ExampleTypes {
};
static_assert(std::is_same<ExampleTypes::T, ExampleTypes::U>::value, "message");
-// expected-error at -1{{static assertion failed due to requirement 'std::is_same<int, float>::value': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement 'std::is_const<int>::value': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement '!std::is_const<const int>::value': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement '!(std::is_const<const int>::value)': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement 'std::is_const<const int>::value == false': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement '!(std::is_const<const int>::value == true)': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement 'std::is_const<int>()': message}}
+// expected-error at -1{{static_assert failed due to requirement 'std::is_const<int>()': message}}
static_assert(!(std::is_const<const ExampleTypes::T>()()), "message");
-// expected-error at -1{{static assertion failed due to requirement '!(std::is_const<const int>()())': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement 'std::is_same<std::is_const<const int>, int>::value': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement 'std::is_const<int>::value': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement 'std::is_const<int>::value': message}}
+// expected-error at -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 at -1{{static assertion failed due to requirement 'std::is_const<ExampleTypes>::value': message}}
+// expected-error at -1{{static_assert failed due to requirement 'std::is_const<ExampleTypes>::value': message}}
struct BI_tag {};
struct RAI_tag : BI_tag {};
@@ -160,7 +160,7 @@ struct MyContainer {
template <class Container>
void foo() {
static_assert(std::is_same<RAI_tag, typename Container::iterator::tag>::value, "message");
- // expected-error at -1{{static assertion failed due to requirement 'std::is_same<RAI_tag, BI_tag>::value': message}}
+ // expected-error at -1{{static_assert failed due to requirement 'std::is_same<RAI_tag, BI_tag>::value': message}}
}
template void foo<MyContainer>();
// expected-note at -1{{in instantiation of function template specialization 'foo<MyContainer>' requested here}}
@@ -178,7 +178,7 @@ struct NestedTemplates1 {
template <typename T, typename U, int a>
void foo2() {
static_assert(::ns::NestedTemplates1<T, a>::NestedTemplates2::template NestedTemplates3<U>::value, "message");
- // expected-error at -1{{static assertion failed due to requirement '::ns::NestedTemplates1<int, 3>::NestedTemplates2::NestedTemplates3<float>::value': message}}
+ // expected-error at -1{{static_assert failed due to requirement '::ns::NestedTemplates1<int, 3>::NestedTemplates2::NestedTemplates3<float>::value': message}}
}
template void foo2<int, float, 3>();
// expected-note at -1{{in instantiation of function template specialization 'foo2<int, float, 3>' requested here}}
@@ -186,9 +186,9 @@ template void foo2<int, float, 3>();
template <class T>
void foo3(T t) {
static_assert(std::is_const<T>::value, "message");
- // expected-error-re at -1{{static assertion failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value': message}}
+ // expected-error-re at -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 at -1{{static assertion failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value': message}}
+ // expected-error-re at -1{{static_assert failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value': message}}
}
void callFoo3() {
foo3([]() {});
@@ -206,12 +206,10 @@ void callFoo4() { foo4(42); }
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 assertion failed}}
+static_assert(p, "message"); // expected-error {{static_assert 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'}}
-
-static_assert(1 , "") // expected-error {{expected ';' after 'static_assert'}}
diff --git a/clang/test/SemaCXX/using-decl-templates.cpp b/clang/test/SemaCXX/using-decl-templates.cpp
index 73d9bc3e774cb..d825971954ec2 100644
--- a/clang/test/SemaCXX/using-decl-templates.cpp
+++ b/clang/test/SemaCXX/using-decl-templates.cpp
@@ -95,7 +95,7 @@ namespace aliastemplateinst {
namespace DontDiagnoseInvalidTest {
template <bool Value> struct Base {
- static_assert(Value, ""); // expected-error {{static assertion failed}}
+ static_assert(Value, ""); // expected-error {{static_assert failed}}
};
struct Derived : Base<false> { // expected-note {{requested here}}
using Base<false>::Base; // OK. Don't diagnose that 'Base' isn't a base class of Derived.
diff --git a/clang/test/SemaCXX/weak-init.cpp b/clang/test/SemaCXX/weak-init.cpp
index a88d32bdca5a1..c040330bb274a 100644
--- a/clang/test/SemaCXX/weak-init.cpp
+++ b/clang/test/SemaCXX/weak-init.cpp
@@ -2,7 +2,7 @@
extern const int W1 __attribute__((weak)) = 10; // expected-note {{declared here}}
-static_assert(W1 == 10, ""); // expected-error {{static assertion expression is not an integral constant expression}}
+static_assert(W1 == 10, ""); // expected-error {{static_assert expression is not an integral constant expression}}
// expected-note at -1 {{initializer of weak variable 'W1' is not considered constant because it may be
diff erent at runtime}}
extern const int W2 __attribute__((weak)) = 20;
diff --git a/clang/test/SemaTemplate/instantiate-var-template.cpp b/clang/test/SemaTemplate/instantiate-var-template.cpp
index 89c4a65249cc2..8037a4865a8bf 100644
--- a/clang/test/SemaTemplate/instantiate-var-template.cpp
+++ b/clang/test/SemaTemplate/instantiate-var-template.cpp
@@ -31,7 +31,7 @@ namespace InstantiationDependent {
static_assert(b<char> == 1, ""); // expected-note {{in instantiation of}} expected-error {{not an integral constant}}
template<typename T> void f() {
- static_assert(a<sizeof(sizeof(f(T())))> == 0, ""); // expected-error {{static assertion failed due to requirement 'a<sizeof (sizeof (f(type-parameter-0-0())))> == 0'}}
+ static_assert(a<sizeof(sizeof(f(T())))> == 0, ""); // expected-error {{static_assert failed due to requirement 'a<sizeof (sizeof (f(type-parameter-0-0())))> == 0'}}
}
}
diff --git a/clang/test/SemaTemplate/pr52909.cpp b/clang/test/SemaTemplate/pr52909.cpp
index b06c97c3cb67d..a17ede44fce08 100644
--- a/clang/test/SemaTemplate/pr52909.cpp
+++ b/clang/test/SemaTemplate/pr52909.cpp
@@ -15,7 +15,7 @@ concept Beginable = requires (T t) {
// expected-note at -1 {{because 't.begin' would be invalid: reference to non-static member function must be called}}
};
-static_assert(Beginable<A>); // expected-error {{static assertion failed}}
+static_assert(Beginable<A>); // expected-error {{static_assert failed}}
// expected-note at -1 {{does not satisfy 'Beginable'}}
} // namespace PR52905
@@ -48,7 +48,7 @@ struct A {
static void begin(double);
};
-static_assert(C<A>); // expected-error {{static assertion failed}}
+static_assert(C<A>); // expected-error {{static_assert failed}}
// expected-note at -1 {{because 'PR52909b::A' does not satisfy 'C'}}
} // namespace PR52909b
@@ -65,7 +65,7 @@ struct S {
int *f() const;
};
-static_assert(C<S>); // expected-error {{static assertion failed}}
+static_assert(C<S>); // expected-error {{static_assert failed}}
// expected-note at -1 {{because 'PR53075::S' does not satisfy 'C'}}
} // namespace PR53075
diff --git a/clang/test/SemaTemplate/pr52970.cpp b/clang/test/SemaTemplate/pr52970.cpp
index e7d5fc601221f..7585fba412081 100644
--- a/clang/test/SemaTemplate/pr52970.cpp
+++ b/clang/test/SemaTemplate/pr52970.cpp
@@ -32,7 +32,7 @@ concept C = requires(T t) { t.a.b; };
static_assert(C<Good>);
static_assert(!C<Bad>);
-static_assert(C<Bad>); // cxx20-error {{static assertion failed}}
+static_assert(C<Bad>); // cxx20-error {{static_assert failed}}
// cxx20-note at -1 {{because 'DotFollowingFunctionName::Bad' does not satisfy 'C'}}
#endif
} // namespace DotFollowingFunctionName
@@ -57,7 +57,7 @@ concept C = requires(T t) { t.begin(); };
static_assert(C<Good>);
static_assert(!C<Bad>);
-static_assert(C<Bad>); // cxx20-error {{static assertion failed}}
+static_assert(C<Bad>); // cxx20-error {{static_assert failed}}
// cxx20-note at -1 {{because 'DotFollowingPointer::Bad' (aka 'Holder<Incomplete> *') does not satisfy 'C'}}
#endif
} // namespace DotFollowingPointer
diff --git a/clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp b/clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp
index feb9bcde92735..ad9cfc7cdd9de 100644
--- a/clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp
+++ b/clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp
@@ -184,7 +184,7 @@ namespace TemplateSpecializations {
namespace Diags {
struct A { int n, m; };
- template<A a> struct X { static_assert(a.n == a.m); }; // expected-error {{static assertion failed due to requirement 'Diags::A{1, 2}.n == Diags::A{1, 2}.m'}}
+ template<A a> struct X { static_assert(a.n == a.m); }; // expected-error {{static_assert failed due to requirement 'Diags::A{1, 2}.n == Diags::A{1, 2}.m'}}
template struct X<A{1, 2}>; // expected-note {{in instantiation of template class 'Diags::X<{1, 2}>' requested here}}
}
More information about the cfe-commits
mailing list