Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-11-30 17:21:10 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Rewording "static_assert" diagnostics

Browse Source 
This patch rewords the static assert diagnostic output. Failing a
_Static_assert in C should not report that static_assert failed. This
changes the wording to be more like GCC and uses "static assertion"
when possible instead of hard coding the name. This also changes some
instances of 'static_assert' to instead be based on the token in the
source code.

Differential Revision: https://reviews.llvm.org/D129048
This commit is contained in:
Muhammad Usman Shahid 2022-07-14 07:44:51 -04:00 committed by Aaron Ballman
parent fc6092fd4d
commit b7e77ff25f
43 changed files with 148 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
clang/include/clang/Basic/DiagnosticParseKinds.td
View File

@ -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 static_assert">;
"expected ';' after '%0'">;
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 "

6
clang/include/clang/Basic/DiagnosticSemaKinds.td
View File

@ -1526,12 +1526,12 @@ def err_messaging_class_with_direct_method : Error<
// 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">,

2
clang/include/clang/Parse/Parser.h
View File

@ -1043,7 +1043,7 @@ private:
/// 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);
bool ExpectAndConsumeSemi(unsigned DiagID , StringRef TokenUsed = "");
/// The kind of extra semi diagnostic to emit.
enum ExtraSemiKind {

7
clang/lib/Parse/ParseDeclCXX.cpp
View File

@ -926,6 +926,9 @@ 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)) {
@ -989,7 +992,9 @@ Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){
T.consumeClose();
DeclEnd = Tok.getLocation();
ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert);
// Passing the token used to the error message.
ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert,
SavedTok.getName());
return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc,
AssertExpr.get(),

4
clang/lib/Parse/Parser.cpp
View File

@ -153,7 +153,7 @@ bool Parser::ExpectAndConsume(tok::TokenKind ExpectedTok, unsigned DiagID,
return true;
}
bool Parser::ExpectAndConsumeSemi(unsigned DiagID) {
bool Parser::ExpectAndConsumeSemi(unsigned DiagID, StringRef TokenUsed) {
if (TryConsumeToken(tok::semi))
return false;
@ -172,7 +172,7 @@ bool Parser::ExpectAndConsumeSemi(unsigned DiagID) {
return false;
}
return ExpectAndConsume(tok::semi, DiagID);
return ExpectAndConsume(tok::semi, DiagID , TokenUsed);
}
void Parser::ConsumeExtraSemi(ExtraSemiKind Kind, DeclSpec::TST TST) {

2
clang/test/C/drs/dr0xx.c
View File

@ -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 different than the resolution to DR029,
* so it's not clear there's value in implementing this DR.
*/
_Static_assert(__builtin_types_compatible_p(struct S { int a; }, union U { int a; }), "fail"); /* expected-error {{static_assert failed due to requirement '__builtin_types_compatible_p(struct S, union U)': fail}} */
_Static_assert(__builtin_types_compatible_p(struct S { int a; }, union U { int a; }), "fail"); /* expected-error {{static assertion failed due to requirement '__builtin_types_compatible_p(struct S, union U)': fail}} */
/* WG14 DR031: yes
* Can constant expressions overflow?

2
clang/test/CXX/dcl.dcl/p4-0x.cpp
View File

@ -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_assert failed: L"\024hi!\""}}
static_assert(false, L"\x14hi" "!" R"x(")x"); // expected-error {{static assertion failed: L"\024hi!\""}}

2
clang/test/CXX/drs/dr19xx.cpp
View File

@ -83,7 +83,7 @@ namespace dr1940 { // dr1940: yes
#if __cplusplus >= 201103L
static union {
static_assert(true, ""); // ok
static_assert(false, ""); // expected-error {{static_assert failed}}
static_assert(false, ""); // expected-error {{static assertion failed}}
int not_empty;
};
#endif

6
clang/test/CXX/expr/expr.prim/expr.prim.id/p3.cpp
View File

@ -161,10 +161,10 @@ concept Large = sizeof(T) > 100;
struct small { };
static_assert(Large<small>);
// expected-error@-1 {{static_assert failed}}
// expected-error@-1 {{static assertion failed}}
// expected-note@-2 {{because 'small' does not satisfy 'Large'}}
static_assert(Large<small>, "small isn't large");
// expected-error@-1 {{static_assert failed: small isn't large}}
// expected-error@-1 {{static assertion failed: small isn't large}}
// expected-note@-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@-1{{because substituted constraint expression is ill-formed: 'f' is a private member of 'T4'}}
static_assert(AccessPrivate<T4>);
// expected-error@-1{{static_assert failed}}
// expected-error@-1{{static assertion failed}}
// expected-note@-2{{because 'T4' does not satisfy 'AccessPrivate'}}
template<typename T, typename U>

4
clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp
View File

@ -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_assert failed}}
}
static_assert(C2<int>); // expected-note{{because 'int' does not satisfy 'C2'}} expected-error{{static assertion failed}}
}

4
clang/test/CXX/temp/temp.constr/temp.constr.constr/partial-specializations.cpp
View File

@ -79,6 +79,6 @@ namespace variable_templates
// expected-note@-1{{while checking constraint satisfaction for variable template partial specialization 'v1<int>' required here}}
// expected-note@-2{{during template argument deduction for variable template partial specialization 'v1<T *>' [with T = int *]}}
// expected-note@-3{{during template argument deduction for variable template partial specialization 'v1<T **>' [with T = int]}}
// expected-error@-4{{static_assert failed due to requirement 'v1<int **>'}}
// expected-error@-4{{static assertion failed due to requirement 'v1<int **>'}}
}
}

2
clang/test/PCH/cxx-static_assert.cpp
View File

@ -17,7 +17,7 @@ template<int N> struct T {
#else
// expected-error@15 {{static_assert failed due to requirement '1 == 2': N is not 2!}}
// expected-error@15 {{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;

2
clang/test/PCH/cxx-templates.cpp
View File

@ -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_assert failed}}
static_assert(A<int>().f() == 1); // expected-error {{static assertion failed}}
#endif
}

4
clang/test/Parser/objc-static-assert.m
View File

@ -15,7 +15,7 @@
@interface A {
int a;
_Static_assert(1, "");
_Static_assert(0, ""); // expected-error {{static_assert failed}}
_Static_assert(0, ""); // expected-error {{static assertion 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 @@ struct S {
@interface A {
int a;
_Static_assert(1, "");
_Static_assert(0, ""); // expected-error {{static_assert failed}}
_Static_assert(0, ""); // expected-error {{static assertion failed}}
}
_Static_assert(1, "");

14
clang/test/Parser/objc-static-assert.mm
View File

@ -21,12 +21,12 @@
static_assert(1, "");
_Static_assert(1, "");
static_assert(0, ""); // expected-error {{static_assert failed}}
_Static_assert(0, ""); // expected-error {{static_assert failed}}
static_assert(0, ""); // expected-error {{static assertion failed}}
_Static_assert(0, ""); // expected-error {{static assertion failed}}
static_assert(a, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert(a, ""); // expected-error {{static assertion expression is not an integral constant expression}}
static_assert(sizeof(a) == 4, "");
static_assert(sizeof(a) == 3, ""); // expected-error {{static_assert failed}}
static_assert(sizeof(a) == 3, ""); // expected-error {{static assertion failed}}
}
static_assert(1, "");
@ -40,7 +40,7 @@ _Static_assert(1, "");
static_assert(1, "");
_Static_assert(1, "");
static_assert(sizeof(b) == 4, "");
static_assert(sizeof(b) == 3, ""); // expected-error {{static_assert failed}}
static_assert(sizeof(b) == 3, ""); // expected-error {{static assertion failed}}
}
static_assert(1, "");
@ -56,7 +56,7 @@ static_assert(1, "");
@interface B () {
int b;
static_assert(sizeof(b) == 4, "");
static_assert(sizeof(b) == 3, ""); // expected-error {{static_assert failed}}
static_assert(sizeof(b) == 3, ""); // expected-error {{static assertion failed}}
}
@end
@ -71,7 +71,7 @@ static_assert(1, "");
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_assert failed}}
_Static_assert(0, ""); // expected-error {{static assertion failed}}
}
@end
#endif

4
clang/test/Sema/builtin-align.c
View File

@ -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_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}}
_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}}
}
// Check that it is a constant expression that can be assigned to globals:

2
clang/test/Sema/sizeless-1.c
View File

@ -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_assert 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 assertion 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}}

13
clang/test/Sema/static-assert.c
View File

@ -5,11 +5,11 @@
_Static_assert("foo", "string is nonzero"); // ext-warning {{'_Static_assert' is a C11 extension}}
#ifndef __cplusplus
// expected-error@-2 {{static_assert expression is not an integral constant expression}}
// expected-error@-2 {{static assertion expression is not an integral constant expression}}
#endif
_Static_assert(1, "1 is nonzero"); // ext-warning {{'_Static_assert' is a C11 extension}}
_Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed: 0 is nonzero}} \
_Static_assert(0, "0 is nonzero"); // expected-error {{static assertion 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_assert failed: 0 is nonzero}} \
_Static_assert(0, "0 is nonzero"); // expected-error {{static assertion 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_assert failed: 0 is nonzero}} \
_Static_assert(0, "0 is nonzero"); // expected-error {{static assertion 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_assert failed due to requirement 'sizeof(char) == sizeof(short)': type size mismatch}} \
typedef UNION(char, short) U3; // expected-error {{static assertion 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,3 +70,6 @@ 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}}

2
clang/test/SemaCXX/access-base-class.cpp
View File

@ -109,7 +109,7 @@ class b {
template <int>
struct Impossible {
static_assert(false, ""); // expected-error {{static_assert failed}}
static_assert(false, ""); // expected-error {{static assertion failed}}
};
// verify "no member named 'value'" bogus diagnostic is not emitted.

2
clang/test/SemaCXX/alias-template.cpp
View File

@ -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_assert failed}}
static_assert(__is_same(S<3>::U, X[2]), ""); // expected-error {{static assertion failed}}
}
namespace PR39623 {

2
clang/test/SemaCXX/builtin-is-constant-evaluated.cpp
View File

@ -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_assert expression is not an integral constant}}
static_assert(n2 == 42); // expected-error {{static assertion expression is not an integral constant}}
// expected-note@-1 {{initializer of 'n2' is not a constant expression}}
template <bool V, bool Default = std::is_constant_evaluated()>

2
clang/test/SemaCXX/builtin-std-move.cpp
View File

@ -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_assert failed}}
static_assert(!is_lvalue_reference<T>::value, "should not forward rval as lval"); // expected-error {{static assertion failed}}
return static_cast<T&&>(x);
}

2
clang/test/SemaCXX/builtins.cpp
View File

@ -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_assert expression is not an integral constant expression}}
static_assert(__builtin_function_start(a) == a, ""); // expected-error {{static assertion expression is not an integral constant expression}}
} // namespace function_start
void no_ms_builtins() {

18
clang/test/SemaCXX/complex-folding.cpp
View File

@ -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_assert}}
static_assert((0.0 + 0.0j) != (0.0 + 0.0j)); // expected-error {{static assertion}}
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 differences and
// equality.
static_assert((1.0 + 0.0j) == (0.0 + 0.0j)); // expected-error {{static_assert}}
static_assert((1.0 + 0.0j) == (0.0 + 0.0j)); // expected-error {{static assertion}}
static_assert((1.0 + 0.0j) == (1.0 + 0.0j));
static_assert((1.0 + 1.0j) == (1.0 + 0.0j)); // expected-error {{static_assert}}
static_assert((1.0 + 1.0j) == (1.0 + 0.0j)); // expected-error {{static assertion}}
static_assert((1.0 + 1.0j) == (1.0 + 1.0j));
static_assert((0.0 + 1.0j) == (1.0 + 1.0j)); // expected-error {{static_assert}}
static_assert((0.0 + 1.0j) == (1.0 + 1.0j)); // expected-error {{static assertion}}
static_assert((0.0 + 1.0j) == (0.0 + 1.0j));
static_assert((-1.0 + 1.0j) == (0.0 + 1.0j)); // expected-error {{static_assert}}
static_assert((-1.0 + 1.0j) == (0.0 + 1.0j)); // expected-error {{static assertion}}
static_assert((-1.0 + 1.0j) == (-1.0 + 1.0j));
static_assert((-1.0 + 0.0j) == (-1.0 + 1.0j)); // expected-error {{static_assert}}
static_assert((-1.0 + 0.0j) == (-1.0 + 1.0j)); // expected-error {{static assertion}}
static_assert((-1.0 + 0.0j) == (-1.0 + 0.0j));
static_assert((-1.0 - 1.0j) == (-1.0 + 0.0j)); // expected-error {{static_assert}}
static_assert((-1.0 - 1.0j) == (-1.0 + 0.0j)); // expected-error {{static assertion}}
static_assert((-1.0 - 1.0j) == (-1.0 - 1.0j));
static_assert((0.0 - 1.0j) == (-1.0 - 1.0j)); // expected-error {{static_assert}}
static_assert((0.0 - 1.0j) == (-1.0 - 1.0j)); // expected-error {{static assertion}}
static_assert((0.0 - 1.0j) == (0.0 - 1.0j));
static_assert((1.0 - 1.0j) == (0.0 - 1.0j)); // expected-error {{static_assert}}
static_assert((1.0 - 1.0j) == (0.0 - 1.0j)); // expected-error {{static assertion}}
static_assert((1.0 - 1.0j) == (1.0 - 1.0j));
// Test basic mathematical folding of both complex and real operands.

10
clang/test/SemaCXX/constant-expression-cxx11.cpp
View File

@ -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_assert expression is not an integral constant expression}} \
expected-error {{static assertion 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_assert expression is not an integral constant expression}}
static_assert(*p == 3, ""); // expected-error {{static assertion expression is not an integral constant expression}}
// expected-note@-1 {{subexpression not valid}}
// expected-note@-3 {{declared here}}
static_assert((int[2]){1, 2}[1] == 2, ""); // expected-warning {{C99}}
// expected-error@-1 {{static_assert expression is not an integral constant expression}}
// expected-error@-1 {{static assertion expression is not an integral constant expression}}
// expected-note@-2 {{subexpression not valid}}
// expected-note@-3 {{declared here}}
@ -1912,12 +1912,12 @@ namespace VirtualFromBase {
static_assert(p->f() == sizeof(X<S1>), "");
// cxx11-error@-1 {{not an integral constant expression}}
// cxx11-note@-2 {{call to virtual function}}
// cxx20_2b-error@-3 {{static_assert failed}}
// cxx20_2b-error@-3 {{static assertion 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_assert failed}}
static_assert(q->f() == sizeof(S2), ""); // cxx20_2b-error {{static assertion failed}}
}
namespace ConstexprConstructorRecovery {

2
clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp
View File

@ -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_assert expression is not an integral constant expression}} expected-note{{in call to 'f(true)'}}
static_assert(f(/*read_uninit=*/true), ""); // expected-error{{static assertion expression is not an integral constant expression}} expected-note{{in call to 'f(true)'}}
constexpr bytes ld539 = {
0x0, 0x0, 0x0, 0x0,

2
clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
View File

@ -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_assert expression is not an integral constant expression}}
static_assert(test10() <= 1, "should not crash"); // expected-error {{static assertion expression is not an integral constant expression}}
struct X {} array[] = {undef()}; // expected-error {{use of undeclared identifier 'undef'}}
constexpr void test11() {

10
clang/test/SemaCXX/coroutines-exp-namespace.cpp
View File

@ -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_assert failed}}
static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
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 &, 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_assert failed}}
static_assert(TC.template MatchesArgs<>, ""); // expected-error {{static_assert failed}}
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 &, 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_assert failed}}
static_assert(TCT::MatchesArgs<int>, ""); // expected-error {{static assertion failed}}
}
static CoroMemberTag test_static(volatile void *const, char &&) {

10
clang/test/SemaCXX/coroutines.cpp
View File

@ -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_assert failed}}
static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
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 &, 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_assert failed}}
static_assert(TC.template MatchesArgs<>, ""); // expected-error {{static_assert failed}}
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 &, 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_assert failed}}
static_assert(TCT::MatchesArgs<int>, ""); // expected-error {{static assertion failed}}
}
static CoroMemberTag test_static(volatile void *const, char &&) {

6
clang/test/SemaCXX/cxx2a-template-lambdas.cpp
View File

@ -11,19 +11,19 @@ struct DummyTemplate { };
void func() {
auto L0 = []<typename T>(T arg) {
static_assert(is_same<T, int>); // expected-error {{static_assert failed}}
static_assert(is_same<T, int>); // expected-error {{static assertion failed}}
};
L0(0);
L0(0.0); // expected-note {{in instantiation}}
auto L1 = []<int I> {
static_assert(I == 5); // expected-error {{static_assert failed}}
static_assert(I == 5); // expected-error {{static assertion 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_assert failed}}
static_assert(is_same<T<U>, DummyTemplate<float>>); // // expected-error {{static assertion failed}}
};
L2(DummyTemplate<float>());
L2(DummyTemplate<double>()); // expected-note {{in instantiation}}

2
clang/test/SemaCXX/cxx98-compat.cpp
View File

@ -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);

2
clang/test/SemaCXX/delete-and-function-templates.cpp
View File

@ -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_assert failed}}
static_assert(is_same<decltype(f(3)),char>::value, ""); //expected-error{{call to deleted function}} expected-error{{static assertion failed}}
template<class T> decltype(f(T{})) g(T); // this one sfinae's out.
template<class T> int *g(T);

2
clang/test/SemaCXX/int-ptr-cast-SFINAE.cpp
View File

@ -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_assert failed due to requirement 'has_minus_assign<int *>': failed}}
static_assert(has_minus_assign<int*>, "failed"); // expected-error {{static assertion failed due to requirement 'has_minus_assign<int *>': failed}}

2
clang/test/SemaCXX/recovery-expr-type.cpp
View File

@ -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_assert failed}}
static_assert(Circular_A == 0 && Circular_A != 0, ""); // expected-error {{static assertion failed}}
}
namespace test14 {

2
clang/test/SemaCXX/sizeless-1.cpp
View File

@ -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_assert 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 assertion 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}}

34
clang/test/SemaCXX/static-assert-cxx17.cpp
View File

@ -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@-1{{static_assert failed due to requirement 'S1<int, float>::value'}}
// expected-error@-1{{static assertion failed due to requirement 'S1<int, float>::value'}}
}
template void foo<int, float>();
// expected-note@-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@-1{{static_assert failed due to requirement 'global_inline_var<int, float>'}}
// expected-error@-1{{static assertion failed due to requirement 'global_inline_var<int, float>'}}
}
template void foo2<int, float>();
// expected-note@-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@-1{{static_assert failed due to requirement 'S2<long>::var<int, float>'}}
// expected-error@-1{{static assertion failed due to requirement 'S2<long>::var<int, float>'}}
}
template void foo3<S2<long>, int, float>();
// expected-note@-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@-1{{static_assert failed due to requirement 'S1<float[4], int[4]>::value'}}
// expected-error@-1{{static assertion failed due to requirement 'S1<float[4], int[4]>::value'}}
};
template void foo4<float>();
// expected-note@-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@-1{{static_assert failed due to requirement '!!(global_inline_var<int, float>)'}}
// expected-error@-1{{static assertion failed due to requirement '!!(global_inline_var<int, float>)'}}
}
template void foo5<int, float>();
// expected-note@-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@-1{{static_assert failed due to requirement 'X<int>()'}}
// expected-error@-1{{static assertion failed due to requirement 'X<int>()'}}
static_assert(X<typename T::T>{});
// expected-error@-1{{static_assert failed due to requirement 'X<int>{}'}}
// expected-error@-1{{static assertion failed due to requirement 'X<int>{}'}}
static_assert(X<typename T::T>{1, 2});
// expected-error@-1{{static_assert failed due to requirement 'X<int>{1, 2}'}}
// expected-error@-1{{static assertion failed due to requirement 'X<int>{1, 2}'}}
static_assert(X<typename T::T>({1, 2}));
// expected-error@-1{{static_assert failed due to requirement 'X<int>({1, 2})'}}
// expected-error@-1{{static assertion failed due to requirement 'X<int>({1, 2})'}}
static_assert(typename T::T{0});
// expected-error@-1{{static_assert failed due to requirement 'int{0}'}}
// expected-error@-1{{static assertion failed due to requirement 'int{0}'}}
static_assert(typename T::T(0));
// expected-error@-1{{static_assert failed due to requirement 'int(0)'}}
// expected-error@-1{{static assertion failed due to requirement 'int(0)'}}
static_assert(sizeof(X<typename T::T>) == 0);
// expected-error@-1{{static_assert failed due to requirement 'sizeof(X<int>) == 0'}}
// expected-error@-1{{static assertion failed due to requirement 'sizeof(X<int>) == 0'}}
static_assert((const X<typename T::T> *)nullptr);
// expected-error@-1{{static_assert failed due to requirement '(const X<int> *)nullptr'}}
// expected-error@-1{{static assertion failed due to requirement '(const X<int> *)nullptr'}}
static_assert(static_cast<const X<typename T::T> *>(nullptr));
// expected-error@-1{{static_assert failed due to requirement 'static_cast<const X<int> *>(nullptr)'}}
// expected-error@-1{{static assertion failed due to requirement 'static_cast<const X<int> *>(nullptr)'}}
static_assert((const X<typename T::T>[]){} == nullptr);
// expected-error@-1{{static_assert failed due to requirement '(const X<int>[0]){} == nullptr'}}
// expected-error@-1{{static assertion 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@-1{{static_assert failed due to requirement 'sizeof(X<void>) == 0'}}
// expected-error@-1{{static assertion failed due to requirement 'sizeof(X<void>) == 0'}}
static_assert(constexpr_return_false<typename T::T, typename T::U>());
// expected-error@-1{{static_assert failed due to requirement 'constexpr_return_false<int, float>()'}}
// expected-error@-1{{static assertion failed due to requirement 'constexpr_return_false<int, float>()'}}
}
template void foo6<ExampleTypes>();
// expected-note@-1{{in instantiation of function template specialization 'foo6<ExampleTypes>' requested here}}

72
clang/test/SemaCXX/static-assert.cpp
View File

@ -2,61 +2,61 @@
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"}}
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"}}
static_assert(false, R"(a
\tb
c
)"); // expected-error@-3 {{static_assert failed: a\n\tb\nc\n}}
)"); // expected-error@-3 {{static assertion failed: a\n\tb\nc\n}}
static_assert(false, "\u0080\u0081\u0082\u0083\u0099\u009A\u009B\u009C\u009D\u009E\u009F");
// expected-error@-1 {{static_assert failed: <U+0080><U+0081><U+0082><U+0083><U+0099><U+009A><U+009B><U+009C><U+009D><U+009E><U+009F>}}
// expected-error@-1 {{static assertion failed: <U+0080><U+0081><U+0082><U+0083><U+0099><U+009A><U+009B><U+009C><U+009D><U+009E><U+009F>}}
//! Contains RTL/LTR marks
static_assert(false, "\u200Eabc\u200Fdef\u200Fgh"); // expected-error {{static_assert failed: ‎abc‏def‏gh}}
static_assert(false, "\u200Eabc\u200Fdef\u200Fgh"); // expected-error {{static assertion failed: ‎abc‏def‏gh}}
//! Contains ZWJ/regional indicators
static_assert(false, "🏳️‍🌈 🏴󠁧󠁢󠁥󠁮󠁧󠁿 🇪🇺"); // expected-error {{static_assert failed: 🏳️‍🌈 🏴󠁧󠁢󠁥󠁮󠁧󠁿 🇪🇺}}
static_assert(false, "🏳️‍🌈 🏴󠁧󠁢󠁥󠁮󠁧󠁿 🇪🇺"); // expected-error {{static assertion failed: 🏳️‍🌈 🏴󠁧󠁢󠁥󠁮󠁧󠁿 🇪🇺}}
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(); };
@ -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_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 {
@ -125,29 +125,29 @@ struct ExampleTypes {
};
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 {};
@ -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@-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}}
@ -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@-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}}
@ -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@-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([]() {});
@ -206,10 +206,12 @@ 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_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'}}
static_assert(1 , "") // expected-error {{expected ';' after 'static_assert'}}

2
clang/test/SemaCXX/using-decl-templates.cpp
View File

@ -95,7 +95,7 @@ namespace aliastemplateinst {
namespace DontDiagnoseInvalidTest {
template <bool Value> struct Base {
static_assert(Value, ""); // expected-error {{static_assert failed}}
static_assert(Value, ""); // expected-error {{static assertion 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.

2
clang/test/SemaCXX/weak-init.cpp
View File

@ -2,7 +2,7 @@
extern const int W1 __attribute__((weak)) = 10; // expected-note {{declared here}}
static_assert(W1 == 10, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert(W1 == 10, ""); // expected-error {{static assertion expression is not an integral constant expression}}
// expected-note@-1 {{initializer of weak variable 'W1' is not considered constant because it may be different at runtime}}
extern const int W2 __attribute__((weak)) = 20;

2
clang/test/SemaTemplate/instantiate-var-template.cpp
View File

@ -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_assert failed due to requirement 'a<sizeof (sizeof (f(type-parameter-0-0())))> == 0'}}
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'}}
}
}

6
clang/test/SemaTemplate/pr52909.cpp
View File

@ -15,7 +15,7 @@ concept Beginable = requires (T t) {
// expected-note@-1 {{because 't.begin' would be invalid: reference to non-static member function must be called}}
};
static_assert(Beginable<A>); // expected-error {{static_assert failed}}
static_assert(Beginable<A>); // expected-error {{static assertion failed}}
// expected-note@-1 {{does not satisfy 'Beginable'}}
} // namespace PR52905
@ -48,7 +48,7 @@ struct A {
static void begin(double);
};
static_assert(C<A>); // expected-error {{static_assert failed}}
static_assert(C<A>); // expected-error {{static assertion failed}}
// expected-note@-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_assert failed}}
static_assert(C<S>); // expected-error {{static assertion failed}}
// expected-note@-1 {{because 'PR53075::S' does not satisfy 'C'}}
} // namespace PR53075

4
clang/test/SemaTemplate/pr52970.cpp
View File

@ -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_assert failed}}
static_assert(C<Bad>); // cxx20-error {{static assertion failed}}
// cxx20-note@-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_assert failed}}
static_assert(C<Bad>); // cxx20-error {{static assertion failed}}
// cxx20-note@-1 {{because 'DotFollowingPointer::Bad' (aka 'Holder<Incomplete> *') does not satisfy 'C'}}
#endif
} // namespace DotFollowingPointer

2
clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp
View File

@ -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_assert 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 assertion 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}}
}