367 lines · cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -pedantic -triple=x86_64-linux-gnu -Wno-invalid-utf82 3int f(); // expected-note {{declared here}}4 5static_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}}6static_assert(true, "true is not false");7static_assert(false, "false is false"); // expected-error {{static assertion failed: false is false}}8 9void g() {10 static_assert(false, "false is false"); // expected-error {{static assertion failed: false is false}}11}12 13class C {14 static_assert(false, "false is false"); // expected-error {{static assertion failed: false is false}}15};16 17template<int N> struct T {18 static_assert(N == 2, "N is not 2!"); // expected-error {{static assertion failed due to requirement '1 == 2': N is not 2!}}19};20 21T<1> t1; // expected-note {{in instantiation of template class 'T<1>' requested here}}22T<2> t2;23 24template<typename T> struct S {25 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!}} \26 // expected-note {{1 > 1}}27};28 29S<char> s1; // expected-note {{in instantiation of template class 'S<char>' requested here}}30S<int> s2;31 32static_assert(false, L"\xFFFFFFFF"); // expected-warning {{encoding prefix 'L' on an unevaluated string literal has no effect and is incompatible with c++2c}} \33 // expected-error {{invalid escape sequence '\xFFFFFFFF' in an unevaluated string literal}} \34 // expected-error {{hex escape sequence out of range}}35static_assert(false, u"\U000317FF"); // expected-warning {{encoding prefix 'u' on an unevaluated string literal has no effect and is incompatible with c++2c}} \36 // expected-error {{static assertion failed}}37 38static_assert(false, u8"Ω"); // expected-warning {{encoding prefix 'u8' on an unevaluated string literal has no effect and is incompatible with c++2c}} \39 // expected-error {{static assertion failed: Ω}}40static_assert(false, L"\u1234"); // expected-warning {{encoding prefix 'L' on an unevaluated string literal has no effect and is incompatible with c++2c}} \41 // expected-error {{static assertion failed: ሴ}}42 43static_assert(false, L"\x1ff" // expected-warning {{encoding prefix 'L' on an unevaluated string literal has no effect and is incompatible with c++2c}} \44 // expected-error {{hex escape sequence out of range}} \45 // expected-error {{invalid escape sequence '\x1ff' in an unevaluated string literal}}46 "0\x123" // expected-error {{invalid escape sequence '\x123' in an unevaluated string literal}}47 "fx\xfffff" // expected-error {{invalid escape sequence '\xfffff' in an unevaluated string literal}}48 "goop");49 50static_assert(false, "\'\"\?\\\a\b\f\n\r\t\v"); // expected-error {{'"?\<U+0007><U+0008>}}51static_assert(true, "\xFF"); // expected-error {{invalid escape sequence '\xFF' in an unevaluated string literal}}52static_assert(true, "\123"); // expected-error {{invalid escape sequence '\123' in an unevaluated string literal}}53static_assert(true, "\pOh no, a Pascal string!"); // expected-warning {{unknown escape sequence '\p'}} \54 // expected-error {{invalid escape sequence '\p' in an unevaluated string literal}}55static_assert(false, R"(a56\tb57c58)"); // expected-error@-3 {{static assertion failed: a\n\tb\nc\n}}59 60static_assert(false, "\u0080\u0081\u0082\u0083\u0099\u009A\u009B\u009C\u009D\u009E\u009F");61// 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>}}62 63//! Contains RTL/LTR marks64static_assert(false, "\u200Eabc\u200Fdef\u200Fgh"); // expected-error {{static assertion failed: abcdefgh}}65 66//! Contains ZWJ/regional indicators67static_assert(false, "🏳️🌈 🏴 🇪🇺"); // expected-error {{static assertion failed: 🏳️🌈 🏴 🇪🇺}}68 69template<typename T> struct AlwaysFails {70 // Only give one error here.71 static_assert(false, ""); // expected-error 2{{static assertion failed}}72};73AlwaysFails<int> alwaysFails; // expected-note {{instantiation}}74AlwaysFails<double> alwaysFails2; // expected-note {{instantiation}}75 76 77template<typename T> struct StaticAssertProtected {78 static_assert(__is_literal(T), ""); // expected-error {{static assertion failed}}79 static constexpr T t = {}; // no error here80};81struct X { ~X(); };82StaticAssertProtected<int> sap1;83StaticAssertProtected<X> sap2; // expected-note {{instantiation}}84 85static_assert(true); // expected-warning {{C++17 extension}}86static_assert(false); // expected-error-re {{failed{{$}}}} expected-warning {{extension}}87 88 89// Diagnostics for static_assert with multiple conditions90template<typename T> struct first_trait {91 static const bool value = false;92};93 94template<>95struct first_trait<X> {96 static const bool value = true;97};98 99template<typename T> struct second_trait {100 static const bool value = false;101};102 103static_assert(first_trait<X>::value && second_trait<X>::value, "message"); // expected-error{{static assertion failed due to requirement 'second_trait<X>::value': message}}104 105namespace std {106 107template <class Tp, Tp v>108struct integral_constant {109 static const Tp value = v;110 typedef Tp value_type;111 typedef integral_constant type;112 constexpr operator value_type() const noexcept { return value; }113 constexpr value_type operator()() const noexcept { return value; }114};115 116template <class Tp, Tp v>117const Tp integral_constant<Tp, v>::value;118 119typedef integral_constant<bool, true> true_type;120typedef integral_constant<bool, false> false_type;121 122template <class Tp>123struct is_const : public false_type {};124template <class Tp>125struct is_const<Tp const> : public true_type {};126 127// We do not define is_same in terms of integral_constant to check that both implementations are supported.128template <typename T, typename U>129struct is_same {130 static const bool value = false;131};132 133template <typename T>134struct is_same<T, T> {135 static const bool value = true;136};137 138} // namespace std139 140struct ExampleTypes {141 explicit ExampleTypes(int);142 using T = int;143 using U = float;144};145 146static_assert(std::is_same<ExampleTypes::T, ExampleTypes::U>::value, "message");147// expected-error@-1{{static assertion failed due to requirement 'std::is_same<int, float>::value': message}}148static_assert(std::is_const<ExampleTypes::T>::value, "message");149// expected-error@-1{{static assertion failed due to requirement 'std::is_const<int>::value': message}}150static_assert(!std::is_const<const ExampleTypes::T>::value, "message");151// expected-error@-1{{static assertion failed due to requirement '!std::is_const<const int>::value': message}}152static_assert(!(std::is_const<const ExampleTypes::T>::value), "message");153// expected-error@-1{{static assertion failed due to requirement '!(std::is_const<const int>::value)': message}}154static_assert(std::is_const<const ExampleTypes::T>::value == false, "message");155// expected-error@-1{{static assertion failed due to requirement 'std::is_const<const int>::value == false': message}}156static_assert(!(std::is_const<const ExampleTypes::T>::value == true), "message");157// expected-error@-1{{static assertion failed due to requirement '!(std::is_const<const int>::value == true)': message}}158static_assert(std::is_const<ExampleTypes::T>(), "message");159// expected-error@-1{{static assertion failed due to requirement 'std::is_const<int>()': message}}160static_assert(!(std::is_const<const ExampleTypes::T>()()), "message");161// expected-error@-1{{static assertion failed due to requirement '!(std::is_const<const int>()())': message}}162static_assert(std::is_same<decltype(std::is_const<const ExampleTypes::T>()), int>::value, "message");163// expected-error@-1{{static assertion failed due to requirement 'std::is_same<std::is_const<const int>, int>::value': message}}164static_assert(std::is_const<decltype(ExampleTypes::T(3))>::value, "message");165// expected-error@-1{{static assertion failed due to requirement 'std::is_const<int>::value': message}}166static_assert(std::is_const<decltype(ExampleTypes::T())>::value, "message");167// expected-error@-1{{static assertion failed due to requirement 'std::is_const<int>::value': message}}168static_assert(std::is_const<decltype(ExampleTypes(3))>::value, "message");169// expected-error@-1{{static assertion failed due to requirement 'std::is_const<ExampleTypes>::value': message}}170 171struct BI_tag {};172struct RAI_tag : BI_tag {};173struct MyIterator {174 using tag = BI_tag;175};176struct MyContainer {177 using iterator = MyIterator;178};179template <class Container>180void foo() {181 static_assert(std::is_same<RAI_tag, typename Container::iterator::tag>::value, "message");182 // expected-error@-1{{static assertion failed due to requirement 'std::is_same<RAI_tag, BI_tag>::value': message}}183}184template void foo<MyContainer>();185// expected-note@-1{{in instantiation of function template specialization 'foo<MyContainer>' requested here}}186 187namespace ns {188template <typename T, int v>189struct NestedTemplates1 {190 struct NestedTemplates2 {191 template <typename U>192 struct NestedTemplates3 : public std::is_same<T, U> {};193 };194};195} // namespace ns196 197template <typename T, typename U, int a>198void foo2() {199 // FIXME: Here the template keyword is dropped because the failed condition200 // for a static assert is always printed with canonical types.201 static_assert(::ns::NestedTemplates1<T, a>::NestedTemplates2::template NestedTemplates3<U>::value, "message");202 // expected-error@-1{{static assertion failed due to requirement 'ns::NestedTemplates1<int, 3>::NestedTemplates2::NestedTemplates3<float>::value': message}}203}204template void foo2<int, float, 3>();205// expected-note@-1{{in instantiation of function template specialization 'foo2<int, float, 3>' requested here}}206 207template <class T>208void foo3(T t) {209 static_assert(std::is_const<T>::value, "message");210 // expected-error-re@-1{{static assertion failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value': message}}211 static_assert(std::is_const<decltype(t)>::value, "message");212 // expected-error-re@-1{{static assertion failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value': message}}213}214void callFoo3() {215 foo3([]() {});216 // expected-note@-1{{in instantiation of function template specialization 'foo3<(lambda at }}217}218 219template <class T>220void foo4(T t) {221 static_assert(std::is_const<typename T::iterator>::value, "message");222 // expected-error@-1{{type 'int' cannot be used prior to '::' because it has no members}}223}224void callFoo4() { foo4(42); }225// expected-note@-1{{in instantiation of function template specialization 'foo4<int>' requested here}}226 227static_assert(42, "message");228static_assert(42.0, "message"); // expected-warning {{implicit conversion from 'double' to 'bool' changes value from 42 to true}}229constexpr int *p = 0;230static_assert(p, "message"); // expected-error {{static assertion failed}}231 232struct NotBool {233} notBool;234constexpr NotBool constexprNotBool;235static_assert(notBool, "message"); // expected-error {{value of type 'struct NotBool' is not contextually convertible to 'bool'}}236static_assert(constexprNotBool, "message"); // expected-error {{value of type 'const NotBool' is not contextually convertible to 'bool'}}237 238static_assert(1 , "") // expected-error {{expected ';' after 'static_assert'}}239 240namespace DependentAlwaysFalse {241template <typename Ty>242struct S {243 static_assert(false); // expected-error{{static assertion failed}} \244 // expected-warning {{C++17 extension}}245};246 247template <typename Ty>248struct T {249 static_assert(false, "test"); // expected-error{{static assertion failed: test}}250};251 252int f() {253 S<double> s; //expected-note {{in instantiation of template class 'DependentAlwaysFalse::S<double>' requested here}}254 T<double> t; //expected-note {{in instantiation of template class 'DependentAlwaysFalse::T<double>' requested here}}255}256}257 258namespace Diagnostics {259 /// No notes for literals.260 static_assert(false, ""); // expected-error {{failed}}261 static_assert(1.0 > 2.0, ""); // expected-error {{failed}}262 static_assert('c' == 'd', ""); // expected-error {{failed}}263 static_assert(1 == 2, ""); // expected-error {{failed}}264 265 /// Simple things are ignored.266 static_assert(1 == (-(1)), ""); //expected-error {{failed}}267 268 /// Chars are printed as chars.269 constexpr char getChar() {270 return 'c';271 }272 static_assert(getChar() == 'a', ""); // expected-error {{failed}} \273 // expected-note {{evaluates to ''c' (0x63, 99) == 'a' (0x61, 97)'}}274 static_assert((char)9 == '\x61', ""); // expected-error {{failed}} \275 // expected-note {{evaluates to ''\t' (0x09, 9) == 'a' (0x61, 97)'}}276 static_assert((char)10 == '\0', ""); // expected-error {{failed}} \277 // expected-note {{n' (0x0A, 10) == '<U+0000>' (0x00, 0)'}}278 // The note above is intended to match "evaluates to '\n' (0x0A, 10) == '<U+0000>' (0x00, 0)'", but if we write it as it is,279 // the "\n" cannot be consumed by the diagnostic consumer.280 static_assert((signed char)10 == (char)-123, ""); // expected-error {{failed}} \281 // expected-note {{evaluates to '10 == '<85>' (0x85, -123)'}}282 static_assert((char)-4 == (unsigned char)-8, ""); // expected-error {{failed}} \283 // expected-note {{evaluates to ''<FC>' (0xFC, -4) == 248'}}284 static_assert((char)-128 == (char)-123, ""); // expected-error {{failed}} \285 // expected-note {{evaluates to ''<80>' (0x80, -128) == '<85>' (0x85, -123)'}}286 static_assert('\xA0' == (char)'\x20', ""); // expected-error {{failed}} \287 // expected-note {{evaluates to ''<A0>' (0xA0, -96) == ' ' (0x20, 32)'}}288 static_assert((char16_t)L'ゆ' == L"C̵̭̯̠̎͌ͅť̺"[1], ""); // expected-error {{failed}} \289 // expected-note {{evaluates to 'u'ゆ' (0x3086, 12422) == L'̵' (0x335, 821)'}}290 static_assert(L"＼／"[1] == u'\xFFFD', ""); // expected-error {{failed}} \291 // expected-note {{evaluates to 'L'／' (0xFF0F, 65295) == u'�' (0xFFFD, 65533)'}}292 static_assert(L"⚾"[0] == U'🌍', ""); // expected-error {{failed}} \293 // expected-note {{evaluates to 'L'⚾' (0x26BE, 9918) == U'🌍' (0x1F30D, 127757)'}}294 static_assert(U"\a"[0] == (wchar_t)9, ""); // expected-error {{failed}} \295 // expected-note {{evaluates to 'U'\a' (0x07, 7) == L'\t' (0x09, 9)'}}296 static_assert(L"§"[0] == U'Ö', ""); // expected-error {{failed}} \297 // expected-note {{evaluates to 'L'§' (0xA7, 167) == U'Ö' (0xD6, 214)'}}298 299 /// Bools are printed as bools.300 constexpr bool invert(bool b) {301 return !b;302 }303 304 static_assert(invert(true) || invert(true), ""); // expected-error {{static assertion failed due to requirement 'invert(true) || invert(true)'}}305 static_assert(invert(true) == invert(false), ""); // expected-error {{static assertion failed due to requirement 'invert(true) == invert(false)'}} \306 // expected-note {{evaluates to 'false == true'}}307 static_assert(true && false, ""); // expected-error {{static assertion failed due to requirement 'true && false'}}308 static_assert(invert(true) || invert(true) || false, ""); // expected-error {{static assertion failed due to requirement 'invert(true) || invert(true) || false'}}309 static_assert((true && invert(true)) || false, ""); // expected-error {{static assertion failed due to requirement '(true && invert(true)) || false'}}310 static_assert(true && invert(false) && invert(true), ""); // expected-error {{static assertion failed due to requirement 'invert(true)'}}311 312 /// No notes here since we compare a bool expression with a bool literal.313 static_assert(invert(true) == true, ""); // expected-error {{failed}}314 315#pragma clang diagnostic push316#pragma clang diagnostic ignored "-Wc99-extensions"317 constexpr _Complex float com = {5,6};318 constexpr _Complex float com2 = {1, 9};319 static_assert(com == com2, ""); // expected-error {{failed}} \320 // expected-note {{evaluates to '(5 + 6i) == (1 + 9i)'}}321#pragma clang diagnostic pop322 323#define CHECK_4(x) ((x) == 4)324#define A_IS_B (a == b)325 static_assert(CHECK_4(5), ""); // expected-error {{failed}}326 327 constexpr int a = 4;328 constexpr int b = 5;329 static_assert(CHECK_4(a) && A_IS_B, ""); // expected-error {{failed}} \330 // expected-note {{evaluates to '4 == 5'}}331 332 static_assert(333 false, // expected-error {{static assertion failed}}334 ""335 );336 337 static_assert(338 true && false, // expected-error {{static assertion failed due to requirement 'true && false'}}339 ""340 );341 342 static_assert(343 // with a comment here344 true && false, // expected-error {{static assertion failed due to requirement 'true && false'}}345 ""346 );347 348 static_assert(349 // with a comment here350 (true && // expected-error {{static assertion failed due to requirement '(true && false) || false'}}351 false)352 || false,353 ""354 );355 356 static_assert(1 + 1 != 2, ""); // expected-error {{failed}} \357 // expected-note {{evaluates to '2 != 2'}}358 static_assert(1 - 1 == 2, ""); // expected-error {{failed}} \359 // expected-note {{evaluates to '0 == 2'}}360 static_assert(1 * 1 == 2, ""); // expected-error {{failed}} \361 // expected-note {{evaluates to '1 == 2'}}362 static_assert(1 / 1 == 2, ""); // expected-error {{failed}} \363 // expected-note {{evaluates to '1 == 2'}}364 static_assert(1 << 3 != 8, ""); // expected-error {{failed}} \365 // expected-note {{evaluates to '8 != 8'}}366}367