1 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
2 namespace T1 {
3
4 class A {
5 virtual int f(); // expected-note{{overridden virtual function is here}}
6 };
7
8 class B : A {
9 virtual void f(); // expected-error{{virtual function 'f' has a different return type ('void') than the function it overrides (which has return type 'int')}}
10 };
11
12 }
13
14 namespace T2 {
15
16 struct a { };
17 struct b { };
18
19 class A {
20 virtual a* f(); // expected-note{{overridden virtual function is here}}
21 };
22
23 class B : A {
24 virtual b* f(); // expected-error{{return type of virtual function 'f' is not covariant with the return type of the function it overrides ('T2::b *' is not derived from 'T2::a *')}}
25 };
26
27 }
28
29 namespace T3 {
30
31 struct a { };
32 struct b : private a { }; // expected-note{{declared private here}}
33
34 class A {
35 virtual a* f(); // FIXME: desired-note{{overridden virtual function is here}}
36 };
37
38 class B : A {
39 virtual b* f(); // expected-error{{invalid covariant return for virtual function: 'T3::a' is a private base class of 'T3::b'}}
40 };
41
42 }
43
44 namespace T4 {
45
46 struct a { };
47 struct a1 : a { };
48 struct b : a, a1 { };
49
50 class A {
51 virtual a* f(); // expected-note{{overridden virtual function is here}}
52 };
53
54 class B : A {
55 virtual b* f(); // expected-error{{return type of virtual function 'f' is not covariant with the return type of the function it overrides (ambiguous conversion from derived class 'T4::b' to base class 'T4::a':\n\
56 struct T4::b -> struct T4::a\n\
57 struct T4::b -> struct T4::a1 -> struct T4::a)}}
58 };
59
60 }
61
62 namespace T5 {
63
64 struct a { };
65
66 class A {
67 virtual a* const f();
68 virtual a* const g(); // expected-note{{overridden virtual function is here}}
69 };
70
71 class B : A {
72 virtual a* const f();
73 virtual a* g(); // expected-error{{return type of virtual function 'g' is not covariant with the return type of the function it overrides ('T5::a *' has different qualifiers than 'T5::a *const')}}
74 };
75
76 }
77
78 namespace T6 {
79
80 struct a { };
81
82 class A {
83 virtual const a* f();
84 virtual a* g(); // expected-note{{overridden virtual function is here}}
85 };
86
87 class B : A {
88 virtual a* f();
89 virtual const a* g(); // expected-error{{return type of virtual function 'g' is not covariant with the return type of the function it overrides (class type 'const T6::a *' is more qualified than class type 'T6::a *'}}
90 };
91
92 }
93
94 namespace T7 {
95 struct a { };
96 struct b { };
97
98 class A {
99 a* f();
100 };
101
102 class B : A {
103 virtual b* f();
104 };
105 }
106
107 namespace T8 {
108 struct a { };
109 struct b; // expected-note {{forward declaration of 'T8::b'}}
110
111 class A {
112 virtual a *f();
113 };
114
115 class B : A {
116 b* f(); // expected-error {{return type of virtual function 'f' is not covariant with the return type of the function it overrides ('T8::b' is incomplete)}}
117 };
118 }
119
120 namespace T9 {
121 struct a { };
122
123 template<typename T> struct b : a {
124 int a[sizeof(T) ? -1 : -1]; // expected-error {{array with a negative size}}
125 };
126
127 class A {
128 virtual a *f();
129 };
130
131 class B : A {
132 virtual b<int> *f(); // expected-note {{in instantiation of template class 'T9::b<int>' requested here}}
133 };
134 }
135
136 // PR5656
137 class X0 {
138 virtual void f0();
139 };
140 class X1 : public X0 {
141 void f0() = 0;
142 };
143
144 template <typename Base>
145 struct Foo : Base {
146 void f(int) = 0; // expected-error{{not virtual and cannot be declared pure}}
147 };
148
149 struct Base1 { virtual void f(int); };
150 struct Base2 { };
151
test()152 void test() {
153 (void)sizeof(Foo<Base1>);
154 (void)sizeof(Foo<Base2>); // expected-note{{instantiation}}
155 }
156
157 template<typename Base>
158 struct Foo2 : Base {
159 template<typename T> int f(T);
160 };
161
test2()162 void test2() {
163 Foo2<Base1> f1;
164 Foo2<Base2> f2;
165 f1.f(17);
166 f2.f(17);
167 };
168
169 struct Foo3 {
170 virtual void f(int) = 0; // expected-note{{unimplemented pure virtual method}}
171 };
172
173 template<typename T>
174 struct Bar3 : Foo3 {
175 void f(T);
176 };
177
test3()178 void test3() {
179 Bar3<int> b3i; // okay
180 Bar3<float> b3f; // expected-error{{is an abstract class}}
181 }
182
183 // 5920
184 namespace PR5920 {
185 class Base {};
186
187 template <typename T>
188 class Derived : public Base {};
189
190 class Foo {
191 public:
192 virtual Base* Method();
193 };
194
195 class Bar : public Foo {
196 public:
197 virtual Derived<int>* Method();
198 };
199 }
200
201 // Look through template types and typedefs to see whether return types are
202 // pointers or references.
203 namespace PR6110 {
204 class Base {};
205 class Derived : public Base {};
206
207 typedef Base* BaseP;
208 typedef Derived* DerivedP;
209
210 class X { virtual BaseP f(); };
211 class X1 : public X { virtual DerivedP f(); };
212
213 template <typename T> class Y { virtual T f(); };
214 template <typename T1, typename T> class Y1 : public Y<T> { virtual T1 f(); };
215 Y1<Derived*, Base*> y;
216 }
217
218 // Defer checking for covariance if either return type is dependent.
219 namespace type_dependent_covariance {
220 struct B {};
221 template <int N> struct TD : public B {};
222 template <> struct TD<1> {};
223
224 template <int N> struct TB {};
225 struct D : public TB<0> {};
226
227 template <int N> struct X {
228 virtual B* f1(); // expected-note{{overridden virtual function is here}}
229 virtual TB<N>* f2(); // expected-note{{overridden virtual function is here}}
230 };
231 template <int N, int M> struct X1 : X<N> {
232 virtual TD<M>* f1(); // expected-error{{return type of virtual function 'f1' is not covariant with the return type of the function it overrides ('TD<1> *'}}
233 virtual D* f2(); // expected-error{{return type of virtual function 'f2' is not covariant with the return type of the function it overrides ('type_dependent_covariance::D *' is not derived from 'TB<1> *')}}
234 };
235
236 X1<0, 0> good;
237 X1<0, 1> bad_derived; // expected-note{{instantiation}}
238 X1<1, 0> bad_base; // expected-note{{instantiation}}
239 }
240
241 namespace T10 {
242 struct A { };
243 struct B : A { };
244
245 struct C {
246 virtual A&& f();
247 };
248
249 struct D : C {
250 virtual B&& f();
251 };
252 };
253
254 namespace T11 {
255 struct A { };
256 struct B : A { };
257
258 struct C {
259 virtual A& f(); // expected-note {{overridden virtual function is here}}
260 };
261
262 struct D : C {
263 virtual B&& f(); // expected-error {{virtual function 'f' has a different return type ('T11::B &&') than the function it overrides (which has return type 'T11::A &')}}
264 };
265 };
266
267 namespace T12 {
268 struct A { };
269 struct B : A { };
270
271 struct C {
272 virtual A&& f(); // expected-note {{overridden virtual function is here}}
273 };
274
275 struct D : C {
276 virtual B& f(); // expected-error {{virtual function 'f' has a different return type ('T12::B &') than the function it overrides (which has return type 'T12::A &&')}}
277 };
278 };
279
280 namespace PR8168 {
281 class A {
282 public:
foo()283 virtual void foo() {} // expected-note{{overridden virtual function is here}}
284 };
285
286 class B : public A {
287 public:
foo()288 static void foo() {} // expected-error{{'static' member function 'foo' overrides a virtual function}}
289 };
290 }
291