1 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 3 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 4 // RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 5 6 namespace std { struct type_info {}; } 7 8 namespace dr601 { // dr601: yes 9 #if __cplusplus >= 201103L 10 #define MAX __LLONG_MAX__ 11 #else 12 #define MAX __LONG_MAX__ 13 #endif 14 15 #if 0x8000 < -1 16 #error 0x8000 should be signed 17 #endif 18 19 #if MAX > 0xFFFFFFFF && 0x80000000 < -1 20 #error 0x80000000 should be signed 21 #endif 22 23 #if __INT_MAX__ == 0x7FFFFFFF 24 _Static_assert(0x80000000 < -1, "0x80000000 should be unsigned"); // expected-error {{C11}} 25 #endif 26 27 #if MAX > 0xFFFFFFFFFFFFFFFF && 0x8000000000000000 < -1 28 #error 0x8000000000000000 should be signed 29 #endif 30 31 #if __cplusplus >= 201103L && __LLONG_MAX__ == 0x7FFFFFFFFFFFFFFF 32 static_assert(0x8000000000000000 < -1, "0x8000000000000000 should be unsigned"); // expected-error {{C11}} 33 #endif 34 35 #undef MAX 36 } 37 38 namespace dr602 { // dr602: yes 39 template<class T> struct A { 40 template<class U> friend struct A; 41 }; 42 43 template<class T> struct B { 44 class C { 45 template<class U> friend struct B; 46 typedef int type; 47 }; 48 typename C::type ct; // ok, befriended 49 }; 50 B<int> b; 51 } 52 53 namespace dr603 { // dr603: yes 54 template<unsigned char> struct S {}; 55 typedef S<'\001'> S1; 56 typedef S<(1ul << __CHAR_BIT__) + 1> S1; 57 #if __cplusplus >= 201103L 58 // expected-error@-2 {{cannot be narrowed}} 59 #endif 60 } 61 62 // dr604: na 63 // dr605 needs IRGen test 64 65 namespace dr606 { // dr606: yes 66 #if __cplusplus >= 201103L 67 template<typename T> struct S {}; 68 template<typename T> void f(S<T> &&); // expected-note {{no known conversion from 'S<int>' to 'S<int> &&'}} 69 template<typename T> void g(T &&); 70 template<typename T> void h(const T &&); // expected-note {{no known conversion from 'S<int>' to 'const dr606::S<int> &&'}} 71 test(S<int> s)72 void test(S<int> s) { 73 f(s); // expected-error {{no match}} 74 g(s); 75 h(s); // expected-error {{no match}} 76 77 g(test); 78 h(test); // ok, an rvalue reference can bind to a function lvalue 79 } 80 #endif 81 } 82 83 namespace dr608 { // dr608: yes 84 struct A { virtual void f(); }; 85 struct B : A {}; 86 struct C : A { void f(); }; 87 struct D : B, C {}; 88 } 89 90 int dr610[-0u == 0u ? 1 : -1]; // dr610: yes 91 92 namespace dr611 { // dr611: yes 93 int k; 94 struct S { int &r; } s = { k ? k : k }; 95 } 96 97 // dr612: na 98 99 namespace dr613 { // dr613: yes c++11 100 // see also n2253 101 struct A { int n; static void f(); }; 102 int f(int); 103 struct B { virtual void f(); }; 104 B &g(int); 105 106 int an1 = sizeof(A::n); 107 int an2 = sizeof(A::n + 1); // valid per dr850 108 int an3 = sizeof A::n; 109 int an4 = sizeof(f(A::n)); 110 int an5 = sizeof(g(A::n)); 111 const std::type_info &an6 = typeid(A::n); 112 const std::type_info &an7 = typeid(A::n + 1); 113 const std::type_info &an8 = typeid(f(A::n)); 114 const std::type_info &an9 = typeid(g(A::n)); // expected-error {{non-static}} 115 #if __cplusplus < 201103L 116 // expected-error@-10 {{non-static}} 117 // expected-error@-10 {{non-static}} 118 // expected-error@-10 {{non-static}} 119 // expected-error@-10 {{non-static}} 120 // expected-error@-10 {{non-static}} 121 // expected-error@-10 {{non-static}} 122 // expected-error@-10 {{non-static}} 123 // expected-error@-10 {{non-static}} 124 #endif 125 f()126 void A::f() { 127 int an1 = sizeof n; 128 const std::type_info &an2 = typeid(n + 1); 129 #if __cplusplus < 201103L 130 // expected-error@-3 {{static}} 131 // expected-error@-3 {{static}} 132 #endif 133 const std::type_info &an3 = typeid(g(n)); // expected-error {{static}} 134 } 135 } 136 137 int dr614_a[(-1) / 2 == 0 ? 1 : -1]; // dr614: yes 138 int dr614_b[(-1) % 2 == -1 ? 1 : -1]; 139 140 namespace dr615 { // dr615: yes 141 int f(); 142 static int n = f(); 143 } 144 145 namespace dr616 { // dr616: no 146 #if __cplusplus >= 201103L 147 struct S { int n; } s; 148 // FIXME: These should all be 'int &&' 149 using T = decltype(S().n); // expected-note 2{{previous}} 150 using T = decltype(static_cast<S&&>(s).n); 151 using T = decltype(S().*&S::n); 152 using T = decltype(static_cast<S&&>(s).*&S::n); // expected-error {{different type}} 153 using T = int&&; // expected-error {{different type}} 154 #endif 155 } 156 157 namespace dr618 { // dr618: yes 158 #if (unsigned)-1 > 0 159 #error wrong 160 #endif 161 } 162 163 namespace dr619 { // dr619: yes 164 extern int x[10]; 165 struct S { static int x[10]; }; 166 167 int x[]; 168 _Static_assert(sizeof(x) == sizeof(int) * 10, ""); // expected-error {{C11}} 169 extern int x[]; 170 _Static_assert(sizeof(x) == sizeof(int) * 10, ""); // expected-error {{C11}} 171 172 int S::x[]; 173 _Static_assert(sizeof(S::x) == sizeof(int) * 10, ""); // expected-error {{C11}} 174 f()175 void f() { 176 extern int x[]; 177 sizeof(x); // expected-error {{incomplete}} 178 } 179 } 180 181 // dr620: dup 568 182 183 namespace dr621 { 184 template<typename T> T f(); f()185 template<> int f() {} // expected-note {{previous}} f()186 template<> int f<int>() {} // expected-error {{redefinition}} 187 } 188 189 // dr623: na 190 // FIXME: Add documentation saying we allow invalid pointer values. 191 192 // dr624 needs an IRGen check. 193 194 namespace dr625 { // dr625: yes 195 template<typename T> struct A {}; 196 A<auto> x = A<int>(); // expected-error {{'auto' not allowed in template argument}} expected-error 0-1{{extension}} 197 void f(int); 198 void (*p)(auto) = f; // expected-error {{'auto' not allowed in function prototype}} expected-error 0-1{{extension}} 199 } 200 201 namespace dr626 { // dr626: yes 202 #define STR(x) #x 203 char c[2] = STR(c); // ok, type matches 204 wchar_t w[2] = STR(w); // expected-error {{initializing wide char array with non-wide string literal}} 205 } 206 207 namespace dr627 { // dr627: yes f()208 void f() { 209 true a = 0; // expected-error +{{}} expected-warning {{unused}} 210 } 211 } 212 213 // dr628: na 214 215 namespace dr629 { // dr629: yes 216 typedef int T; 217 int n = 1; f()218 void f() { 219 auto T = 2; 220 #if __cplusplus < 201103L 221 // expected-error@-2 {{expected unqualified-id}} 222 #else 223 // expected-note@-4 {{previous}} 224 #endif 225 226 auto T(n); 227 #if __cplusplus >= 201103L 228 // expected-error@-2 {{redefinition of 'T'}} 229 #endif 230 } 231 } 232 233 namespace dr630 { // dr630: yes 234 const bool MB_EQ_WC = 235 ' ' == L' ' && '\t' == L'\t' && '\v' == L'\v' && '\r' == L'\r' && 236 '\n' == L'\n' && // 237 'a' == L'a' && 'b' == L'b' && 'c' == L'c' && 'd' == L'd' && 'e' == L'e' && 238 'f' == L'f' && 'g' == L'g' && 'h' == L'h' && 'i' == L'i' && 'j' == L'j' && 239 'k' == L'k' && 'l' == L'l' && 'm' == L'm' && 'n' == L'n' && 'o' == L'o' && 240 'p' == L'p' && 'q' == L'q' && 'r' == L'r' && 's' == L's' && 't' == L't' && 241 'u' == L'u' && 'v' == L'v' && 'w' == L'w' && 'x' == L'x' && 'y' == L'y' && 242 'z' == L'z' && // 243 'A' == L'A' && 'B' == L'B' && 'C' == L'C' && 'D' == L'D' && 'E' == L'E' && 244 'F' == L'F' && 'G' == L'G' && 'H' == L'H' && 'I' == L'I' && 'J' == L'J' && 245 'K' == L'K' && 'L' == L'L' && 'M' == L'M' && 'N' == L'N' && 'O' == L'O' && 246 'P' == L'P' && 'Q' == L'Q' && 'R' == L'R' && 'S' == L'S' && 'T' == L'T' && 247 'U' == L'U' && 'V' == L'V' && 'W' == L'W' && 'X' == L'X' && 'Y' == L'Y' && 248 'Z' == L'Z' && // 249 '0' == L'0' && '1' == L'1' && '2' == L'2' && '3' == L'3' && '4' == L'4' && 250 '5' == L'5' && '6' == L'6' && '7' == L'7' && '8' == L'8' && 251 '9' == L'9' && // 252 '_' == L'_' && '{' == L'{' && '}' == L'}' && '[' == L'[' && ']' == L']' && 253 '#' == L'#' && '(' == L'(' && ')' == L')' && '<' == L'<' && '>' == L'>' && 254 '%' == L'%' && ':' == L':' && ';' == L';' && '.' == L'.' && '?' == L'?' && 255 '*' == L'*' && '+' == L'+' && '-' == L'-' && '/' == L'/' && '^' == L'^' && 256 '&' == L'&' && '|' == L'|' && '~' == L'~' && '!' == L'!' && '=' == L'=' && 257 ',' == L',' && '\\' == L'\\' && '"' == L'"' && '\'' == L'\''; 258 #if __STDC_MB_MIGHT_NEQ_WC__ 259 #ifndef __FreeBSD__ // PR22208, FreeBSD expects us to give a bad (but conforming) answer here. 260 _Static_assert(!MB_EQ_WC, "__STDC_MB_MIGHT_NEQ_WC__ but all basic source characters have same representation"); // expected-error {{C11}} 261 #endif 262 #else 263 _Static_assert(MB_EQ_WC, "!__STDC_MB_MIGHT_NEQ_WC__ but some character differs"); // expected-error {{C11}} 264 #endif 265 } 266 267 // dr631: na 268 269 namespace dr632 { // dr632: yes 270 struct S { int n; } s = {{5}}; // expected-warning {{braces}} 271 } 272 273 // dr633: na 274 // see also n2993 275 276 namespace dr634 { // dr634: yes 277 struct S { S(); S(const S&); virtual void f(); ~S(); }; 278 int f(...); 279 char f(int); 280 template<typename T> int (&g(T))[sizeof f(T())]; 281 int (&a)[sizeof(int)] = g(S()); 282 int (&b)[1] = g(0); 283 int k = f(S()); // expected-error {{cannot pass}} 284 } 285 286 namespace dr635 { // dr635: yes 287 template<typename T> struct A { A(); ~A(); }; A()288 template<typename T> A<T>::A<T>() {} // expected-error {{cannot have template arguments}} ~A()289 template<typename T> A<T>::~A<T>() {} 290 291 template<typename T> struct B { B(); ~B(); }; B()292 template<typename T> B<T>::B() {} ~B()293 template<typename T> B<T>::~B() {} 294 295 struct C { template<typename T> C(); C(); }; C()296 template<typename T> C::C() {} C()297 C::C() {} C()298 template<> C::C<int>() {} // expected-error {{constructor name}} expected-error {{unqualified-id}} 299 /*FIXME: needed for error recovery:*/; 300 301 template<typename T> struct D { template<typename U> D(); D(); }; D()302 template<typename T> D<T>::D() {} // expected-note {{previous}} D()303 template<typename T> template<typename U> D<T>::D() {} D()304 template<typename T> D<T>::D<T>() {} // expected-error {{redefinition}} expected-error {{cannot have template arg}} 305 } 306 307 namespace dr637 { // dr637: yes f(int i)308 void f(int i) { 309 i = ++i + 1; 310 i = i++ + 1; // expected-warning {{unsequenced}} 311 } 312 } 313 314 namespace dr638 { // dr638: no 315 template<typename T> struct A { 316 struct B; 317 void f(); 318 void g(); 319 struct C { 320 void h(); 321 }; 322 }; 323 324 class X { 325 typedef int type; 326 template<class T> friend struct A<T>::B; // expected-warning {{not supported}} 327 template<class T> friend void A<T>::f(); // expected-warning {{not supported}} 328 template<class T> friend void A<T>::g(); // expected-warning {{not supported}} 329 template<class T> friend void A<T>::C::h(); // expected-warning {{not supported}} 330 }; 331 332 template<> struct A<int> { 333 X::type a; // FIXME: private 334 struct B { 335 X::type b; // ok 336 }; fdr638::A337 int f() { X::type c; } // FIXME: private gdr638::A338 void g() { X::type d; } // ok 339 struct D { hdr638::A::D340 void h() { X::type e; } // FIXME: private 341 }; 342 }; 343 } 344 345 namespace dr639 { // dr639: yes f(int i)346 void f(int i) { 347 void((i = 0) + (i = 0)); // expected-warning {{unsequenced}} 348 } 349 } 350