blob: 0ae6c446f3da9cbee74abac0470e02ac5d698e4a [file] [log] [blame]
// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++0x
#ifndef __GXX_EXPERIMENTAL_CXX0X__
#define __CONCAT(__X, __Y) __CONCAT1(__X, __Y)
#define __CONCAT1(__X, __Y) __X ## __Y
#define static_assert(__b, __m) \
typedef int __CONCAT(__sa, __LINE__)[__b ? 1 : -1]
#endif
class C {
virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
};
static_assert(__is_abstract(C), "C has a pure virtual function");
class D : C {
};
static_assert(__is_abstract(D), "D inherits from an abstract class");
class E : D {
virtual void f();
};
static_assert(!__is_abstract(E), "E inherits from an abstract class but implements f");
C *d = new C; // expected-error {{allocation of an object of abstract type 'C'}}
C c; // expected-error {{variable type 'C' is an abstract class}}
void t1(C c); // expected-error {{parameter type 'C' is an abstract class}}
void t2(C); // expected-error {{parameter type 'C' is an abstract class}}
struct S {
C c; // expected-error {{field type 'C' is an abstract class}}
};
void t3(const C&);
void f() {
C(); // expected-error {{allocation of an object of abstract type 'C'}}
t3(C()); // expected-error {{allocation of an object of abstract type 'C'}}
}
C e1[2]; // expected-error {{variable type 'C' is an abstract class}}
C (*e2)[2]; // expected-error {{variable type 'C' is an abstract class}}
C (**e3)[2]; // expected-error {{variable type 'C' is an abstract class}}
void t4(C c[2]); // expected-error {{parameter type 'C' is an abstract class}}
void t5(void (*)(C)); // expected-error {{parameter type 'C' is an abstract class}}
typedef void (*Func)(C); // expected-error {{parameter type 'C' is an abstract class}}
void t6(Func);
class F {
F a() { while (1) {} } // expected-error {{return type 'F' is an abstract class}}
class D {
void f(F c); // expected-error {{parameter type 'F' is an abstract class}}
};
union U {
void u(F c); // expected-error {{parameter type 'F' is an abstract class}}
};
virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
};
class Abstract;
void t7(Abstract a); // expected-error {{parameter type 'Abstract' is an abstract class}}
void t8() {
void h(Abstract a); // expected-error {{parameter type 'Abstract' is an abstract class}}
}
namespace N {
void h(Abstract a); // expected-error {{parameter type 'Abstract' is an abstract class}}
}
class Abstract {
virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
};
// <rdar://problem/6854087>
class foo {
public:
virtual foo *getFoo() = 0;
};
class bar : public foo {
public:
virtual bar *getFoo();
};
bar x;
// <rdar://problem/6902298>
class A {
public:
virtual void release() = 0;
virtual void release(int count) = 0;
virtual void retain() = 0;
};
class B : public A {
public:
virtual void release();
virtual void release(int count);
virtual void retain();
};
void foo(void) {
B b;
}
struct K {
int f;
virtual ~K();
};
struct L : public K {
void f();
};
// PR5222
namespace PR5222 {
struct A {
virtual A *clone() = 0;
};
struct B : public A {
virtual B *clone() = 0;
};
struct C : public B {
virtual C *clone();
};
C c;
}
// PR5550 - instantiating template didn't track overridden methods
namespace PR5550 {
struct A {
virtual void a() = 0;
virtual void b() = 0;
};
template<typename T> struct B : public A {
virtual void b();
virtual void c() = 0;
};
struct C : public B<int> {
virtual void a();
virtual void c();
};
C x;
}
namespace PureImplicit {
// A pure virtual destructor should be implicitly overridden.
struct A { virtual ~A() = 0; };
struct B : A {};
B x;
// A pure virtual assignment operator should be implicitly overridden.
struct D;
struct C { virtual D& operator=(const D&) = 0; };
struct D : C {};
D y;
}