1 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -triple=x86_64-linux-gnu
2
3 int f(); // expected-note {{declared here}}
4
5 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}}
6 static_assert(true, "true is not false");
7 static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}}
8
g()9 void g() {
10 static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}}
11 }
12
13 class C {
14 static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}}
15 };
16
17 template<int N> struct T {
18 static_assert(N == 2, "N is not 2!"); // expected-error {{static_assert failed due to requirement '1 == 2' "N is not 2!"}}
19 };
20
21 T<1> t1; // expected-note {{in instantiation of template class 'T<1>' requested here}}
22 T<2> t2;
23
24 template<typename T> struct S {
25 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!"}}
26 };
27
28 S<char> s1; // expected-note {{in instantiation of template class 'S<char>' requested here}}
29 S<int> s2;
30
31 static_assert(false, L"\xFFFFFFFF"); // expected-error {{static_assert failed L"\xFFFFFFFF"}}
32 static_assert(false, u"\U000317FF"); // expected-error {{static_assert failed u"\U000317FF"}}
33 // FIXME: render this as u8"\u03A9"
34 static_assert(false, u8"Ω"); // expected-error {{static_assert failed u8"\316\251"}}
35 static_assert(false, L"\u1234"); // expected-error {{static_assert failed L"\x1234"}}
36 static_assert(false, L"\x1ff" "0\x123" "fx\xfffff" "goop"); // expected-error {{static_assert failed L"\x1FF""0\x123""fx\xFFFFFgoop"}}
37
38 template<typename T> struct AlwaysFails {
39 // Only give one error here.
40 static_assert(false, ""); // expected-error {{static_assert failed}}
41 };
42 AlwaysFails<int> alwaysFails;
43
44 template<typename T> struct StaticAssertProtected {
45 static_assert(__is_literal(T), ""); // expected-error {{static_assert failed}}
46 static constexpr T t = {}; // no error here
47 };
48 struct X { ~X(); };
49 StaticAssertProtected<int> sap1;
50 StaticAssertProtected<X> sap2; // expected-note {{instantiation}}
51
52 static_assert(true); // expected-warning {{C++17 extension}}
53 static_assert(false); // expected-error-re {{failed{{$}}}} expected-warning {{extension}}
54
55
56 // Diagnostics for static_assert with multiple conditions
57 template<typename T> struct first_trait {
58 static const bool value = false;
59 };
60
61 template<>
62 struct first_trait<X> {
63 static const bool value = true;
64 };
65
66 template<typename T> struct second_trait {
67 static const bool value = false;
68 };
69
70 static_assert(first_trait<X>::value && second_trait<X>::value, "message"); // expected-error{{static_assert failed due to requirement 'second_trait<X>::value' "message"}}
71
72 namespace std {
73
74 template <class Tp, Tp v>
75 struct integral_constant {
76 static const Tp value = v;
77 typedef Tp value_type;
78 typedef integral_constant type;
operator value_typestd::integral_constant79 constexpr operator value_type() const noexcept { return value; }
operator ()std::integral_constant80 constexpr value_type operator()() const noexcept { return value; }
81 };
82
83 template <class Tp, Tp v>
84 const Tp integral_constant<Tp, v>::value;
85
86 typedef integral_constant<bool, true> true_type;
87 typedef integral_constant<bool, false> false_type;
88
89 template <class Tp>
90 struct is_const : public false_type {};
91 template <class Tp>
92 struct is_const<Tp const> : public true_type {};
93
94 // We do not define is_same in terms of integral_constant to check that both implementations are supported.
95 template <typename T, typename U>
96 struct is_same {
97 static const bool value = false;
98 };
99
100 template <typename T>
101 struct is_same<T, T> {
102 static const bool value = true;
103 };
104
105 } // namespace std
106
107 struct ExampleTypes {
108 explicit ExampleTypes(int);
109 using T = int;
110 using U = float;
111 };
112
113 static_assert(std::is_same<ExampleTypes::T, ExampleTypes::U>::value, "message");
114 // expected-error@-1{{static_assert failed due to requirement 'std::is_same<int, float>::value' "message"}}
115 static_assert(std::is_const<ExampleTypes::T>::value, "message");
116 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value' "message"}}
117 static_assert(!std::is_const<const ExampleTypes::T>::value, "message");
118 // expected-error@-1{{static_assert failed due to requirement '!std::is_const<const int>::value' "message"}}
119 static_assert(!(std::is_const<const ExampleTypes::T>::value), "message");
120 // expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>::value)' "message"}}
121 static_assert(std::is_const<const ExampleTypes::T>::value == false, "message");
122 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<const int>::value == false' "message"}}
123 static_assert(!(std::is_const<const ExampleTypes::T>::value == true), "message");
124 // expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>::value == true)' "message"}}
125 static_assert(std::is_const<ExampleTypes::T>(), "message");
126 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>()' "message"}}
127 static_assert(!(std::is_const<const ExampleTypes::T>()()), "message");
128 // expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>()())' "message"}}
129 static_assert(std::is_same<decltype(std::is_const<const ExampleTypes::T>()), int>::value, "message");
130 // expected-error@-1{{static_assert failed due to requirement 'std::is_same<std::is_const<const int>, int>::value' "message"}}
131 static_assert(std::is_const<decltype(ExampleTypes::T(3))>::value, "message");
132 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value' "message"}}
133 static_assert(std::is_const<decltype(ExampleTypes::T())>::value, "message");
134 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value' "message"}}
135 static_assert(std::is_const<decltype(ExampleTypes(3))>::value, "message");
136 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<ExampleTypes>::value' "message"}}
137
138 struct BI_tag {};
139 struct RAI_tag : BI_tag {};
140 struct MyIterator {
141 using tag = BI_tag;
142 };
143 struct MyContainer {
144 using iterator = MyIterator;
145 };
146 template <class Container>
foo()147 void foo() {
148 static_assert(std::is_same<RAI_tag, typename Container::iterator::tag>::value, "message");
149 // expected-error@-1{{static_assert failed due to requirement 'std::is_same<RAI_tag, BI_tag>::value' "message"}}
150 }
151 template void foo<MyContainer>();
152 // expected-note@-1{{in instantiation of function template specialization 'foo<MyContainer>' requested here}}
153
154 namespace ns {
155 template <typename T, int v>
156 struct NestedTemplates1 {
157 struct NestedTemplates2 {
158 template <typename U>
159 struct NestedTemplates3 : public std::is_same<T, U> {};
160 };
161 };
162 } // namespace ns
163
164 template <typename T, typename U, int a>
foo2()165 void foo2() {
166 static_assert(::ns::NestedTemplates1<T, a>::NestedTemplates2::template NestedTemplates3<U>::value, "message");
167 // expected-error@-1{{static_assert failed due to requirement '::ns::NestedTemplates1<int, 3>::NestedTemplates2::NestedTemplates3<float>::value' "message"}}
168 }
169 template void foo2<int, float, 3>();
170 // expected-note@-1{{in instantiation of function template specialization 'foo2<int, float, 3>' requested here}}
171
172 template <class T>
foo3(T t)173 void foo3(T t) {
174 static_assert(std::is_const<T>::value, "message");
175 // expected-error-re@-1{{static_assert failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value' "message"}}
176 static_assert(std::is_const<decltype(t)>::value, "message");
177 // expected-error-re@-1{{static_assert failed due to requirement 'std::is_const<(lambda at {{.*}}static-assert.cpp:{{[0-9]*}}:{{[0-9]*}})>::value' "message"}}
178 }
callFoo3()179 void callFoo3() {
180 foo3([]() {});
181 // expected-note@-1{{in instantiation of function template specialization 'foo3<(lambda at }}
182 }
183
184 template <class T>
foo4(T t)185 void foo4(T t) {
186 static_assert(std::is_const<typename T::iterator>::value, "message");
187 // expected-error@-1{{type 'int' cannot be used prior to '::' because it has no members}}
188 }
callFoo4()189 void callFoo4() { foo4(42); }
190 // expected-note@-1{{in instantiation of function template specialization 'foo4<int>' requested here}}
191