// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // PR13819 -- __SIZE_TYPE__ is incompatible. typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}} #if __cplusplus < 201103L #define fold(x) (__builtin_constant_p(x) ? (x) : (x)) #else #define fold #endif namespace dr200 { // dr200: dup 214 template <class T> T f(int); template <class T, class U> T f(U) = delete; // expected-error 0-1{{extension}} void g() { f<int>(1); } } // dr201 FIXME: write codegen test namespace dr202 { // dr202: yes template<typename T> T f(); template<int (*g)()> struct X { int arr[fold(g == &f<int>) ? 1 : -1]; }; template struct X<f>; } // FIXME (export) dr204: no namespace dr206 { // dr206: yes struct S; // expected-note 2{{declaration}} template<typename T> struct Q { S s; }; // expected-error {{incomplete}} template<typename T> void f() { S s; } // expected-error {{incomplete}} } namespace dr207 { // dr207: yes class A { protected: static void f() {} }; class B : A { public: using A::f; void g() { A::f(); f(); } }; } // dr208 FIXME: write codegen test namespace dr209 { // dr209: yes class A { void f(); // expected-note {{here}} }; class B { friend void A::f(); // expected-error {{private}} }; } // dr210 FIXME: write codegen test namespace dr211 { // dr211: yes struct A { A() try { throw 0; } catch (...) { return; // expected-error {{return in the catch of a function try block of a constructor}} } }; } namespace dr213 { // dr213: yes template <class T> struct A : T { void h(T t) { char &r1 = f(t); int &r2 = g(t); // expected-error {{undeclared}} } }; struct B { int &f(B); int &g(B); // expected-note {{in dependent base class}} }; char &f(B); template void A<B>::h(B); // expected-note {{instantiation}} } namespace dr214 { // dr214: yes template<typename T, typename U> T checked_cast(U from) { U::error; } template<typename T, typename U> T checked_cast(U *from); class C {}; void foo(int *arg) { checked_cast<const C *>(arg); } template<typename T> T f(int); template<typename T, typename U> T f(U) { T::error; } void g() { f<int>(1); } } namespace dr215 { // dr215: yes template<typename T> class X { friend void T::foo(); int n; }; struct Y { void foo() { (void)+X<Y>().n; } }; } namespace dr216 { // dr216: no // FIXME: Should reject this: 'f' has linkage but its type does not, // and 'f' is odr-used but not defined in this TU. typedef enum { e } *E; void f(E); void g(E e) { f(e); } struct S { // FIXME: Should reject this: 'f' has linkage but its type does not, // and 'f' is odr-used but not defined in this TU. typedef enum { e } *E; void f(E); }; void g(S s, S::E e) { s.f(e); } } namespace dr217 { // dr217: yes template<typename T> struct S { void f(int); }; template<typename T> void S<T>::f(int = 0) {} // expected-error {{default arguments cannot be added}} } namespace dr218 { // dr218: yes namespace A { struct S {}; void f(S); } namespace B { struct S {}; void f(S); } struct C { int f; void test1(A::S as) { f(as); } // expected-error {{called object type 'int'}} void test2(A::S as) { void f(); f(as); } // expected-error {{too many arguments}} expected-note {{}} void test3(A::S as) { using A::f; f(as); } // ok void test4(A::S as) { using B::f; f(as); } // ok void test5(A::S as) { int f; f(as); } // expected-error {{called object type 'int'}} void test6(A::S as) { struct f {}; (void) f(as); } // expected-error {{no matching conversion}} expected-note +{{}} }; namespace D { struct S {}; struct X { void operator()(S); } f; } void testD(D::S ds) { f(ds); } // expected-error {{undeclared identifier}} namespace E { struct S {}; struct f { f(S); }; } void testE(E::S es) { f(es); } // expected-error {{undeclared identifier}} namespace F { struct S { template<typename T> friend void f(S, T) {} }; } void testF(F::S fs) { f(fs, 0); } namespace G { namespace X { int f; struct A {}; } namespace Y { template<typename T> void f(T); struct B {}; } template<typename A, typename B> struct C {}; } void testG(G::C<G::X::A, G::Y::B> gc) { f(gc); } } // dr219: na // dr220: na namespace dr221 { // dr221: yes struct A { A &operator=(int&); A &operator+=(int&); static A &operator=(A&, double&); // expected-error {{cannot be a static member}} static A &operator+=(A&, double&); // expected-error {{cannot be a static member}} friend A &operator=(A&, char&); // expected-error {{must be a non-static member function}} friend A &operator+=(A&, char&); }; A &operator=(A&, float&); // expected-error {{must be a non-static member function}} A &operator+=(A&, float&); void test(A a, int n, char c, float f) { a = n; a += n; a = c; a += c; a = f; a += f; } } namespace dr222 { // dr222: dup 637 void f(int a, int b, int c, int *x) { #pragma clang diagnostic push #pragma clang diagnostic warning "-Wunsequenced" void((a += b) += c); void((a += b) + (a += c)); // expected-warning {{multiple unsequenced modifications to 'a'}} x[a++] = a; // expected-warning {{unsequenced modification and access to 'a'}} a = b = 0; // ok, read and write of 'b' are sequenced a = (b = a++); // expected-warning {{multiple unsequenced modifications to 'a'}} a = (b = ++a); #pragma clang diagnostic pop } } // dr223: na namespace dr224 { // dr224: no namespace example1 { template <class T> class A { typedef int type; A::type a; A<T>::type b; A<T*>::type c; // expected-error {{missing 'typename'}} ::dr224::example1::A<T>::type d; class B { typedef int type; A::type a; A<T>::type b; A<T*>::type c; // expected-error {{missing 'typename'}} ::dr224::example1::A<T>::type d; B::type e; A<T>::B::type f; A<T*>::B::type g; // expected-error {{missing 'typename'}} typename A<T*>::B::type h; }; }; template <class T> class A<T*> { typedef int type; A<T*>::type a; A<T>::type b; // expected-error {{missing 'typename'}} }; template <class T1, class T2, int I> struct B { typedef int type; B<T1, T2, I>::type b1; B<T2, T1, I>::type b2; // expected-error {{missing 'typename'}} typedef T1 my_T1; static const int my_I = I; static const int my_I2 = I+0; static const int my_I3 = my_I; B<my_T1, T2, my_I>::type b3; // FIXME: expected-error {{missing 'typename'}} B<my_T1, T2, my_I2>::type b4; // expected-error {{missing 'typename'}} B<my_T1, T2, my_I3>::type b5; // FIXME: expected-error {{missing 'typename'}} }; } namespace example2 { template <int, typename T> struct X { typedef T type; }; template <class T> class A { static const int i = 5; X<i, int>::type w; // FIXME: expected-error {{missing 'typename'}} X<A::i, char>::type x; // FIXME: expected-error {{missing 'typename'}} X<A<T>::i, double>::type y; // FIXME: expected-error {{missing 'typename'}} X<A<T*>::i, long>::type z; // expected-error {{missing 'typename'}} int f(); }; template <class T> int A<T>::f() { return i; } } } // dr225: yes template<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}} void dr225_g(int); // expected-note {{should be declared prior to the call site}} template void dr225_f(int); // expected-note {{in instantiation of}} namespace dr226 { // dr226: no template<typename T = void> void f() {} #if __cplusplus < 201103L // expected-error@-2 {{extension}} // FIXME: This appears to be wrong: default arguments for function templates // are listed as a defect (in c++98) not an extension. EDG accepts them in // strict c++98 mode. #endif template<typename T> struct S { template<typename U = void> void g(); #if __cplusplus < 201103L // expected-error@-2 {{extension}} #endif template<typename U> struct X; template<typename U> void h(); }; template<typename T> template<typename U> void S<T>::g() {} template<typename T> template<typename U = void> struct S<T>::X {}; // expected-error {{cannot add a default template arg}} template<typename T> template<typename U = void> void S<T>::h() {} // expected-error {{cannot add a default template arg}} template<typename> void friend_h(); struct A { // FIXME: This is ill-formed. template<typename=void> struct friend_B; // FIXME: f, h, and i are ill-formed. // f is ill-formed because it is not a definition. // h and i are ill-formed because they are not the only declarations of the // function in the translation unit. template<typename=void> void friend_f(); template<typename=void> void friend_g() {} template<typename=void> void friend_h() {} template<typename=void> void friend_i() {} #if __cplusplus < 201103L // expected-error@-5 {{extension}} expected-error@-4 {{extension}} // expected-error@-4 {{extension}} expected-error@-3 {{extension}} #endif }; template<typename> void friend_i(); template<typename=void, typename X> void foo(X) {} template<typename=void, typename X> struct Foo {}; // expected-error {{missing a default argument}} expected-note {{here}} #if __cplusplus < 201103L // expected-error@-3 {{extension}} #endif template<typename=void, typename X, typename, typename Y> int foo(X, Y); template<typename, typename X, typename=void, typename Y> int foo(X, Y); int x = foo(0, 0); #if __cplusplus < 201103L // expected-error@-4 {{extension}} // expected-error@-4 {{extension}} #endif } void dr227(bool b) { // dr227: yes if (b) int n; else int n; } namespace dr228 { // dr228: yes template <class T> struct X { void f(); }; template <class T> struct Y { void g(X<T> x) { x.template X<T>::f(); } }; } namespace dr229 { // dr229: yes template<typename T> void f(); template<typename T> void f<T*>() {} // expected-error {{function template partial specialization}} template<> void f<int>() {} } namespace dr230 { // dr230: yes struct S { S() { f(); } // expected-warning {{call to pure virtual member function}} virtual void f() = 0; // expected-note {{declared here}} }; } namespace dr231 { // dr231: yes namespace outer { namespace inner { int i; // expected-note {{here}} } void f() { using namespace inner; } int j = i; // expected-error {{undeclared identifier 'i'; did you mean 'inner::i'?}} } } // dr234: na // dr235: na namespace dr236 { // dr236: yes void *p = int(); #if __cplusplus < 201103L // expected-warning@-2 {{null pointer}} #else // expected-error@-4 {{cannot initialize}} #endif } namespace dr237 { // dr237: dup 470 template<typename T> struct A { void f() { T::error; } }; template<typename T> struct B : A<T> {}; template struct B<int>; // ok } namespace dr239 { // dr239: yes namespace NS { class T {}; void f(T); float &g(T, int); } NS::T parm; int &g(NS::T, float); int main() { f(parm); float &r = g(parm, 1); extern int &g(NS::T, float); int &s = g(parm, 1); } } // dr240: dup 616 namespace dr241 { // dr241: yes namespace A { struct B {}; template <int X> void f(); // expected-note 2{{candidate}} template <int X> void g(B); } namespace C { template <class T> void f(T t); // expected-note 2{{candidate}} template <class T> void g(T t); // expected-note {{candidate}} } void h(A::B b) { f<3>(b); // expected-error {{undeclared identifier}} g<3>(b); // expected-error {{undeclared identifier}} A::f<3>(b); // expected-error {{no matching}} A::g<3>(b); C::f<3>(b); // expected-error {{no matching}} C::g<3>(b); // expected-error {{no matching}} using C::f; using C::g; f<3>(b); // expected-error {{no matching}} g<3>(b); } } namespace dr243 { // dr243: yes struct B; struct A { A(B); // expected-note {{candidate}} }; struct B { operator A() = delete; // expected-error 0-1{{extension}} expected-note {{candidate}} } b; A a1(b); A a2 = b; // expected-error {{ambiguous}} } namespace dr244 { // dr244: 3.5 struct B {}; struct D : B {}; // expected-note {{here}} D D_object; typedef B B_alias; B* B_ptr = &D_object; void f() { D_object.~B(); // expected-error {{expression does not match the type}} D_object.B::~B(); B_ptr->~B(); B_ptr->~B_alias(); B_ptr->B_alias::~B(); // This is valid under DR244. B_ptr->B_alias::~B_alias(); B_ptr->dr244::~B(); // expected-error {{refers to a member in namespace}} B_ptr->dr244::~B_alias(); // expected-error {{refers to a member in namespace}} } } namespace dr245 { // dr245: yes struct S { enum E {}; // expected-note {{here}} class E *p; // expected-error {{does not match previous declaration}} }; } namespace dr246 { // dr246: yes struct S { S() try { // expected-note {{try block}} throw 0; X: ; } catch (int) { goto X; // expected-error {{protected scope}} } }; } namespace dr247 { // dr247: yes struct A {}; struct B : A { void f(); void f(int); }; void (A::*f)() = (void (A::*)())&B::f; struct C { void f(); void f(int); }; struct D : C {}; void (C::*g)() = &D::f; void (D::*h)() = &D::f; struct E { void f(); }; struct F : E { using E::f; void f(int); }; void (F::*i)() = &F::f; } namespace dr248 { // dr248: yes c++11 // FIXME: Should this also apply to c++98 mode? This was a DR against C++98. int \u040d\u040e = 0; #if __cplusplus < 201103L // FIXME: expected-error@-2 {{expected ';'}} #endif } namespace dr249 { // dr249: yes template<typename T> struct X { void f(); }; template<typename T> void X<T>::f() {} } namespace dr250 { // dr250: yes typedef void (*FPtr)(double x[]); template<int I> void f(double x[]); FPtr fp = &f<3>; template<int I = 3> void g(double x[]); // expected-error 0-1{{extension}} FPtr gp = &g<>; } namespace dr252 { // dr252: yes struct A { void operator delete(void*); // expected-note {{found}} }; struct B { void operator delete(void*); // expected-note {{found}} }; struct C : A, B { virtual ~C(); }; C::~C() {} // expected-error {{'operator delete' found in multiple base classes}} struct D { void operator delete(void*, int); // expected-note {{here}} virtual ~D(); }; D::~D() {} // expected-error {{no suitable member 'operator delete'}} struct E { void operator delete(void*, int); void operator delete(void*) = delete; // expected-error 0-1{{extension}} expected-note 1-2 {{here}} virtual ~E(); // expected-error 0-1 {{attempt to use a deleted function}} }; E::~E() {} // expected-error {{attempt to use a deleted function}} struct F { // If both functions are available, the first one is a placement delete. void operator delete(void*, size_t); void operator delete(void*) = delete; // expected-error 0-1{{extension}} expected-note {{here}} virtual ~F(); }; F::~F() {} // expected-error {{attempt to use a deleted function}} struct G { void operator delete(void*, size_t); virtual ~G(); }; G::~G() {} } namespace dr254 { // dr254: yes template<typename T> struct A { typedef typename T::type type; // ok even if this is a typedef-name, because // it's not an elaborated-type-specifier typedef struct T::type foo; // expected-error {{elaborated type refers to a typedef}} }; struct B { struct type {}; }; struct C { typedef struct {} type; }; // expected-note {{here}} A<B>::type n; A<C>::type n; // expected-note {{instantiation of}} } // dr256: dup 624 namespace dr257 { // dr257: yes struct A { A(int); }; // expected-note {{here}} struct B : virtual A { B() {} virtual void f() = 0; }; struct C : B { C() {} }; struct D : B { D() {} // expected-error {{must explicitly initialize the base class 'dr257::A'}} void f(); }; } namespace dr258 { // dr258: yes struct A { void f(const int); template<typename> void g(int); float &h() const; }; struct B : A { using A::f; using A::g; using A::h; int &f(int); template<int> int &g(int); // expected-note {{candidate}} int &h(); } b; int &w = b.f(0); int &x = b.g<int>(0); // expected-error {{no match}} int &y = b.h(); float &z = const_cast<const B&>(b).h(); struct C { virtual void f(const int) = 0; }; struct D : C { void f(int); } d; struct E { virtual void f() = 0; // expected-note {{unimplemented}} }; struct F : E { void f() const {} } f; // expected-error {{abstract}} } namespace dr259 { // dr259: yes c++11 template<typename T> struct A {}; template struct A<int>; // expected-note {{previous}} template struct A<int>; // expected-error {{duplicate explicit instantiation}} // FIXME: We only apply this DR in C++11 mode. template<> struct A<float>; template struct A<float>; #if __cplusplus < 201103L // expected-error@-2 {{extension}} expected-note@-3 {{here}} #endif template struct A<char>; // expected-note {{here}} template<> struct A<char>; // expected-error {{explicit specialization of 'dr259::A<char>' after instantiation}} template<> struct A<double>; template<> struct A<double>; template<> struct A<double> {}; // expected-note {{here}} template<> struct A<double> {}; // expected-error {{redefinition}} template<typename T> struct B; // expected-note {{here}} template struct B<int>; // expected-error {{undefined}} template<> struct B<float>; template struct B<float>; #if __cplusplus < 201103L // expected-error@-2 {{extension}} expected-note@-3 {{here}} #endif } // FIXME: When dr260 is resolved, also add tests for DR507. namespace dr261 { // dr261: no #pragma clang diagnostic push #pragma clang diagnostic warning "-Wused-but-marked-unused" // FIXME: This is ill-formed, with a diagnostic required, because operator new // and operator delete are inline and odr-used, but not defined in this // translation unit. // We're also missing the -Wused-but-marked-unused diagnostic here. struct A { inline void *operator new(size_t) __attribute__((unused)); inline void operator delete(void*) __attribute__((unused)); A() {} }; // FIXME: These are ill-formed, with a required diagnostic, for the same // reason. struct B { inline void operator delete(void*) __attribute__((unused)); ~B() {} }; struct C { inline void operator delete(void*) __attribute__((unused)); virtual ~C() {} }; struct D { inline void operator delete(void*) __attribute__((unused)); }; void h() { C::operator delete(0); } // expected-warning {{marked unused but was used}} #pragma clang diagnostic pop } namespace dr262 { // dr262: yes int f(int = 0, ...); int k = f(); int l = f(0); int m = f(0, 0); } namespace dr263 { // dr263: yes struct X {}; struct Y { #if __cplusplus < 201103L friend X::X() throw(); friend X::~X() throw(); #else friend constexpr X::X() noexcept; friend X::~X(); #endif Y::Y(); // expected-error {{extra qualification}} Y::~Y(); // expected-error {{extra qualification}} }; } // dr265: dup 353 // dr266: na // dr269: na // dr270: na namespace dr272 { // dr272: yes struct X { void f() { this->~X(); X::~X(); ~X(); // expected-error {{unary expression}} } }; } #include <stdarg.h> #include <stddef.h> namespace dr273 { // dr273: yes struct A { int n; }; void operator&(A); void f(A a, ...) { offsetof(A, n); va_list val; va_start(val, a); va_end(val); } } // dr274: na namespace dr275 { // dr275: no namespace N { template <class T> void f(T) {} // expected-note 1-4{{here}} template <class T> void g(T) {} // expected-note {{candidate}} template <> void f(int); template <> void f(char); template <> void f(double); template <> void g(char); } using namespace N; namespace M { template <> void N::f(char) {} // expected-error {{'M' does not enclose namespace 'N'}} template <class T> void g(T) {} template <> void g(char) {} template void f(long); #if __cplusplus >= 201103L // FIXME: this should be rejected in c++98 too // expected-error@-3 {{must occur in namespace 'N'}} #endif template void N::f(unsigned long); #if __cplusplus >= 201103L // FIXME: this should be rejected in c++98 too // expected-error@-3 {{not in a namespace enclosing 'N'}} #endif template void h(long); // expected-error {{does not refer to a function template}} template <> void f(double) {} // expected-error {{no function template matches}} } template <class T> void g(T) {} // expected-note {{candidate}} template <> void N::f(char) {} template <> void f(int) {} // expected-error {{no function template matches}} template void f(short); #if __cplusplus >= 201103L // FIXME: this should be rejected in c++98 too // expected-error@-3 {{must occur in namespace 'N'}} #endif template void N::f(unsigned short); // FIXME: this should probably be valid. the wording from the issue // doesn't clarify this, but it follows from the usual rules. template void g(int); // expected-error {{ambiguous}} // FIXME: likewise, this should also be valid. template<typename T> void f(T) {} // expected-note {{candidate}} template void f(short); // expected-error {{ambiguous}} } // dr276: na namespace dr277 { // dr277: yes typedef int *intp; int *p = intp(); int a[fold(intp() ? -1 : 1)]; } namespace dr280 { // dr280: yes typedef void f0(); typedef void f1(int); typedef void f2(int, int); typedef void f3(int, int, int); struct A { operator f1*(); // expected-note {{here}} expected-note {{candidate}} operator f2*(); }; struct B { operator f0*(); // expected-note {{candidate}} private: operator f3*(); // expected-note {{here}} expected-note {{candidate}} }; struct C { operator f0*(); // expected-note {{candidate}} operator f1*(); // expected-note {{candidate}} operator f2*(); // expected-note {{candidate}} operator f3*(); // expected-note {{candidate}} }; struct D : private A, B { // expected-note 2{{here}} operator f2*(); // expected-note {{candidate}} } d; struct E : C, D {} e; void g() { d(); // ok, public d(0); // expected-error {{private member of 'dr280::A'}} expected-error {{private base class 'dr280::A'}} d(0, 0); // ok, suppressed by member in D d(0, 0, 0); // expected-error {{private member of 'dr280::B'}} e(); // expected-error {{ambiguous}} e(0); // expected-error {{ambiguous}} e(0, 0); // expected-error {{ambiguous}} e(0, 0, 0); // expected-error {{ambiguous}} } } namespace dr281 { // dr281: no void a(); inline void b(); void d(); inline void e(); struct S { friend inline void a(); // FIXME: ill-formed friend inline void b(); friend inline void c(); // FIXME: ill-formed friend inline void d() {} friend inline void e() {} friend inline void f() {} }; } namespace dr283 { // dr283: yes template<typename T> // expected-note 2{{here}} struct S { friend class T; // expected-error {{shadows}} class T; // expected-error {{shadows}} }; } namespace dr284 { // dr284: no namespace A { struct X; enum Y {}; class Z {}; } namespace B { struct W; using A::X; using A::Y; using A::Z; } struct B::V {}; // expected-error {{no struct named 'V'}} struct B::W {}; struct B::X {}; // FIXME: ill-formed enum B::Y e; // ok per dr417 class B::Z z; // ok per dr417 struct C { struct X; enum Y {}; class Z {}; }; struct D : C { struct W; using C::X; using C::Y; using C::Z; }; struct D::V {}; // expected-error {{no struct named 'V'}} struct D::W {}; struct D::X {}; // FIXME: ill-formed enum D::Y e2; // ok per dr417 class D::Z z2; // ok per dr417 } namespace dr285 { // dr285: yes template<typename T> void f(T, int); // expected-note {{match}} template<typename T> void f(int, T); // expected-note {{match}} template<> void f<int>(int, int) {} // expected-error {{ambiguous}} } namespace dr286 { // dr286: yes template<class T> struct A { class C { template<class T2> struct B {}; // expected-note {{here}} }; }; template<class T> template<class T2> struct A<T>::C::B<T2*> { }; A<short>::C::B<int*> absip; // expected-error {{private}} } // dr288: na namespace dr289 { // dr289: yes struct A; // expected-note {{forward}} struct B : A {}; // expected-error {{incomplete}} template<typename T> struct C { typename T::error error; }; // expected-error {{cannot be used prior to '::'}} struct D : C<int> {}; // expected-note {{instantiation}} } // dr290: na // dr291: dup 391 // dr292 FIXME: write a codegen test namespace dr294 { // dr294: no void f() throw(int); int main() { // FIXME: we reject this for the wrong reason, because we don't implement // dr87 yet. (void)static_cast<void (*)() throw()>(f); // expected-error {{not superset}} void (*p)() throw() = f; // expected-error {{not superset}} (void)static_cast<void (*)() throw(int)>(f); // FIXME: ill-formed } } namespace dr295 { // dr295: no typedef int f(); // FIXME: This warning is incorrect. const f g; // expected-warning {{unspecified behavior}} const f &r = g; // expected-warning {{unspecified behavior}} template<typename T> struct X { const T &f; }; X<f> x = {g}; // FIXME: expected-error {{drops qualifiers}} } namespace dr296 { // dr296: yes struct A { static operator int() { return 0; } // expected-error {{static}} }; } namespace dr298 { // dr298: yes struct A { typedef int type; A(); ~A(); }; typedef A B; // expected-note {{here}} typedef const A C; // expected-note {{here}} A::type i1; B::type i2; C::type i3; struct A a; struct B b; // expected-error {{refers to a typedef}} struct C c; // expected-error {{refers to a typedef}} B::B() {} // expected-error {{requires a type specifier}} B::A() {} // ok C::~C() {} // expected-error {{destructor cannot be declared using a typedef 'C' (aka 'const dr298::A') of the class name}} typedef struct D E; // expected-note {{here}} struct E {}; // expected-error {{conflicts with typedef}} struct F { ~F(); }; typedef const F G; G::~F() {} // ok } namespace dr299 { // dr299: yes c++11 struct S { operator int(); }; struct T { operator int(); // expected-note {{}} operator unsigned short(); // expected-note {{}} }; // FIXME: should this apply to c++98 mode? int *p = new int[S()]; // expected-error 0-1{{extension}} int *q = new int[T()]; // expected-error {{ambiguous}} }