Clang Project

clang_source_code/test/SemaCXX/virtual-override.cpp
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
3namespace T1 {
4
5class A {
6  virtual int f(); // expected-note{{overridden virtual function is here}}
7};
8
9class 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
15namespace T2 {
16
17struct a { };
18struct b { };
19  
20class A {
21  virtual a* f(); // expected-note{{overridden virtual function is here}}
22};
23
24class 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
30namespace T3 {
31
32struct a { };
33struct b : private a { }; // expected-note{{declared private here}}
34  
35class A {
36  virtual a* f(); // FIXME: desired-note{{overridden virtual function is here}}
37};
38
39class 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
45namespace T4 {
46
47struct a { };
48struct a1 : a { };
49struct 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  
51class A {
52  virtual a* f(); // expected-note{{overridden virtual function is here}}
53};
54
55class 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
63namespace T5 {
64  
65struct a { };
66
67class A {
68  virtual a* const f(); 
69  virtual a* const g(); // expected-note{{overridden virtual function is here}}
70};
71
72class 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
79namespace T6 {
80  
81struct a { };
82
83class A {
84  virtual const a* f(); 
85  virtual a* g(); // expected-note{{overridden virtual function is here}}
86};
87
88class 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
95namespace 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
108namespace 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
121namespace 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
138class X0 {
139  virtual void f0();
140};
141class X1 : public X0 {
142  void f0() = 0;
143};
144
145template <typename Base>
146struct Foo : Base { 
147  void f(int) = 0; // expected-error{{not virtual and cannot be declared pure}}
148};
149
150struct Base1 { virtual void f(int); };
151struct Base2 { };
152
153void test() {
154  (void)sizeof(Foo<Base1>);
155  (void)sizeof(Foo<Base2>); // expected-note{{instantiation}}
156}
157
158template<typename Base>
159struct Foo2 : Base {
160  template<typename T> int f(T);
161};
162
163void test2() {
164  Foo2<Base1> f1;
165  Foo2<Base2> f2;
166  f1.f(17);
167  f2.f(17);
168};
169
170struct Foo3 {
171  virtual void f(int) = 0; // expected-note{{unimplemented pure virtual method}}
172};
173
174template<typename T>
175struct Bar3 : Foo3 {
176  void f(T);
177};
178
179void test3() {
180  Bar3<int> b3i; // okay
181  Bar3<float> b3f; // expected-error{{is an abstract class}}
182}
183
184// 5920
185namespace 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.
204namespace 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.
220namespace 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
242namespace 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
255namespace 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
268namespace 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
281namespace PR8168 {
282  class A {
283  public:
284    virtual void foo() {} // expected-note{{overridden virtual function is here}}
285  };
286
287  class B : public A {
288  public:
289    static void foo() {} // expected-error{{'static' member function 'foo' overrides a virtual function}}
290  };
291}
292
CodeThinker, Enjoy your reading code