blob: 3e61cc386eb81d3af1e21b6b75a114c2fd56d4d7 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
// 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 {{array of abstract class type 'C'}}
C (*e2)[2]; // expected-error {{array of abstract class type 'C'}}
C (**e3)[2]; // expected-error {{array of abstract class type 'C'}}
void t4(C c[2]); // expected-error {{array of abstract class type 'C'}}
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;
}
|
