1e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 3176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 4176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 5e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith 6f696538f5e79a285cc453eba2eacdb3edab16ccaNAKAMURA Takumi// PR13819 -- __SIZE_TYPE__ is incompatible. 7651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinestypedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}} 8f696538f5e79a285cc453eba2eacdb3edab16ccaNAKAMURA Takumi 92c1721f12297bb881f7f9deb383fe6616d835272Richard Smith#if __cplusplus < 201103L 102c1721f12297bb881f7f9deb383fe6616d835272Richard Smith#define fold(x) (__builtin_constant_p(x) ? (x) : (x)) 112c1721f12297bb881f7f9deb383fe6616d835272Richard Smith#else 122c1721f12297bb881f7f9deb383fe6616d835272Richard Smith#define fold 132c1721f12297bb881f7f9deb383fe6616d835272Richard Smith#endif 142c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 15e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smithnamespace dr200 { // dr200: dup 214 16e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith template <class T> T f(int); 17e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith template <class T, class U> T f(U) = delete; // expected-error 0-1{{extension}} 18e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith 19e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith void g() { 20e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith f<int>(1); 21e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith } 22e9a5b3871f3d58fa226910fd8123c98fc8bc6c67Richard Smith} 232c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 242c1721f12297bb881f7f9deb383fe6616d835272Richard Smith// dr201 FIXME: write codegen test 252c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 262c1721f12297bb881f7f9deb383fe6616d835272Richard Smithnamespace dr202 { // dr202: yes 272c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template<typename T> T f(); 282c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template<int (*g)()> struct X { 292c1721f12297bb881f7f9deb383fe6616d835272Richard Smith int arr[fold(g == &f<int>) ? 1 : -1]; 302c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 312c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template struct X<f>; 322c1721f12297bb881f7f9deb383fe6616d835272Richard Smith} 332c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 342c1721f12297bb881f7f9deb383fe6616d835272Richard Smith// FIXME (export) dr204: no 352c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 362c1721f12297bb881f7f9deb383fe6616d835272Richard Smithnamespace dr206 { // dr206: yes 372c1721f12297bb881f7f9deb383fe6616d835272Richard Smith struct S; // expected-note 2{{declaration}} 382c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template<typename T> struct Q { S s; }; // expected-error {{incomplete}} 392c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template<typename T> void f() { S s; } // expected-error {{incomplete}} 402c1721f12297bb881f7f9deb383fe6616d835272Richard Smith} 412c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 422c1721f12297bb881f7f9deb383fe6616d835272Richard Smithnamespace dr207 { // dr207: yes 432c1721f12297bb881f7f9deb383fe6616d835272Richard Smith class A { 442c1721f12297bb881f7f9deb383fe6616d835272Richard Smith protected: 452c1721f12297bb881f7f9deb383fe6616d835272Richard Smith static void f() {} 462c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 472c1721f12297bb881f7f9deb383fe6616d835272Richard Smith class B : A { 482c1721f12297bb881f7f9deb383fe6616d835272Richard Smith public: 492c1721f12297bb881f7f9deb383fe6616d835272Richard Smith using A::f; 502c1721f12297bb881f7f9deb383fe6616d835272Richard Smith void g() { 512c1721f12297bb881f7f9deb383fe6616d835272Richard Smith A::f(); 522c1721f12297bb881f7f9deb383fe6616d835272Richard Smith f(); 532c1721f12297bb881f7f9deb383fe6616d835272Richard Smith } 542c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 552c1721f12297bb881f7f9deb383fe6616d835272Richard Smith} 562c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 572c1721f12297bb881f7f9deb383fe6616d835272Richard Smith// dr208 FIXME: write codegen test 582c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 592c1721f12297bb881f7f9deb383fe6616d835272Richard Smithnamespace dr209 { // dr209: yes 602c1721f12297bb881f7f9deb383fe6616d835272Richard Smith class A { 612c1721f12297bb881f7f9deb383fe6616d835272Richard Smith void f(); // expected-note {{here}} 622c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 632c1721f12297bb881f7f9deb383fe6616d835272Richard Smith class B { 642c1721f12297bb881f7f9deb383fe6616d835272Richard Smith friend void A::f(); // expected-error {{private}} 652c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 662c1721f12297bb881f7f9deb383fe6616d835272Richard Smith} 672c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 682c1721f12297bb881f7f9deb383fe6616d835272Richard Smith// dr210 FIXME: write codegen test 692c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 702c1721f12297bb881f7f9deb383fe6616d835272Richard Smithnamespace dr211 { // dr211: yes 712c1721f12297bb881f7f9deb383fe6616d835272Richard Smith struct A { 722c1721f12297bb881f7f9deb383fe6616d835272Richard Smith A() try { 732c1721f12297bb881f7f9deb383fe6616d835272Richard Smith throw 0; 742c1721f12297bb881f7f9deb383fe6616d835272Richard Smith } catch (...) { 752c1721f12297bb881f7f9deb383fe6616d835272Richard Smith return; // expected-error {{return in the catch of a function try block of a constructor}} 762c1721f12297bb881f7f9deb383fe6616d835272Richard Smith } 772c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 782c1721f12297bb881f7f9deb383fe6616d835272Richard Smith} 792c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 802c1721f12297bb881f7f9deb383fe6616d835272Richard Smithnamespace dr213 { // dr213: yes 812c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template <class T> struct A : T { 822c1721f12297bb881f7f9deb383fe6616d835272Richard Smith void h(T t) { 832c1721f12297bb881f7f9deb383fe6616d835272Richard Smith char &r1 = f(t); 842c1721f12297bb881f7f9deb383fe6616d835272Richard Smith int &r2 = g(t); // expected-error {{undeclared}} 852c1721f12297bb881f7f9deb383fe6616d835272Richard Smith } 862c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 872c1721f12297bb881f7f9deb383fe6616d835272Richard Smith struct B { 882c1721f12297bb881f7f9deb383fe6616d835272Richard Smith int &f(B); 892c1721f12297bb881f7f9deb383fe6616d835272Richard Smith int &g(B); // expected-note {{in dependent base class}} 902c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 912c1721f12297bb881f7f9deb383fe6616d835272Richard Smith char &f(B); 922c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 932c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template void A<B>::h(B); // expected-note {{instantiation}} 942c1721f12297bb881f7f9deb383fe6616d835272Richard Smith} 952c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 962c1721f12297bb881f7f9deb383fe6616d835272Richard Smithnamespace dr214 { // dr214: yes 972c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template<typename T, typename U> T checked_cast(U from) { U::error; } 982c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template<typename T, typename U> T checked_cast(U *from); 992c1721f12297bb881f7f9deb383fe6616d835272Richard Smith class C {}; 1002c1721f12297bb881f7f9deb383fe6616d835272Richard Smith void foo(int *arg) { checked_cast<const C *>(arg); } 1012c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 1022c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template<typename T> T f(int); 1032c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template<typename T, typename U> T f(U) { T::error; } 1042c1721f12297bb881f7f9deb383fe6616d835272Richard Smith void g() { 1052c1721f12297bb881f7f9deb383fe6616d835272Richard Smith f<int>(1); 1062c1721f12297bb881f7f9deb383fe6616d835272Richard Smith } 1072c1721f12297bb881f7f9deb383fe6616d835272Richard Smith} 1082c1721f12297bb881f7f9deb383fe6616d835272Richard Smith 1092c1721f12297bb881f7f9deb383fe6616d835272Richard Smithnamespace dr215 { // dr215: yes 1102c1721f12297bb881f7f9deb383fe6616d835272Richard Smith template<typename T> class X { 1112c1721f12297bb881f7f9deb383fe6616d835272Richard Smith friend void T::foo(); 1122c1721f12297bb881f7f9deb383fe6616d835272Richard Smith int n; 1132c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 1142c1721f12297bb881f7f9deb383fe6616d835272Richard Smith struct Y { 1152c1721f12297bb881f7f9deb383fe6616d835272Richard Smith void foo() { (void)+X<Y>().n; } 1162c1721f12297bb881f7f9deb383fe6616d835272Richard Smith }; 1172c1721f12297bb881f7f9deb383fe6616d835272Richard Smith} 118ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 119ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smithnamespace dr216 { // dr216: no 120ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith // FIXME: Should reject this: 'f' has linkage but its type does not, 121ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith // and 'f' is odr-used but not defined in this TU. 122ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith typedef enum { e } *E; 123ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void f(E); 124ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void g(E e) { f(e); } 125ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 126ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct S { 127ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith // FIXME: Should reject this: 'f' has linkage but its type does not, 128ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith // and 'f' is odr-used but not defined in this TU. 129ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith typedef enum { e } *E; 130ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void f(E); 131ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith }; 132ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void g(S s, S::E e) { s.f(e); } 133ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith} 134ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 135ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smithnamespace dr217 { // dr217: yes 136ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith template<typename T> struct S { 137ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void f(int); 138ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith }; 139ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith template<typename T> void S<T>::f(int = 0) {} // expected-error {{default arguments cannot be added}} 140ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith} 141ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 142ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smithnamespace dr218 { // dr218: yes 143ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith namespace A { 144ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct S {}; 145ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void f(S); 146ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith } 147ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith namespace B { 148ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct S {}; 149ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void f(S); 150ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith } 151ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 152ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct C { 153ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith int f; 154ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void test1(A::S as) { f(as); } // expected-error {{called object type 'int'}} 155ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void test2(A::S as) { void f(); f(as); } // expected-error {{too many arguments}} expected-note {{}} 156ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void test3(A::S as) { using A::f; f(as); } // ok 157ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void test4(A::S as) { using B::f; f(as); } // ok 158ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void test5(A::S as) { int f; f(as); } // expected-error {{called object type 'int'}} 159ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void test6(A::S as) { struct f {}; (void) f(as); } // expected-error {{no matching conversion}} expected-note +{{}} 160ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith }; 161ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 162ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith namespace D { 163ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct S {}; 164ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct X { void operator()(S); } f; 165ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith } 166ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void testD(D::S ds) { f(ds); } // expected-error {{undeclared identifier}} 167ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 168ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith namespace E { 169ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct S {}; 170ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct f { f(S); }; 171ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith } 172ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void testE(E::S es) { f(es); } // expected-error {{undeclared identifier}} 173ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 174ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith namespace F { 175ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct S { 176ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith template<typename T> friend void f(S, T) {} 177ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith }; 178ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith } 179ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void testF(F::S fs) { f(fs, 0); } 180ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 181ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith namespace G { 182ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith namespace X { 183ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith int f; 184ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct A {}; 185ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith } 186ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith namespace Y { 187ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith template<typename T> void f(T); 188ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith struct B {}; 189ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith } 190ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith template<typename A, typename B> struct C {}; 191ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith } 192ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void testG(G::C<G::X::A, G::Y::B> gc) { f(gc); } 193ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith} 194ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 195ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith// dr219: na 196ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith// dr220: na 197ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 198ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smithnamespace dr221 { // dr221: yes 199176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines struct A { // expected-note 2-4{{candidate}} 200176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines A &operator=(int&); // expected-note 2{{candidate}} 201ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith A &operator+=(int&); 202ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith static A &operator=(A&, double&); // expected-error {{cannot be a static member}} 203ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith static A &operator+=(A&, double&); // expected-error {{cannot be a static member}} 204ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith friend A &operator=(A&, char&); // expected-error {{must be a non-static member function}} 205ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith friend A &operator+=(A&, char&); 206ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith }; 207ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith A &operator=(A&, float&); // expected-error {{must be a non-static member function}} 208ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith A &operator+=(A&, float&); 209ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 210ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith void test(A a, int n, char c, float f) { 211ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith a = n; 212ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith a += n; 213176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines a = c; // expected-error {{no viable}} 214ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith a += c; 215176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines a = f; // expected-error {{no viable}} 216ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith a += f; 217ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith } 218ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith} 219ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 220651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr222 { // dr222: dup 637 221651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void f(int a, int b, int c, int *x) { 222651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#pragma clang diagnostic push 223651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#pragma clang diagnostic warning "-Wunsequenced" 224651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void((a += b) += c); 225651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void((a += b) + (a += c)); // expected-warning {{multiple unsequenced modifications to 'a'}} 226651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 227651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines x[a++] = a; // expected-warning {{unsequenced modification and access to 'a'}} 228651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 229651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines a = b = 0; // ok, read and write of 'b' are sequenced 230651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 231651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines a = (b = a++); // expected-warning {{multiple unsequenced modifications to 'a'}} 232651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines a = (b = ++a); 233651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#pragma clang diagnostic pop 234651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 235651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 236ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith 237ad40edabcb1a6cf05c17c31e66842e3cbb24fde9Richard Smith// dr223: na 2381a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 2391a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithnamespace dr224 { // dr224: no 2401a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith namespace example1 { 2411a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template <class T> class A { 2421a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith typedef int type; 2431a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A::type a; 2441a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A<T>::type b; 2451a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A<T*>::type c; // expected-error {{missing 'typename'}} 2461a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith ::dr224::example1::A<T>::type d; 2471a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 2481a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith class B { 2491a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith typedef int type; 2501a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 2511a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A::type a; 2521a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A<T>::type b; 2531a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A<T*>::type c; // expected-error {{missing 'typename'}} 2541a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith ::dr224::example1::A<T>::type d; 2551a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 2561a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith B::type e; 2571a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A<T>::B::type f; 2581a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A<T*>::B::type g; // expected-error {{missing 'typename'}} 2591a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith typename A<T*>::B::type h; 2601a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith }; 2611a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith }; 2621a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 2631a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template <class T> class A<T*> { 2641a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith typedef int type; 2651a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A<T*>::type a; 2661a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith A<T>::type b; // expected-error {{missing 'typename'}} 2671a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith }; 2681a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 2691a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template <class T1, class T2, int I> struct B { 2701a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith typedef int type; 2711a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith B<T1, T2, I>::type b1; 2721a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith B<T2, T1, I>::type b2; // expected-error {{missing 'typename'}} 2731a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 2741a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith typedef T1 my_T1; 2751a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith static const int my_I = I; 2761a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith static const int my_I2 = I+0; 2771a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith static const int my_I3 = my_I; 2781a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith B<my_T1, T2, my_I>::type b3; // FIXME: expected-error {{missing 'typename'}} 2791a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith B<my_T1, T2, my_I2>::type b4; // expected-error {{missing 'typename'}} 2801a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith B<my_T1, T2, my_I3>::type b5; // FIXME: expected-error {{missing 'typename'}} 2811a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith }; 2821a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith } 2831a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 2841a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith namespace example2 { 2851a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template <int, typename T> struct X { typedef T type; }; 2861a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template <class T> class A { 2871a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith static const int i = 5; 2881a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith X<i, int>::type w; // FIXME: expected-error {{missing 'typename'}} 2891a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith X<A::i, char>::type x; // FIXME: expected-error {{missing 'typename'}} 2901a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith X<A<T>::i, double>::type y; // FIXME: expected-error {{missing 'typename'}} 2911a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith X<A<T*>::i, long>::type z; // expected-error {{missing 'typename'}} 2921a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith int f(); 2931a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith }; 2941a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template <class T> int A<T>::f() { 2951a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith return i; 2961a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith } 2971a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith } 2981a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith} 2991a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 3001a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith// dr225: yes 3011a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithtemplate<typename T> void dr225_f(T t) { dr225_g(t); } // expected-error {{call to function 'dr225_g' that is neither visible in the template definition nor found by argument-dependent lookup}} 3021a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithvoid dr225_g(int); // expected-note {{should be declared prior to the call site}} 3031a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithtemplate void dr225_f(int); // expected-note {{in instantiation of}} 3041a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 3051a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithnamespace dr226 { // dr226: no 3061a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename T = void> void f() {} 3071a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#if __cplusplus < 201103L 3081a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // expected-error@-2 {{extension}} 3091a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // FIXME: This appears to be wrong: default arguments for function templates 3101a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // are listed as a defect (in c++98) not an extension. EDG accepts them in 3111a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // strict c++98 mode. 3121a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#endif 3131a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename T> struct S { 3141a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename U = void> void g(); 3151a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#if __cplusplus < 201103L 3161a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // expected-error@-2 {{extension}} 3171a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#endif 3181a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename U> struct X; 3191a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename U> void h(); 3201a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith }; 3211a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename T> template<typename U> void S<T>::g() {} 3221a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename T> template<typename U = void> struct S<T>::X {}; // expected-error {{cannot add a default template arg}} 3231a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename T> template<typename U = void> void S<T>::h() {} // expected-error {{cannot add a default template arg}} 3241a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 3251a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename> void friend_h(); 3261a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith struct A { 3271a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // FIXME: This is ill-formed. 3281a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename=void> struct friend_B; 3291a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // FIXME: f, h, and i are ill-formed. 3301a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // f is ill-formed because it is not a definition. 3311a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // h and i are ill-formed because they are not the only declarations of the 3321a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // function in the translation unit. 3331a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename=void> void friend_f(); 3341a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename=void> void friend_g() {} 3351a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename=void> void friend_h() {} 3361a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename=void> void friend_i() {} 3371a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#if __cplusplus < 201103L 3381a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // expected-error@-5 {{extension}} expected-error@-4 {{extension}} 3391a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // expected-error@-4 {{extension}} expected-error@-3 {{extension}} 3401a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#endif 3411a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith }; 3421a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename> void friend_i(); 3431a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 3441a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename=void, typename X> void foo(X) {} 3451a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename=void, typename X> struct Foo {}; // expected-error {{missing a default argument}} expected-note {{here}} 3461a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#if __cplusplus < 201103L 3471a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // expected-error@-3 {{extension}} 3481a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#endif 3491a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 3501a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename=void, typename X, typename, typename Y> int foo(X, Y); 3511a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename, typename X, typename=void, typename Y> int foo(X, Y); 3521a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith int x = foo(0, 0); 3531a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#if __cplusplus < 201103L 3541a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // expected-error@-4 {{extension}} 3551a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // expected-error@-4 {{extension}} 3561a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#endif 3571a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith} 3581a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 3591a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithvoid dr227(bool b) { // dr227: yes 3601a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith if (b) 3611a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith int n; 3621a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith else 3631a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith int n; 3641a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith} 3651a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 3661a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithnamespace dr228 { // dr228: yes 3671a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template <class T> struct X { 3681a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith void f(); 3691a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith }; 3701a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template <class T> struct Y { 3711a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith void g(X<T> x) { x.template X<T>::f(); } 3721a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith }; 3731a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith} 3741a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 3751a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithnamespace dr229 { // dr229: yes 3761a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename T> void f(); 3771a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename T> void f<T*>() {} // expected-error {{function template partial specialization}} 3781a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<> void f<int>() {} 3791a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith} 3801a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 381651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr230 { // dr230: yes 382651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct S { 383651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines S() { f(); } // expected-warning {{call to pure virtual member function}} 384651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void f() = 0; // expected-note {{declared here}} 385651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 386651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 387651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 3881a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithnamespace dr231 { // dr231: yes 3891a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith namespace outer { 3901a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith namespace inner { 3911a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith int i; // expected-note {{here}} 3921a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith } 3931a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith void f() { using namespace inner; } 3941a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith int j = i; // expected-error {{undeclared identifier 'i'; did you mean 'inner::i'?}} 3951a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith } 3961a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith} 3971a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 3981a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith// dr234: na 3991a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith// dr235: na 4001a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 4011a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithnamespace dr236 { // dr236: yes 4021a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith void *p = int(); 4031a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#if __cplusplus < 201103L 4041a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // expected-warning@-2 {{null pointer}} 4051a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#else 4061a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith // expected-error@-4 {{cannot initialize}} 4071a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith#endif 4081a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith} 4091a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 4101a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithnamespace dr237 { // dr237: dup 470 4111a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename T> struct A { void f() { T::error; } }; 4121a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template<typename T> struct B : A<T> {}; 4131a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith template struct B<int>; // ok 4141a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith} 4151a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 4161a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smithnamespace dr239 { // dr239: yes 4171a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith namespace NS { 4181a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith class T {}; 4191a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith void f(T); 4201a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith float &g(T, int); 4211a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith } 4221a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith NS::T parm; 4231a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith int &g(NS::T, float); 4241a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith int main() { 4251a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith f(parm); 4261a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith float &r = g(parm, 1); 4271a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith extern int &g(NS::T, float); 4281a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith int &s = g(parm, 1); 4291a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith } 4301a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith} 4311a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith 4321a2dc26cc17c54b8864e7a53a57ae5b3b1324a03Richard Smith// dr240: dup 616 433e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 434e3a404411fe651097024edece9a72afeef5f6ac3Richard Smithnamespace dr241 { // dr241: yes 435e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith namespace A { 436e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct B {}; 437e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith template <int X> void f(); // expected-note 2{{candidate}} 438e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith template <int X> void g(B); 439e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith } 440e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith namespace C { 441e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith template <class T> void f(T t); // expected-note 2{{candidate}} 442e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith template <class T> void g(T t); // expected-note {{candidate}} 443e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith } 444e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void h(A::B b) { 445e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith f<3>(b); // expected-error {{undeclared identifier}} 446e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith g<3>(b); // expected-error {{undeclared identifier}} 447e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith A::f<3>(b); // expected-error {{no matching}} 448e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith A::g<3>(b); 449e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith C::f<3>(b); // expected-error {{no matching}} 450e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith C::g<3>(b); // expected-error {{no matching}} 451e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith using C::f; 452e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith using C::g; 453e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith f<3>(b); // expected-error {{no matching}} 454e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith g<3>(b); 455e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith } 456e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith} 457e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 458e3a404411fe651097024edece9a72afeef5f6ac3Richard Smithnamespace dr243 { // dr243: yes 459e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct B; 460e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct A { 461e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith A(B); // expected-note {{candidate}} 462e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith }; 463e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct B { 464e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith operator A() = delete; // expected-error 0-1{{extension}} expected-note {{candidate}} 465e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith } b; 466e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith A a1(b); 467e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith A a2 = b; // expected-error {{ambiguous}} 468e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith} 469e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 470176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesnamespace dr244 { // dr244: partial 471e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct B {}; struct D : B {}; // expected-note {{here}} 472e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 473e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith D D_object; 474e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith typedef B B_alias; 475e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith B* B_ptr = &D_object; 476e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 477e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void f() { 478e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith D_object.~B(); // expected-error {{expression does not match the type}} 479e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith D_object.B::~B(); 480e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith B_ptr->~B(); 481e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith B_ptr->~B_alias(); 482e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith B_ptr->B_alias::~B(); 483e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith // This is valid under DR244. 4846bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines B_ptr->B_alias::~B_alias(); 485e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith B_ptr->dr244::~B(); // expected-error {{refers to a member in namespace}} 486e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith B_ptr->dr244::~B_alias(); // expected-error {{refers to a member in namespace}} 487e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith } 488176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 489176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines namespace N { 490176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines template<typename T> struct E {}; 491176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines typedef E<int> F; 492176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 493176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void g(N::F f) { 494176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines typedef N::F G; 495176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines f.~G(); 496176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines f.G::~E(); 497176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines f.G::~F(); // expected-error {{expected the class name after '~' to name a destructor}} 498176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines f.G::~G(); 499176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // This is technically ill-formed; E is looked up in 'N::' and names the 500176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // class template, not the injected-class-name of the class. But that's 501176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // probably a bug in the standard. 502176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines f.N::F::~E(); 503176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // This is valid; we look up the second F in the same scope in which we 504176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // found the first one, that is, 'N::'. 505176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines f.N::F::~F(); // FIXME: expected-error {{expected the class name after '~' to name a destructor}} 506176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // This is technically ill-formed; G is looked up in 'N::' and is not found; 507176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // as above, this is probably a bug in the standard. 508176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines f.N::F::~G(); 509176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 510e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith} 511e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 512e3a404411fe651097024edece9a72afeef5f6ac3Richard Smithnamespace dr245 { // dr245: yes 513e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct S { 514e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith enum E {}; // expected-note {{here}} 515e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith class E *p; // expected-error {{does not match previous declaration}} 516e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith }; 517e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith} 518e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 519e3a404411fe651097024edece9a72afeef5f6ac3Richard Smithnamespace dr246 { // dr246: yes 520e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct S { 521e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith S() try { // expected-note {{try block}} 522e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith throw 0; 523e3a404411fe651097024edece9a72afeef5f6ac3Richard SmithX: ; 524e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith } catch (int) { 525176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines goto X; // expected-error {{cannot jump}} 526e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith } 527e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith }; 528e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith} 529e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 530e3a404411fe651097024edece9a72afeef5f6ac3Richard Smithnamespace dr247 { // dr247: yes 531e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct A {}; 532e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct B : A { 533e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void f(); 534e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void f(int); 535e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith }; 536e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void (A::*f)() = (void (A::*)())&B::f; 537e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 538e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct C { 539e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void f(); 540e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void f(int); 541e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith }; 542e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct D : C {}; 543e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void (C::*g)() = &D::f; 544e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void (D::*h)() = &D::f; 545e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 546e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct E { 547e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void f(); 548e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith }; 549e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith struct F : E { 550e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith using E::f; 551e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void f(int); 552e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith }; 553e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith void (F::*i)() = &F::f; 554e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith} 555e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 556e3a404411fe651097024edece9a72afeef5f6ac3Richard Smithnamespace dr248 { // dr248: yes c++11 557e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith // FIXME: Should this also apply to c++98 mode? This was a DR against C++98. 558e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith int \u040d\u040e = 0; 559e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith#if __cplusplus < 201103L 560e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith // FIXME: expected-error@-2 {{expected ';'}} 561e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith#endif 562e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith} 563e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 564e3a404411fe651097024edece9a72afeef5f6ac3Richard Smithnamespace dr249 { // dr249: yes 565e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith template<typename T> struct X { void f(); }; 566e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith template<typename T> void X<T>::f() {} 567e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith} 568e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 569e3a404411fe651097024edece9a72afeef5f6ac3Richard Smithnamespace dr250 { // dr250: yes 570e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith typedef void (*FPtr)(double x[]); 571e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 572e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith template<int I> void f(double x[]); 573e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith FPtr fp = &f<3>; 574e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith 575e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith template<int I = 3> void g(double x[]); // expected-error 0-1{{extension}} 576e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith FPtr gp = &g<>; 577e3a404411fe651097024edece9a72afeef5f6ac3Richard Smith} 5787b633339f3f17d6817bc664332008996c51badd2Richard Smith 5797b633339f3f17d6817bc664332008996c51badd2Richard Smithnamespace dr252 { // dr252: yes 5807b633339f3f17d6817bc664332008996c51badd2Richard Smith struct A { 5817b633339f3f17d6817bc664332008996c51badd2Richard Smith void operator delete(void*); // expected-note {{found}} 5827b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 5837b633339f3f17d6817bc664332008996c51badd2Richard Smith struct B { 5847b633339f3f17d6817bc664332008996c51badd2Richard Smith void operator delete(void*); // expected-note {{found}} 5857b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 5867b633339f3f17d6817bc664332008996c51badd2Richard Smith struct C : A, B { 5877b633339f3f17d6817bc664332008996c51badd2Richard Smith virtual ~C(); 5887b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 5897b633339f3f17d6817bc664332008996c51badd2Richard Smith C::~C() {} // expected-error {{'operator delete' found in multiple base classes}} 5907b633339f3f17d6817bc664332008996c51badd2Richard Smith 5917b633339f3f17d6817bc664332008996c51badd2Richard Smith struct D { 5927b633339f3f17d6817bc664332008996c51badd2Richard Smith void operator delete(void*, int); // expected-note {{here}} 5937b633339f3f17d6817bc664332008996c51badd2Richard Smith virtual ~D(); 5947b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 5957b633339f3f17d6817bc664332008996c51badd2Richard Smith D::~D() {} // expected-error {{no suitable member 'operator delete'}} 5967b633339f3f17d6817bc664332008996c51badd2Richard Smith 5977b633339f3f17d6817bc664332008996c51badd2Richard Smith struct E { 5987b633339f3f17d6817bc664332008996c51badd2Richard Smith void operator delete(void*, int); 599651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void operator delete(void*) = delete; // expected-error 0-1{{extension}} expected-note 1-2 {{here}} 600651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual ~E(); // expected-error 0-1 {{attempt to use a deleted function}} 6017b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 602651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines E::~E() {} // expected-error {{attempt to use a deleted function}} 6037b633339f3f17d6817bc664332008996c51badd2Richard Smith 6047b633339f3f17d6817bc664332008996c51badd2Richard Smith struct F { 6057b633339f3f17d6817bc664332008996c51badd2Richard Smith // If both functions are available, the first one is a placement delete. 606651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void operator delete(void*, size_t); 6077b633339f3f17d6817bc664332008996c51badd2Richard Smith void operator delete(void*) = delete; // expected-error 0-1{{extension}} expected-note {{here}} 6087b633339f3f17d6817bc664332008996c51badd2Richard Smith virtual ~F(); 6097b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 610651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines F::~F() {} // expected-error {{attempt to use a deleted function}} 6117b633339f3f17d6817bc664332008996c51badd2Richard Smith 6127b633339f3f17d6817bc664332008996c51badd2Richard Smith struct G { 613651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void operator delete(void*, size_t); 6147b633339f3f17d6817bc664332008996c51badd2Richard Smith virtual ~G(); 6157b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 6167b633339f3f17d6817bc664332008996c51badd2Richard Smith G::~G() {} 6177b633339f3f17d6817bc664332008996c51badd2Richard Smith} 6187b633339f3f17d6817bc664332008996c51badd2Richard Smith 6197b633339f3f17d6817bc664332008996c51badd2Richard Smithnamespace dr254 { // dr254: yes 6207b633339f3f17d6817bc664332008996c51badd2Richard Smith template<typename T> struct A { 6217b633339f3f17d6817bc664332008996c51badd2Richard Smith typedef typename T::type type; // ok even if this is a typedef-name, because 6227b633339f3f17d6817bc664332008996c51badd2Richard Smith // it's not an elaborated-type-specifier 6237b633339f3f17d6817bc664332008996c51badd2Richard Smith typedef struct T::type foo; // expected-error {{elaborated type refers to a typedef}} 6247b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 6257b633339f3f17d6817bc664332008996c51badd2Richard Smith struct B { struct type {}; }; 6267b633339f3f17d6817bc664332008996c51badd2Richard Smith struct C { typedef struct {} type; }; // expected-note {{here}} 6277b633339f3f17d6817bc664332008996c51badd2Richard Smith A<B>::type n; 6287b633339f3f17d6817bc664332008996c51badd2Richard Smith A<C>::type n; // expected-note {{instantiation of}} 6297b633339f3f17d6817bc664332008996c51badd2Richard Smith} 6307b633339f3f17d6817bc664332008996c51badd2Richard Smith 6317b633339f3f17d6817bc664332008996c51badd2Richard Smith// dr256: dup 624 6327b633339f3f17d6817bc664332008996c51badd2Richard Smith 6337b633339f3f17d6817bc664332008996c51badd2Richard Smithnamespace dr257 { // dr257: yes 6347b633339f3f17d6817bc664332008996c51badd2Richard Smith struct A { A(int); }; // expected-note {{here}} 6357b633339f3f17d6817bc664332008996c51badd2Richard Smith struct B : virtual A { 6367b633339f3f17d6817bc664332008996c51badd2Richard Smith B() {} 6377b633339f3f17d6817bc664332008996c51badd2Richard Smith virtual void f() = 0; 6387b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 6397b633339f3f17d6817bc664332008996c51badd2Richard Smith struct C : B { 6407b633339f3f17d6817bc664332008996c51badd2Richard Smith C() {} 6417b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 6427b633339f3f17d6817bc664332008996c51badd2Richard Smith struct D : B { 6437b633339f3f17d6817bc664332008996c51badd2Richard Smith D() {} // expected-error {{must explicitly initialize the base class 'dr257::A'}} 6447b633339f3f17d6817bc664332008996c51badd2Richard Smith void f(); 6457b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 6467b633339f3f17d6817bc664332008996c51badd2Richard Smith} 6477b633339f3f17d6817bc664332008996c51badd2Richard Smith 6487b633339f3f17d6817bc664332008996c51badd2Richard Smithnamespace dr258 { // dr258: yes 6497b633339f3f17d6817bc664332008996c51badd2Richard Smith struct A { 6507b633339f3f17d6817bc664332008996c51badd2Richard Smith void f(const int); 6517b633339f3f17d6817bc664332008996c51badd2Richard Smith template<typename> void g(int); 6527b633339f3f17d6817bc664332008996c51badd2Richard Smith float &h() const; 6537b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 6547b633339f3f17d6817bc664332008996c51badd2Richard Smith struct B : A { 6557b633339f3f17d6817bc664332008996c51badd2Richard Smith using A::f; 6567b633339f3f17d6817bc664332008996c51badd2Richard Smith using A::g; 6577b633339f3f17d6817bc664332008996c51badd2Richard Smith using A::h; 6587b633339f3f17d6817bc664332008996c51badd2Richard Smith int &f(int); 6597b633339f3f17d6817bc664332008996c51badd2Richard Smith template<int> int &g(int); // expected-note {{candidate}} 6607b633339f3f17d6817bc664332008996c51badd2Richard Smith int &h(); 6617b633339f3f17d6817bc664332008996c51badd2Richard Smith } b; 6627b633339f3f17d6817bc664332008996c51badd2Richard Smith int &w = b.f(0); 6637b633339f3f17d6817bc664332008996c51badd2Richard Smith int &x = b.g<int>(0); // expected-error {{no match}} 6647b633339f3f17d6817bc664332008996c51badd2Richard Smith int &y = b.h(); 6657b633339f3f17d6817bc664332008996c51badd2Richard Smith float &z = const_cast<const B&>(b).h(); 6667b633339f3f17d6817bc664332008996c51badd2Richard Smith 6677b633339f3f17d6817bc664332008996c51badd2Richard Smith struct C { 6687b633339f3f17d6817bc664332008996c51badd2Richard Smith virtual void f(const int) = 0; 6697b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 6707b633339f3f17d6817bc664332008996c51badd2Richard Smith struct D : C { 6717b633339f3f17d6817bc664332008996c51badd2Richard Smith void f(int); 6727b633339f3f17d6817bc664332008996c51badd2Richard Smith } d; 6737b633339f3f17d6817bc664332008996c51badd2Richard Smith 6747b633339f3f17d6817bc664332008996c51badd2Richard Smith struct E { 6757b633339f3f17d6817bc664332008996c51badd2Richard Smith virtual void f() = 0; // expected-note {{unimplemented}} 6767b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 6777b633339f3f17d6817bc664332008996c51badd2Richard Smith struct F : E { 6787b633339f3f17d6817bc664332008996c51badd2Richard Smith void f() const {} 6797b633339f3f17d6817bc664332008996c51badd2Richard Smith } f; // expected-error {{abstract}} 6807b633339f3f17d6817bc664332008996c51badd2Richard Smith} 6817b633339f3f17d6817bc664332008996c51badd2Richard Smith 6827b633339f3f17d6817bc664332008996c51badd2Richard Smithnamespace dr259 { // dr259: yes c++11 6837b633339f3f17d6817bc664332008996c51badd2Richard Smith template<typename T> struct A {}; 6847b633339f3f17d6817bc664332008996c51badd2Richard Smith template struct A<int>; // expected-note {{previous}} 6857b633339f3f17d6817bc664332008996c51badd2Richard Smith template struct A<int>; // expected-error {{duplicate explicit instantiation}} 6867b633339f3f17d6817bc664332008996c51badd2Richard Smith 6877b633339f3f17d6817bc664332008996c51badd2Richard Smith // FIXME: We only apply this DR in C++11 mode. 6887b633339f3f17d6817bc664332008996c51badd2Richard Smith template<> struct A<float>; 6897b633339f3f17d6817bc664332008996c51badd2Richard Smith template struct A<float>; 6907b633339f3f17d6817bc664332008996c51badd2Richard Smith#if __cplusplus < 201103L 6917b633339f3f17d6817bc664332008996c51badd2Richard Smith // expected-error@-2 {{extension}} expected-note@-3 {{here}} 6927b633339f3f17d6817bc664332008996c51badd2Richard Smith#endif 6937b633339f3f17d6817bc664332008996c51badd2Richard Smith 6947b633339f3f17d6817bc664332008996c51badd2Richard Smith template struct A<char>; // expected-note {{here}} 6957b633339f3f17d6817bc664332008996c51badd2Richard Smith template<> struct A<char>; // expected-error {{explicit specialization of 'dr259::A<char>' after instantiation}} 6967b633339f3f17d6817bc664332008996c51badd2Richard Smith 6977b633339f3f17d6817bc664332008996c51badd2Richard Smith template<> struct A<double>; 6987b633339f3f17d6817bc664332008996c51badd2Richard Smith template<> struct A<double>; 6997b633339f3f17d6817bc664332008996c51badd2Richard Smith template<> struct A<double> {}; // expected-note {{here}} 7007b633339f3f17d6817bc664332008996c51badd2Richard Smith template<> struct A<double> {}; // expected-error {{redefinition}} 7017b633339f3f17d6817bc664332008996c51badd2Richard Smith 7027b633339f3f17d6817bc664332008996c51badd2Richard Smith template<typename T> struct B; // expected-note {{here}} 7037b633339f3f17d6817bc664332008996c51badd2Richard Smith template struct B<int>; // expected-error {{undefined}} 7047b633339f3f17d6817bc664332008996c51badd2Richard Smith 7057b633339f3f17d6817bc664332008996c51badd2Richard Smith template<> struct B<float>; 7067b633339f3f17d6817bc664332008996c51badd2Richard Smith template struct B<float>; 7077b633339f3f17d6817bc664332008996c51badd2Richard Smith#if __cplusplus < 201103L 7087b633339f3f17d6817bc664332008996c51badd2Richard Smith // expected-error@-2 {{extension}} expected-note@-3 {{here}} 7097b633339f3f17d6817bc664332008996c51badd2Richard Smith#endif 7107b633339f3f17d6817bc664332008996c51badd2Richard Smith} 7117b633339f3f17d6817bc664332008996c51badd2Richard Smith 7126bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines// FIXME: When dr260 is resolved, also add tests for DR507. 7136bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 7147b633339f3f17d6817bc664332008996c51badd2Richard Smithnamespace dr261 { // dr261: no 7157b633339f3f17d6817bc664332008996c51badd2Richard Smith#pragma clang diagnostic push 7167b633339f3f17d6817bc664332008996c51badd2Richard Smith#pragma clang diagnostic warning "-Wused-but-marked-unused" 7177b633339f3f17d6817bc664332008996c51badd2Richard Smith 7187b633339f3f17d6817bc664332008996c51badd2Richard Smith // FIXME: This is ill-formed, with a diagnostic required, because operator new 7197b633339f3f17d6817bc664332008996c51badd2Richard Smith // and operator delete are inline and odr-used, but not defined in this 7207b633339f3f17d6817bc664332008996c51badd2Richard Smith // translation unit. 7217b633339f3f17d6817bc664332008996c51badd2Richard Smith // We're also missing the -Wused-but-marked-unused diagnostic here. 7227b633339f3f17d6817bc664332008996c51badd2Richard Smith struct A { 723651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines inline void *operator new(size_t) __attribute__((unused)); 7247b633339f3f17d6817bc664332008996c51badd2Richard Smith inline void operator delete(void*) __attribute__((unused)); 7257b633339f3f17d6817bc664332008996c51badd2Richard Smith A() {} 7267b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 7277b633339f3f17d6817bc664332008996c51badd2Richard Smith 7287b633339f3f17d6817bc664332008996c51badd2Richard Smith // FIXME: These are ill-formed, with a required diagnostic, for the same 7297b633339f3f17d6817bc664332008996c51badd2Richard Smith // reason. 7307b633339f3f17d6817bc664332008996c51badd2Richard Smith struct B { 7317b633339f3f17d6817bc664332008996c51badd2Richard Smith inline void operator delete(void*) __attribute__((unused)); 7327b633339f3f17d6817bc664332008996c51badd2Richard Smith ~B() {} 7337b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 7347b633339f3f17d6817bc664332008996c51badd2Richard Smith struct C { 7357b633339f3f17d6817bc664332008996c51badd2Richard Smith inline void operator delete(void*) __attribute__((unused)); 7367b633339f3f17d6817bc664332008996c51badd2Richard Smith virtual ~C() {} 7377b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 7387b633339f3f17d6817bc664332008996c51badd2Richard Smith 7397b633339f3f17d6817bc664332008996c51badd2Richard Smith struct D { 7407b633339f3f17d6817bc664332008996c51badd2Richard Smith inline void operator delete(void*) __attribute__((unused)); 7417b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 7427b633339f3f17d6817bc664332008996c51badd2Richard Smith void h() { C::operator delete(0); } // expected-warning {{marked unused but was used}} 7437b633339f3f17d6817bc664332008996c51badd2Richard Smith 7447b633339f3f17d6817bc664332008996c51badd2Richard Smith#pragma clang diagnostic pop 7457b633339f3f17d6817bc664332008996c51badd2Richard Smith} 7467b633339f3f17d6817bc664332008996c51badd2Richard Smith 7477b633339f3f17d6817bc664332008996c51badd2Richard Smithnamespace dr262 { // dr262: yes 7487b633339f3f17d6817bc664332008996c51badd2Richard Smith int f(int = 0, ...); 7497b633339f3f17d6817bc664332008996c51badd2Richard Smith int k = f(); 7507b633339f3f17d6817bc664332008996c51badd2Richard Smith int l = f(0); 7517b633339f3f17d6817bc664332008996c51badd2Richard Smith int m = f(0, 0); 7527b633339f3f17d6817bc664332008996c51badd2Richard Smith} 7537b633339f3f17d6817bc664332008996c51badd2Richard Smith 7547b633339f3f17d6817bc664332008996c51badd2Richard Smithnamespace dr263 { // dr263: yes 7557b633339f3f17d6817bc664332008996c51badd2Richard Smith struct X {}; 7567b633339f3f17d6817bc664332008996c51badd2Richard Smith struct Y { 7577b633339f3f17d6817bc664332008996c51badd2Richard Smith#if __cplusplus < 201103L 7587b633339f3f17d6817bc664332008996c51badd2Richard Smith friend X::X() throw(); 7597b633339f3f17d6817bc664332008996c51badd2Richard Smith friend X::~X() throw(); 7607b633339f3f17d6817bc664332008996c51badd2Richard Smith#else 7617b633339f3f17d6817bc664332008996c51badd2Richard Smith friend constexpr X::X() noexcept; 7627b633339f3f17d6817bc664332008996c51badd2Richard Smith friend X::~X(); 7637b633339f3f17d6817bc664332008996c51badd2Richard Smith#endif 7647b633339f3f17d6817bc664332008996c51badd2Richard Smith Y::Y(); // expected-error {{extra qualification}} 7657b633339f3f17d6817bc664332008996c51badd2Richard Smith Y::~Y(); // expected-error {{extra qualification}} 7667b633339f3f17d6817bc664332008996c51badd2Richard Smith }; 7677b633339f3f17d6817bc664332008996c51badd2Richard Smith} 7687b633339f3f17d6817bc664332008996c51badd2Richard Smith 7697b633339f3f17d6817bc664332008996c51badd2Richard Smith// dr265: dup 353 7707b633339f3f17d6817bc664332008996c51badd2Richard Smith// dr266: na 7717b633339f3f17d6817bc664332008996c51badd2Richard Smith// dr269: na 7727b633339f3f17d6817bc664332008996c51badd2Richard Smith// dr270: na 773651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 774651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr272 { // dr272: yes 775651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct X { 776651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void f() { 777651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines this->~X(); 778651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines X::~X(); 779651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines ~X(); // expected-error {{unary expression}} 780651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 781651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 782651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 783651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 784651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#include <stdarg.h> 785651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#include <stddef.h> 786651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr273 { // dr273: yes 787651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct A { 788651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines int n; 789651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 790651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void operator&(A); 791651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void f(A a, ...) { 792651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines offsetof(A, n); 793651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines va_list val; 794651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines va_start(val, a); 795651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines va_end(val); 796651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 797651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 798651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 799651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines// dr274: na 800651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 801651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr275 { // dr275: no 802651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines namespace N { 803651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <class T> void f(T) {} // expected-note 1-4{{here}} 804651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <class T> void g(T) {} // expected-note {{candidate}} 805651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <> void f(int); 806651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <> void f(char); 807651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <> void f(double); 808651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <> void g(char); 809651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 810651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 811651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines using namespace N; 812651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 813651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines namespace M { 814651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <> void N::f(char) {} // expected-error {{'M' does not enclose namespace 'N'}} 815651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <class T> void g(T) {} 816651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <> void g(char) {} 817651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template void f(long); 818651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#if __cplusplus >= 201103L 819651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // FIXME: this should be rejected in c++98 too 820651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // expected-error@-3 {{must occur in namespace 'N'}} 821651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#endif 822651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template void N::f(unsigned long); 823651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#if __cplusplus >= 201103L 824651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // FIXME: this should be rejected in c++98 too 825651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // expected-error@-3 {{not in a namespace enclosing 'N'}} 826651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#endif 827651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template void h(long); // expected-error {{does not refer to a function template}} 828651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <> void f(double) {} // expected-error {{no function template matches}} 829651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 830651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 831651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <class T> void g(T) {} // expected-note {{candidate}} 832651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 833651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <> void N::f(char) {} 834651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <> void f(int) {} // expected-error {{no function template matches}} 835651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 836651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template void f(short); 837651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#if __cplusplus >= 201103L 838651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // FIXME: this should be rejected in c++98 too 839651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // expected-error@-3 {{must occur in namespace 'N'}} 840651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines#endif 841651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template void N::f(unsigned short); 842651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 843651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // FIXME: this should probably be valid. the wording from the issue 844651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // doesn't clarify this, but it follows from the usual rules. 845651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template void g(int); // expected-error {{ambiguous}} 846651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 847651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // FIXME: likewise, this should also be valid. 848651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<typename T> void f(T) {} // expected-note {{candidate}} 849651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template void f(short); // expected-error {{ambiguous}} 850651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 851651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 852651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines// dr276: na 853651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 854651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr277 { // dr277: yes 855651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef int *intp; 856651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines int *p = intp(); 857651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines int a[fold(intp() ? -1 : 1)]; 858651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 859651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 860651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr280 { // dr280: yes 861651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef void f0(); 862651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef void f1(int); 863651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef void f2(int, int); 864651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef void f3(int, int, int); 865651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct A { 866651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator f1*(); // expected-note {{here}} expected-note {{candidate}} 867651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator f2*(); 868651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 869651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct B { 870651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator f0*(); // expected-note {{candidate}} 871651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines private: 872651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator f3*(); // expected-note {{here}} expected-note {{candidate}} 873651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 874651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct C { 875651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator f0*(); // expected-note {{candidate}} 876651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator f1*(); // expected-note {{candidate}} 877651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator f2*(); // expected-note {{candidate}} 878651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator f3*(); // expected-note {{candidate}} 879651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 880651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct D : private A, B { // expected-note 2{{here}} 881651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator f2*(); // expected-note {{candidate}} 882651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } d; 883651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct E : C, D {} e; 884651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void g() { 885651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines d(); // ok, public 886651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines d(0); // expected-error {{private member of 'dr280::A'}} expected-error {{private base class 'dr280::A'}} 887651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines d(0, 0); // ok, suppressed by member in D 888651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines d(0, 0, 0); // expected-error {{private member of 'dr280::B'}} 889651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines e(); // expected-error {{ambiguous}} 890651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines e(0); // expected-error {{ambiguous}} 891651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines e(0, 0); // expected-error {{ambiguous}} 892651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines e(0, 0, 0); // expected-error {{ambiguous}} 893651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 894651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 895651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 896651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr281 { // dr281: no 897651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void a(); 898651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines inline void b(); 899651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 900651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void d(); 901651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines inline void e(); 902651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 903651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct S { 904651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines friend inline void a(); // FIXME: ill-formed 905651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines friend inline void b(); 906651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines friend inline void c(); // FIXME: ill-formed 907651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines friend inline void d() {} 908651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines friend inline void e() {} 909651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines friend inline void f() {} 910651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 911651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 912651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 913651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr283 { // dr283: yes 914651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<typename T> // expected-note 2{{here}} 915651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct S { 916651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines friend class T; // expected-error {{shadows}} 917651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines class T; // expected-error {{shadows}} 918651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 919651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 920651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 921651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr284 { // dr284: no 922651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines namespace A { 923651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct X; 924651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines enum Y {}; 925651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines class Z {}; 926651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 927651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines namespace B { 928651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct W; 929651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines using A::X; 930651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines using A::Y; 931651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines using A::Z; 932651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 933651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct B::V {}; // expected-error {{no struct named 'V'}} 934651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct B::W {}; 935651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct B::X {}; // FIXME: ill-formed 936651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines enum B::Y e; // ok per dr417 937651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines class B::Z z; // ok per dr417 938651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 939651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct C { 940651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct X; 941651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines enum Y {}; 942651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines class Z {}; 943651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 944651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct D : C { 945651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct W; 946651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines using C::X; 947651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines using C::Y; 948651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines using C::Z; 949651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 950651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct D::V {}; // expected-error {{no struct named 'V'}} 951651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct D::W {}; 952651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct D::X {}; // FIXME: ill-formed 953651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines enum D::Y e2; // ok per dr417 954651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines class D::Z z2; // ok per dr417 955651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 956651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 957651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr285 { // dr285: yes 958651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<typename T> void f(T, int); // expected-note {{match}} 959651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<typename T> void f(int, T); // expected-note {{match}} 960651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<> void f<int>(int, int) {} // expected-error {{ambiguous}} 961651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 962651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 963651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr286 { // dr286: yes 964651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<class T> struct A { 965651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines class C { 966651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<class T2> struct B {}; // expected-note {{here}} 967651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 968651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 969651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 970651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<class T> 971651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<class T2> 972651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct A<T>::C::B<T2*> { }; 973651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 974651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines A<short>::C::B<int*> absip; // expected-error {{private}} 975651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 976651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 977651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines// dr288: na 978651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 979651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr289 { // dr289: yes 980651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct A; // expected-note {{forward}} 981651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct B : A {}; // expected-error {{incomplete}} 982651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 983651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<typename T> struct C { typename T::error error; }; // expected-error {{cannot be used prior to '::'}} 984651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct D : C<int> {}; // expected-note {{instantiation}} 985651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 986651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 987651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines// dr290: na 988651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines// dr291: dup 391 989651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines// dr292 FIXME: write a codegen test 990651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 991651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr294 { // dr294: no 992651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void f() throw(int); 993651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines int main() { 9940e2c34f92f00628d48968dfea096d36381f494cbStephen Hines (void)static_cast<void (*)() throw()>(f); // FIXME: ill-formed 995651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines (void)static_cast<void (*)() throw(int)>(f); // FIXME: ill-formed 9960e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 9970e2c34f92f00628d48968dfea096d36381f494cbStephen Hines void (*p)() throw() = f; // expected-error {{not superset}} 9980e2c34f92f00628d48968dfea096d36381f494cbStephen Hines void (*q)() throw(int) = f; 999651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 1000651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1001651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1002651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr295 { // dr295: no 1003651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef int f(); 1004651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // FIXME: This warning is incorrect. 1005651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines const f g; // expected-warning {{unspecified behavior}} 1006651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines const f &r = g; // expected-warning {{unspecified behavior}} 1007651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template<typename T> struct X { 1008651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines const T &f; 1009651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 1010651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines X<f> x = {g}; // FIXME: expected-error {{drops qualifiers}} 1011651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1012651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1013651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr296 { // dr296: yes 1014651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct A { 1015651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines static operator int() { return 0; } // expected-error {{static}} 1016651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 1017651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1018651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1019651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr298 { // dr298: yes 1020651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct A { 1021651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef int type; 1022651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines A(); 1023651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines ~A(); 1024651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 1025651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef A B; // expected-note {{here}} 1026651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef const A C; // expected-note {{here}} 1027651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1028651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines A::type i1; 1029651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines B::type i2; 1030651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines C::type i3; 1031651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1032651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct A a; 1033651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct B b; // expected-error {{refers to a typedef}} 1034651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct C c; // expected-error {{refers to a typedef}} 1035651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1036651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines B::B() {} // expected-error {{requires a type specifier}} 1037651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines B::A() {} // ok 10386bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines C::~C() {} // expected-error {{destructor cannot be declared using a typedef 'C' (aka 'const dr298::A') of the class name}} 1039651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1040651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef struct D E; // expected-note {{here}} 1041651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct E {}; // expected-error {{conflicts with typedef}} 10426bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 10436bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines struct F { 10446bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines ~F(); 10456bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines }; 10466bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines typedef const F G; 10476bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines G::~F() {} // ok 1048651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1049651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1050651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesnamespace dr299 { // dr299: yes c++11 1051651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct S { 1052651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator int(); 1053651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 1054651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines struct T { 1055651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator int(); // expected-note {{}} 1056651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines operator unsigned short(); // expected-note {{}} 1057651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines }; 1058651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // FIXME: should this apply to c++98 mode? 1059651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines int *p = new int[S()]; // expected-error 0-1{{extension}} 1060651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines int *q = new int[T()]; // expected-error {{ambiguous}} 1061651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1062