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