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 { }; 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 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 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 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: 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
