1 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2 // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 3 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 4 // RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 5 6 namespace dr100 { // dr100: yes 7 template<const char *> struct A {}; // expected-note 0-1{{declared here}} 8 template<const char (&)[4]> struct B {}; // expected-note 0-1{{declared here}} 9 A<"foo"> a; // expected-error {{does not refer to any declaration}} 10 B<"bar"> b; // expected-error {{does not refer to any declaration}} 11 } 12 13 namespace dr101 { // dr101: 3.5 14 extern "C" void dr101_f(); 15 typedef unsigned size_t; 16 namespace X { 17 extern "C" void dr101_f(); 18 typedef unsigned size_t; 19 } 20 using X::dr101_f; 21 using X::size_t; 22 extern "C" void dr101_f(); 23 typedef unsigned size_t; 24 } 25 26 namespace dr102 { // dr102: yes 27 namespace A { f(T a,T b)28 template<typename T> T f(T a, T b) { return a + b; } // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}} 29 } 30 namespace B { 31 struct S {}; 32 } 33 B::S operator+(B::S, B::S); // expected-note {{should be declared prior to the call site or in namespace 'dr102::B'}} 34 template B::S A::f(B::S, B::S); // expected-note {{in instantiation of}} 35 } 36 37 // dr103: na 38 // dr104 FIXME: add codegen test 39 // dr105: na 40 41 namespace dr106 { // dr106: sup 540 42 typedef int &r1; 43 typedef r1 &r1; 44 typedef const r1 r1; // expected-warning {{has no effect}} 45 typedef const r1 &r1; // expected-warning {{has no effect}} 46 47 typedef const int &r2; 48 typedef r2 &r2; 49 typedef const r2 r2; // expected-warning {{has no effect}} 50 typedef const r2 &r2; // expected-warning {{has no effect}} 51 } 52 53 namespace dr107 { // dr107: yes 54 struct S {}; operator +(S,S)55 extern "C" S operator+(S, S) { return S(); } 56 } 57 58 namespace dr108 { // dr108: yes 59 template<typename T> struct A { 60 struct B { typedef int X; }; 61 B::X x; // expected-error {{missing 'typename'}} 62 struct C : B { X x; }; // expected-error {{unknown type name}} 63 }; 64 template<> struct A<int>::B { int X; }; 65 } 66 67 namespace dr109 { // dr109: yes 68 struct A { template<typename T> void f(T); }; 69 template<typename T> struct B : T { 70 using T::template f; // expected-error {{using declaration cannot refer to a template}} gdr109::B71 void g() { this->f<int>(123); } // expected-error {{use 'template'}} 72 }; 73 } 74 75 namespace dr111 { // dr111: dup 535 76 struct A { A(); A(volatile A&, int = 0); A(A&, const char * = "foo"); }; 77 struct B : A { B(); }; // expected-note +{{would lose const qualifier}} expected-note {{requires 0 arguments}} 78 const B b1; 79 B b2(b1); // expected-error {{no matching constructor}} 80 } 81 82 namespace dr112 { // dr112: yes 83 struct T { int n; }; 84 typedef T Arr[1]; 85 86 const T a1[1] = {}; 87 volatile T a2[1] = {}; 88 const Arr a3 = {}; 89 volatile Arr a4 = {}; 90 template<const volatile T*> struct X {}; 91 X<a1> x1; 92 X<a2> x2; 93 X<a3> x3; 94 X<a4> x4; 95 #if __cplusplus < 201103L 96 // expected-error@-5 {{internal linkage}} expected-note@-10 {{here}} 97 // expected-error@-4 {{internal linkage}} expected-note@-9 {{here}} 98 #else 99 // FIXME: Test this somehow. 100 #endif 101 } 102 103 namespace dr113 { // dr113: yes 104 extern void (*p)(); f()105 void f() { 106 no_such_function(); // expected-error {{undeclared}} 107 p(); 108 } 109 void g(); 110 void (*p)() = &g; 111 } 112 113 namespace dr114 { // dr114: yes 114 struct A { 115 virtual void f(int) = 0; // expected-note {{unimplemented}} 116 }; 117 struct B : A { 118 template<typename T> void f(T); gdr114::B119 void g() { f(0); } 120 } b; // expected-error {{abstract}} 121 } 122 123 namespace dr115 { // dr115: yes 124 template<typename T> int f(T); // expected-note +{{}} 125 template<typename T> int g(T); // expected-note +{{}} 126 template<typename T> int g(T, int); // expected-note +{{}} 127 128 int k1 = f(&f); // expected-error {{no match}} 129 int k2 = f(&f<int>); 130 int k3 = f(&g<int>); // expected-error {{no match}} 131 h()132 void h() { 133 (void)&f; // expected-error {{address of overloaded function 'f' cannot be cast to type 'void'}} 134 (void)&f<int>; 135 (void)&g<int>; // expected-error {{address of overloaded function 'g' cannot be cast to type 'void'}} 136 137 &f; // expected-error {{reference to overloaded function could not be resolved}} 138 &f<int>; // expected-warning {{unused}} 139 &g<int>; // expected-error {{reference to overloaded function could not be resolved}} 140 } 141 142 struct S { 143 template<typename T> static int f(T); 144 template<typename T> static int g(T); 145 template<typename T> static int g(T, int); 146 } s; 147 148 int k4 = f(&s.f); // expected-error {{non-constant pointer to member}} 149 int k5 = f(&s.f<int>); 150 int k6 = f(&s.g<int>); // expected-error {{non-constant pointer to member}} 151 i()152 void i() { 153 (void)&s.f; // expected-error {{non-constant pointer to member}} 154 (void)&s.f<int>; 155 (void)&s.g<int>; // expected-error {{non-constant pointer to member}} 156 157 &s.f; // expected-error {{non-constant pointer to member}} 158 &s.f<int>; // expected-warning {{unused}} 159 &s.g<int>; // expected-error {{non-constant pointer to member}} 160 } 161 162 struct T { 163 template<typename T> int f(T); 164 template<typename T> int g(T); 165 template<typename T> int g(T, int); 166 } t; 167 168 int k7 = f(&s.f); // expected-error {{non-constant pointer to member}} 169 int k8 = f(&s.f<int>); 170 int k9 = f(&s.g<int>); // expected-error {{non-constant pointer to member}} 171 j()172 void j() { 173 (void)&s.f; // expected-error {{non-constant pointer to member}} 174 (void)&s.f<int>; 175 (void)&s.g<int>; // expected-error {{non-constant pointer to member}} 176 177 &s.f; // expected-error {{non-constant pointer to member}} 178 &s.f<int>; // expected-warning {{unused}} 179 &s.g<int>; // expected-error {{non-constant pointer to member}} 180 } 181 182 #if __cplusplus >= 201103L 183 // Special case kicks in only if a template argument list is specified. 184 template<typename T=int> void with_default(); // expected-note +{{}} 185 int k10 = f(&with_default); // expected-error {{no matching function}} 186 int k11 = f(&with_default<>); k()187 void k() { 188 (void)&with_default; // expected-error {{overloaded function}} 189 (void)&with_default<>; 190 &with_default; // expected-error {{overloaded function}} 191 &with_default<>; // expected-warning {{unused}} 192 } 193 #endif 194 } 195 196 namespace dr116 { // dr116: yes 197 template<int> struct A {}; f(A<N>)198 template<int N> void f(A<N>) {} // expected-note {{previous}} f(A<M>)199 template<int M> void f(A<M>) {} // expected-error {{redefinition}} f(A<sizeof (T)>)200 template<typename T> void f(A<sizeof(T)>) {} // expected-note {{previous}} f(A<sizeof (U)>)201 template<typename U> void f(A<sizeof(U)>) {} // expected-error {{redefinition}} 202 } 203 204 // dr117: na 205 // dr118 FIXME: add codegen test 206 // dr119: na 207 // dr120: na 208 209 namespace dr121 { // dr121: yes 210 struct X { 211 template<typename T> struct Y {}; 212 }; 213 template<typename T> struct Z { 214 X::Y<T> x; 215 T::Y<T> y; // expected-error +{{}} 216 }; 217 Z<X> z; 218 } 219 220 namespace dr122 { // dr122: yes 221 template<typename T> void f(); g()222 void g() { f<int>(); } 223 } 224 225 // dr123: na 226 // dr124: dup 201 227 228 // dr125: yes 229 struct dr125_A { struct dr125_B {}; }; // expected-note {{here}} 230 dr125_A::dr125_B dr125_C(); 231 namespace dr125_B { dr125_A dr125_C(); } 232 namespace dr125 { 233 struct X { 234 friend dr125_A::dr125_B (::dr125_C)(); // ok 235 friend dr125_A (::dr125_B::dr125_C)(); // ok 236 friend dr125_A::dr125_B::dr125_C(); // expected-error {{did you mean the constructor name 'dr125_B'?}} 237 // expected-error@-1 {{missing exception specification}} 238 #if __cplusplus >= 201103L 239 // expected-error@-3 {{follows constexpr declaration}} expected-note@-10 {{here}} 240 #endif 241 }; 242 } 243 244 namespace dr126 { // dr126: no 245 struct C {}; 246 struct D : C {}; 247 struct E : private C { friend class A; friend class B; }; 248 struct F : protected C {}; 249 struct G : C {}; 250 struct H : D, G {}; 251 252 struct A { 253 virtual void cp() throw(C*); 254 virtual void dp() throw(C*); 255 virtual void ep() throw(C*); // expected-note {{overridden}} 256 virtual void fp() throw(C*); // expected-note {{overridden}} 257 virtual void gp() throw(C*); 258 virtual void hp() throw(C*); // expected-note {{overridden}} 259 260 virtual void cr() throw(C&); 261 virtual void dr() throw(C&); 262 virtual void er() throw(C&); // expected-note {{overridden}} 263 virtual void fr() throw(C&); // expected-note {{overridden}} 264 virtual void gr() throw(C&); 265 virtual void hr() throw(C&); // expected-note {{overridden}} 266 267 virtual void pv() throw(void*); // expected-note {{overridden}} 268 269 #if __cplusplus >= 201103L 270 virtual void np() throw(C*); // expected-note {{overridden}} 271 virtual void npm() throw(int C::*); // expected-note {{overridden}} 272 virtual void nr() throw(C&); // expected-note {{overridden}} 273 #endif 274 275 virtual void ref1() throw(C *const&); 276 virtual void ref2() throw(C *); 277 278 virtual void v() throw(int); 279 virtual void w() throw(const int); 280 virtual void x() throw(int*); 281 virtual void y() throw(const int*); 282 virtual void z() throw(int); // expected-note {{overridden}} 283 }; 284 struct B : A { 285 virtual void cp() throw(C*); 286 virtual void dp() throw(D*); 287 virtual void ep() throw(E*); // expected-error {{more lax}} 288 virtual void fp() throw(F*); // expected-error {{more lax}} 289 virtual void gp() throw(G*); 290 virtual void hp() throw(H*); // expected-error {{more lax}} 291 292 virtual void cr() throw(C&); 293 virtual void dr() throw(D&); 294 virtual void er() throw(E&); // expected-error {{more lax}} 295 virtual void fr() throw(F&); // expected-error {{more lax}} 296 virtual void gr() throw(G&); 297 virtual void hr() throw(H&); // expected-error {{more lax}} 298 299 virtual void pv() throw(C*); // expected-error {{more lax}} FIXME: This is valid. 300 301 #if __cplusplus >= 201103L 302 using nullptr_t = decltype(nullptr); 303 virtual void np() throw(nullptr_t*); // expected-error {{more lax}} FIXME: This is valid. 304 virtual void npm() throw(nullptr_t*); // expected-error {{more lax}} FIXME: This is valid. 305 virtual void nr() throw(nullptr_t&); // expected-error {{more lax}} This is not. 306 #endif 307 308 virtual void ref1() throw(D *const &); 309 virtual void ref2() throw(D *); 310 311 virtual void v() throw(const int); 312 virtual void w() throw(int); 313 virtual void x() throw(const int*); // FIXME: 'const int*' is not allowed by A::h. 314 virtual void y() throw(int*); // ok 315 virtual void z() throw(long); // expected-error {{more lax}} 316 }; 317 } 318 319 namespace dr127 { // dr127: yes 320 __extension__ typedef __decltype(sizeof(0)) size_t; 321 template<typename T> struct A { 322 A() throw(int); 323 void *operator new(size_t, const char * = 0); operator deletedr127::A324 void operator delete(void *, const char *) { T::error; } // expected-error 2{{no members}} operator deletedr127::A325 void operator delete(void *) { T::error; } 326 }; 327 A<void> *p = new A<void>; // expected-note {{instantiat}} 328 A<int> *q = new ("") A<int>; // expected-note {{instantiat}} 329 } 330 331 namespace dr128 { // dr128: yes 332 enum E1 { e1 } x = e1; 333 enum E2 { e2 } y = static_cast<E2>(x), z = static_cast<E2>(e1); 334 } 335 336 // dr129: dup 616 337 // dr130: na 338 339 namespace dr131 { // dr131: yes 340 const char *a_with_\u0e8c = "\u0e8c"; 341 const char *b_with_\u0e8d = "\u0e8d"; 342 const char *c_with_\u0e8e = "\u0e8e"; 343 #if __cplusplus < 201103L 344 // expected-error@-4 {{expected ';'}} expected-error@-2 {{expected ';'}} 345 #endif 346 } 347 348 namespace dr132 { // dr132: no f()349 void f() { 350 extern struct {} x; // ok 351 extern struct S {} y; // FIXME: This is invalid. 352 } 353 static enum { E } e; 354 } 355 356 // dr133: dup 87 357 // dr134: na 358 359 namespace dr135 { // dr135: yes 360 struct A { fdr135::A361 A f(A a) { return a; } g(A a)362 friend A g(A a) { return a; } hdr135::A363 static A h(A a) { return a; } 364 }; 365 } 366 367 namespace dr136 { // dr136: 3.4 368 void f(int, int, int = 0); // expected-note {{previous declaration is here}} 369 void g(int, int, int); // expected-note {{previous declaration is here}} 370 struct A { 371 friend void f(int, int = 0, int); // expected-error {{friend declaration specifying a default argument must be the only declaration}} 372 friend void g(int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}} 373 friend void h(int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be a definition}} i(int,int,int=0)374 friend void i(int, int, int = 0) {} // expected-note {{previous declaration is here}} j(int,int,int=0)375 friend void j(int, int, int = 0) {} 376 operator int(); 377 }; 378 void i(int, int, int); // expected-error {{friend declaration specifying a default argument must be the only declaration}} q()379 void q() { 380 j(A(), A()); // ok, has default argument 381 } 382 extern "C" void k(int, int, int, int); // expected-note {{previous declaration is here}} 383 namespace NSA { 384 struct A { 385 friend void dr136::k(int, int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}} \ 386 // expected-note {{previous declaration is here}} 387 }; 388 } 389 namespace NSB { 390 struct A { 391 friend void dr136::k(int, int, int = 0, int); // expected-error {{friend declaration specifying a default argument must be the only declaration}} 392 }; 393 } 394 struct B { 395 void f(int); // expected-note {{previous declaration is here}} 396 }; 397 struct C { 398 friend void B::f(int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}} 399 }; 400 } 401 402 namespace dr137 { // dr137: yes 403 extern void *p; 404 extern const void *cp; 405 extern volatile void *vp; 406 extern const volatile void *cvp; 407 int *q = static_cast<int*>(p); 408 int *qc = static_cast<int*>(cp); // expected-error {{casts away qualifiers}} 409 int *qv = static_cast<int*>(vp); // expected-error {{casts away qualifiers}} 410 int *qcv = static_cast<int*>(cvp); // expected-error {{casts away qualifiers}} 411 const int *cq = static_cast<const int*>(p); 412 const int *cqc = static_cast<const int*>(cp); 413 const int *cqv = static_cast<const int*>(vp); // expected-error {{casts away qualifiers}} 414 const int *cqcv = static_cast<const int*>(cvp); // expected-error {{casts away qualifiers}} 415 const volatile int *cvq = static_cast<const volatile int*>(p); 416 const volatile int *cvqc = static_cast<const volatile int*>(cp); 417 const volatile int *cvqv = static_cast<const volatile int*>(vp); 418 const volatile int *cvqcv = static_cast<const volatile int*>(cvp); 419 } 420 421 namespace dr139 { // dr139: yes 422 namespace example1 { 423 typedef int f; // expected-note {{previous}} 424 struct A { 425 friend void f(A &); // expected-error {{different kind of symbol}} 426 }; 427 } 428 429 namespace example2 { 430 typedef int f; 431 namespace N { 432 struct A { 433 friend void f(A &); 434 operator int(); gdr139::example2::N::A435 void g(A a) { int i = f(a); } // ok, f is typedef not friend function 436 }; 437 } 438 } 439 } 440 441 namespace dr140 { // dr140: yes f(int * const)442 void f(int *const) {} // expected-note {{previous}} f(int[3])443 void f(int[3]) {} // expected-error {{redefinition}} 444 void g(const int); g(int n)445 void g(int n) { n = 2; } 446 } 447 448 namespace dr141 { // dr141: yes 449 template<typename T> void f(); 450 template<typename T> struct S { int n; }; 451 struct A : S<int> { 452 template<typename T> void f(); 453 template<typename T> struct S {}; 454 } a; 455 struct B : S<int> {} b; g()456 void g() { 457 a.f<int>(); 458 (void)a.S<int>::n; // expected-error {{no member named 'n'}} 459 #if __cplusplus < 201103L 460 // expected-error@-2 {{ambiguous}} 461 // expected-note@-11 {{lookup from the current scope}} 462 // expected-note@-9 {{lookup in the object type}} 463 #endif 464 b.f<int>(); // expected-error {{no member}} expected-error +{{}} 465 (void)b.S<int>::n; 466 } 467 template<typename T> struct C { 468 T t; gdr141::C469 void g() { 470 t.f<int>(); // expected-error {{use 'template'}} 471 } hdr141::C472 void h() { 473 (void)t.S<int>::n; // ok 474 } idr141::C475 void i() { 476 (void)t.S<int>(); // ok! 477 } 478 }; h()479 void h() { C<B>().h(); } // ok 480 struct X { 481 template<typename T> void S(); 482 }; i()483 void i() { C<X>().i(); } // ok!! 484 } 485 486 namespace dr142 { // dr142: yes 487 class B { // expected-note +{{here}} 488 public: 489 int mi; // expected-note +{{here}} 490 static int si; // expected-note +{{here}} 491 }; 492 class D : private B { // expected-note +{{here}} 493 }; 494 class DD : public D { 495 void f(); 496 }; f()497 void DD::f() { 498 mi = 3; // expected-error {{private base class}} expected-error {{private member}} 499 si = 3; // expected-error {{private member}} 500 B b_old; // expected-error {{private member}} 501 dr142::B b; 502 b.mi = 3; 503 b.si = 3; 504 B::si = 3; // expected-error {{private member}} 505 dr142::B::si = 3; 506 B *bp1_old = this; // expected-error {{private member}} expected-error {{private base class}} 507 dr142::B *bp1 = this; // expected-error {{private base class}} 508 B *bp2_old = (B*)this; // expected-error 2{{private member}} 509 dr142::B *bp2 = (dr142::B*)this; 510 bp2->mi = 3; 511 } 512 } 513 514 namespace dr143 { // dr143: yes 515 namespace A { struct X; } 516 namespace B { void f(A::X); } 517 namespace A { 518 struct X { friend void B::f(X); }; 519 } g(A::X x)520 void g(A::X x) { 521 f(x); // expected-error {{undeclared identifier 'f'}} 522 } 523 } 524 525 namespace dr145 { // dr145: yes f(bool b)526 void f(bool b) { 527 #if __cplusplus <= 201402L 528 ++b; // expected-warning {{deprecated}} 529 b++; // expected-warning {{deprecated}} 530 #else 531 ++b; // expected-error {{increment}} 532 b++; // expected-error {{increment}} 533 #endif 534 } 535 } 536 537 namespace dr147 { // dr147: no 538 namespace example1 { 539 template<typename> struct A { 540 template<typename T> A(T); 541 }; 542 // FIXME: This appears to be valid, and EDG and G++ accept. A(int)543 template<> template<> A<int>::A<int>(int) {} // expected-error {{out-of-line constructor for 'A' cannot have template arguments}} 544 } 545 namespace example2 { 546 struct A { A(); }; 547 struct B : A { B(); }; 548 A::A a1; // expected-error {{is a constructor}} 549 B::A a2; 550 } 551 namespace example3 { 552 template<typename> struct A { 553 template<typename T> A(T); 554 static A a; 555 }; 556 template<> A<int>::A<int>(A<int>::a); // expected-error {{is a constructor}} 557 } 558 } 559 560 namespace dr148 { // dr148: yes 561 struct A { int A::*p; }; 562 int check1[__is_pod(int(A::*)) ? 1 : -1]; 563 int check2[__is_pod(A) ? 1 : -1]; 564 } 565 566 // dr149: na 567 568 namespace dr151 { // dr151: yes 569 struct X {}; 570 typedef int X::*p; 571 #if __cplusplus < 201103L 572 #define fold(x) (__builtin_constant_p(0) ? (x) : (x)) 573 #else 574 #define fold 575 #endif 576 int check[fold(p() == 0) ? 1 : -1]; 577 #undef fold 578 } 579 580 namespace dr152 { // dr152: yes 581 struct A { 582 A(); // expected-note {{not viable}} 583 explicit A(const A&); 584 }; 585 A a1 = A(); // expected-error {{no matching constructor}} 586 A a2((A())); 587 } 588 589 // dr153: na 590 591 namespace dr154 { // dr154: yes 592 union { int a; }; // expected-error {{must be declared 'static'}} 593 namespace { 594 union { int b; }; 595 } 596 static union { int c; }; 597 } 598 599 namespace dr155 { // dr155: dup 632 600 struct S { int n; } s = { { 1 } }; // expected-warning {{braces around scalar initializer}} 601 } 602 603 // dr158 FIXME write codegen test 604 605 namespace dr159 { // dr159: 3.5 606 namespace X { void f(); } 607 void f(); f()608 void dr159::f() {} // expected-warning {{extra qualification}} f()609 void dr159::X::f() {} 610 } 611 612 // dr160: na 613 614 namespace dr161 { // dr161: yes 615 class A { 616 protected: 617 struct B { int n; } b; // expected-note 2{{here}} 618 static B bs; 619 void f(); // expected-note {{here}} 620 static void sf(); 621 }; 622 struct C : A {}; 623 struct D : A { gdr161::D624 void g(C c) { 625 (void)b.n; 626 B b1; 627 C::B b2; // ok, accessible as a member of A 628 (void)&C::b; // expected-error {{protected}} 629 (void)&C::bs; 630 (void)c.b; // expected-error {{protected}} 631 (void)c.bs; 632 f(); 633 sf(); 634 c.f(); // expected-error {{protected}} 635 c.sf(); 636 A::f(); 637 D::f(); 638 A::sf(); 639 C::sf(); 640 D::sf(); 641 } 642 }; 643 } 644 645 namespace dr162 { // dr162: no 646 struct A { 647 char &f(char); 648 static int &f(int); 649 gdr162::A650 void g() { 651 int &a = (&A::f)(0); // FIXME: expected-error {{could not be resolved}} 652 char &b = (&A::f)('0'); // expected-error {{could not be resolved}} 653 } 654 }; 655 656 int &c = (&A::f)(0); // FIXME: expected-error {{could not be resolved}} 657 char &d = (&A::f)('0'); // expected-error {{could not be resolved}} 658 } 659 660 // dr163: na 661 662 namespace dr164 { // dr164: yes 663 void f(int); g(T t)664 template <class T> int g(T t) { return f(t); } 665 666 enum E { e }; 667 int f(E); 668 669 int k = g(e); 670 } 671 672 namespace dr165 { // dr165: no 673 namespace N { 674 struct A { friend struct B; }; f()675 void f() { void g(); } 676 } 677 // FIXME: dr1477 says this is ok, dr165 says it's ill-formed 678 struct N::B {}; 679 // FIXME: dr165 says this is ill-formed, but the argument in dr1477 says it's ok g()680 void N::g() {} 681 } 682 683 namespace dr166 { // dr166: yes 684 namespace A { class X; } 685 f(T t)686 template<typename T> int f(T t) { return t.n; } 687 int g(A::X); h(T t)688 template<typename T> int h(T t) { return t.n; } // expected-error {{private}} 689 int i(A::X); 690 691 namespace A { 692 class X { 693 friend int f<X>(X); 694 friend int dr166::g(X); 695 friend int h(X); 696 friend int i(X); 697 int n; // expected-note 2{{here}} 698 }; 699 h(X x)700 int h(X x) { return x.n; } i(X x)701 int i(X x) { return x.n; } 702 } 703 704 template int f(A::X); g(A::X x)705 int g(A::X x) { return x.n; } 706 template int h(A::X); // expected-note {{instantiation}} i(A::X x)707 int i(A::X x) { return x.n; } // expected-error {{private}} 708 } 709 710 // dr167: sup 1012 711 712 namespace dr168 { // dr168: no 713 extern "C" typedef int (*p)(); 714 extern "C++" typedef int (*q)(); 715 struct S { 716 static int f(); 717 }; 718 p a = &S::f; // FIXME: this should fail. 719 q b = &S::f; 720 } 721 722 namespace dr169 { // dr169: yes 723 template<typename> struct A { int n; }; 724 struct B { 725 template<typename> struct C; 726 template<typename> void f(); 727 template<typename> static int n; // expected-error 0-1{{extension}} 728 }; 729 struct D : A<int>, B { 730 using A<int>::n; 731 using B::C<int>; // expected-error {{using declaration cannot refer to a template specialization}} 732 using B::f<int>; // expected-error {{using declaration cannot refer to a template specialization}} 733 using B::n<int>; // expected-error {{using declaration cannot refer to a template specialization}} 734 }; 735 } 736 737 namespace { // dr171: yes 738 int dr171a; 739 } 740 int dr171b; // expected-note {{here}} 741 namespace dr171 { 742 extern "C" void dr171a(); 743 extern "C" void dr171b(); // expected-error {{conflicts}} 744 } 745 746 namespace dr172 { // dr172: yes 747 enum { zero }; 748 int check1[-1 < zero ? 1 : -1]; 749 750 enum { x = -1, y = (unsigned int)-1 }; 751 int check2[sizeof(x) > sizeof(int) ? 1 : -1]; 752 753 enum { a = (unsigned int)-1 / 2 }; 754 int check3a[sizeof(a) == sizeof(int) ? 1 : -1]; 755 int check3b[-a < 0 ? 1 : -1]; 756 757 enum { b = (unsigned int)-1 / 2 + 1 }; 758 int check4a[sizeof(b) == sizeof(unsigned int) ? 1 : -1]; 759 int check4b[-b > 0 ? 1 : -1]; 760 761 enum { c = (unsigned long)-1 / 2 }; 762 int check5a[sizeof(c) == sizeof(long) ? 1 : -1]; 763 int check5b[-c < 0 ? 1 : -1]; 764 765 enum { d = (unsigned long)-1 / 2 + 1 }; 766 int check6a[sizeof(d) == sizeof(unsigned long) ? 1 : -1]; 767 int check6b[-d > 0 ? 1 : -1]; 768 769 enum { e = (unsigned long long)-1 / 2 }; // expected-error 0-1{{extension}} 770 int check7a[sizeof(e) == sizeof(long) ? 1 : -1]; // expected-error 0-1{{extension}} 771 int check7b[-e < 0 ? 1 : -1]; 772 773 enum { f = (unsigned long long)-1 / 2 + 1 }; // expected-error 0-1{{extension}} 774 int check8a[sizeof(f) == sizeof(unsigned long) ? 1 : -1]; // expected-error 0-1{{extension}} 775 int check8b[-f > 0 ? 1 : -1]; 776 } 777 778 namespace dr173 { // dr173: yes 779 int check[('0' + 1 == '1' && '0' + 2 == '2' && '0' + 3 == '3' && 780 '0' + 4 == '4' && '0' + 5 == '5' && '0' + 6 == '6' && 781 '0' + 7 == '7' && '0' + 8 == '8' && '0' + 9 == '9') ? 1 : -1]; 782 } 783 784 // dr174: sup 1012 785 786 namespace dr175 { // dr175: yes 787 struct A {}; // expected-note {{here}} 788 struct B : private A {}; // expected-note {{constrained by private inheritance}} 789 struct C : B { 790 A a; // expected-error {{private}} 791 dr175::A b; 792 }; 793 } 794 795 namespace dr176 { // dr176: yes 796 template<typename T> class Y; 797 template<> class Y<int> { f()798 void f() { 799 typedef Y A; // expected-note {{here}} 800 typedef Y<char> A; // expected-error {{different types ('Y<char>' vs 'Y<int>')}} 801 } 802 }; 803 804 template<typename T> struct Base {}; // expected-note 2{{found}} 805 template<typename T> struct Derived : public Base<T> { fdr176::Derived806 void f() { 807 typedef typename Derived::template Base<T> A; 808 typedef typename Derived::Base A; 809 } 810 }; 811 template struct Derived<int>; 812 813 template<typename T> struct Derived2 : Base<int>, Base<char> { 814 typename Derived2::Base b; // expected-error {{found in multiple base classes}} 815 typename Derived2::Base<double> d; 816 }; 817 818 template<typename T> class X { // expected-note {{here}} 819 X *p1; 820 X<T> *p2; 821 X<int> *p3; 822 dr176::X *p4; // expected-error {{requires template arguments}} 823 }; 824 } 825 826 namespace dr177 { // dr177: yes 827 struct B {}; 828 struct A { 829 A(A &); // expected-note {{not viable: expects an l-value}} 830 A(const B &); 831 }; 832 B b; 833 A a = b; // expected-error {{no viable constructor copying variable}} 834 } 835 836 namespace dr178 { // dr178: yes 837 int check[int() == 0 ? 1 : -1]; 838 #if __cplusplus >= 201103L 839 static_assert(int{} == 0, ""); 840 struct S { int a, b; }; 841 static_assert(S{1}.b == 0, ""); Tdr178::T842 struct T { constexpr T() : n() {} int n; }; 843 static_assert(T().n == 0, ""); Udr178::U844 struct U : S { constexpr U() : S() {} }; 845 static_assert(U().b == 0, ""); 846 #endif 847 } 848 849 namespace dr179 { // dr179: yes 850 void f(); 851 int n = &f - &f; // expected-error {{arithmetic on pointers to the function type 'void ()'}} 852 } 853 854 namespace dr180 { // dr180: yes 855 template<typename T> struct X : T, T::some_base { Xdr180::X856 X() : T::some_type_that_might_be_T(), T::some_base() {} 857 friend class T::some_class; fdr180::X858 void f() { 859 enum T::some_enum e; 860 } 861 }; 862 } 863 864 namespace dr181 { // dr181: yes 865 namespace X { 866 template <template X<class T> > struct A { }; // expected-error +{{}} 867 template <template X<class T> > void f(A<X>) { } // expected-error +{{}} 868 } 869 870 namespace Y { 871 template <template <class T> class X> struct A { }; 872 template <template <class T> class X> void f(A<X>) { } 873 } 874 } 875 876 namespace dr182 { // dr182: yes 877 template <class T> struct C { 878 void f(); 879 void g(); 880 }; 881 882 template <class T> void C<T>::f() {} 883 template <class T> void C<T>::g() {} 884 885 class A { 886 class B {}; // expected-note {{here}} 887 void f(); 888 }; 889 890 template void C<A::B>::f(); 891 template <> void C<A::B>::g(); // expected-error {{private}} 892 893 void A::f() { 894 C<B> cb; 895 cb.f(); 896 } 897 } 898 899 namespace dr183 { // dr183: sup 382 900 template<typename T> struct A {}; 901 template<typename T> struct B { 902 typedef int X; 903 }; 904 template<> struct A<int> { 905 typename B<int>::X x; 906 }; 907 } 908 909 namespace dr184 { // dr184: yes 910 template<typename T = float> struct B {}; 911 912 template<template<typename TT = float> class T> struct A { 913 void f(); 914 void g(); 915 }; 916 917 template<template<typename TT> class T> void A<T>::f() { // expected-note {{here}} 918 T<> t; // expected-error {{too few template arguments}} 919 } 920 921 template<template<typename TT = char> class T> void A<T>::g() { 922 T<> t; 923 typedef T<> X; 924 typedef T<char> X; 925 } 926 927 void h() { A<B>().g(); } 928 } 929 930 // dr185 FIXME: add codegen test 931 932 namespace dr187 { // dr187: sup 481 933 const int Z = 1; 934 template<int X = Z, int Z = X> struct A; 935 typedef A<> T; 936 typedef A<1, 1> T; 937 } 938 939 namespace dr188 { // dr188: yes 940 char c[10]; 941 int check[sizeof(0, c) == 10 ? 1 : -1]; 942 } 943 944 // dr190 FIXME: add codegen test for tbaa 945 946 // dr193 FIXME: add codegen test 947 948 namespace dr194 { // dr194: yes 949 struct A { 950 A(); 951 void A(); // expected-error {{constructor cannot have a return type}} 952 }; 953 struct B { 954 void B(); // expected-error {{constructor cannot have a return type}} 955 B(); 956 }; 957 struct C { 958 inline explicit C(int) {} 959 }; 960 } 961 962 namespace dr195 { // dr195: yes 963 void f(); 964 int *p = (int*)&f; // expected-error 0-1{{extension}} 965 void (*q)() = (void(*)())&p; // expected-error 0-1{{extension}} 966 } 967 968 namespace dr197 { // dr197: yes 969 char &f(char); 970 971 template <class T> void g(T t) { 972 char &a = f(1); 973 char &b = f(T(1)); // expected-error {{unrelated type 'int'}} 974 char &c = f(t); // expected-error {{unrelated type 'int'}} 975 } 976 977 void f(int); 978 979 enum E { e }; 980 int &f(E); 981 982 void h() { 983 g('a'); 984 g(2); 985 g(e); // expected-note {{in instantiation of}} 986 } 987 } 988 989 namespace dr198 { // dr198: yes 990 struct A { 991 int n; 992 struct B { 993 int m[sizeof(n)]; 994 #if __cplusplus < 201103L 995 // expected-error@-2 {{invalid use of non-static data member}} 996 #endif 997 int f() { return n; } 998 // expected-error@-1 {{use of non-static data member 'n' of 'A' from nested type 'B'}} 999 }; 1000 struct C; 1001 struct D; 1002 }; 1003 struct A::C { 1004 int m[sizeof(n)]; 1005 #if __cplusplus < 201103L 1006 // expected-error@-2 {{invalid use of non-static data member}} 1007 #endif 1008 int f() { return n; } 1009 // expected-error@-1 {{use of non-static data member 'n' of 'A' from nested type 'C'}} 1010 }; 1011 struct A::D : A { 1012 int m[sizeof(n)]; 1013 #if __cplusplus < 201103L 1014 // expected-error@-2 {{invalid use of non-static data member}} 1015 #endif 1016 int f() { return n; } 1017 }; 1018 } 1019 1020 // dr199 FIXME: add codegen test 1021