1 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions 2 3 4 // Microsoft doesn't validate exception specification. 5 namespace microsoft_exception_spec { 6 7 void foo(); // expected-note {{previous declaration}} 8 void foo() throw(); // expected-warning {{exception specification in declaration does not match previous declaration}} 9 10 void r6() throw(...); // expected-note {{previous declaration}} 11 void r6() throw(int); // expected-warning {{exception specification in declaration does not match previous declaration}} 12 13 struct Base { 14 virtual void f2(); 15 virtual void f3() throw(...); 16 }; 17 18 struct Derived : Base { 19 virtual void f2() throw(...); 20 virtual void f3(); 21 }; 22 23 class A { 24 virtual ~A() throw(); // expected-note {{overridden virtual function is here}} 25 }; 26 27 class B : public A { 28 virtual ~B(); // expected-warning {{exception specification of overriding function is more lax than base version}} 29 }; 30 31 } 32 33 // MSVC allows type definition in anonymous union and struct 34 struct A 35 { 36 union 37 { 38 int a; 39 struct B // expected-warning {{types declared in an anonymous union are a Microsoft extension}} 40 { 41 int c; 42 } d; 43 44 union C // expected-warning {{types declared in an anonymous union are a Microsoft extension}} 45 { 46 int e; 47 int ee; 48 } f; 49 50 typedef int D; // expected-warning {{types declared in an anonymous union are a Microsoft extension}} 51 struct F; // expected-warning {{types declared in an anonymous union are a Microsoft extension}} 52 }; 53 54 struct 55 { 56 int a2; 57 58 struct B2 // expected-warning {{types declared in an anonymous struct are a Microsoft extension}} 59 { 60 int c2; 61 } d2; 62 63 union C2 // expected-warning {{types declared in an anonymous struct are a Microsoft extension}} 64 { 65 int e2; 66 int ee2; 67 } f2; 68 69 typedef int D2; // expected-warning {{types declared in an anonymous struct are a Microsoft extension}} 70 struct F2; // expected-warning {{types declared in an anonymous struct are a Microsoft extension}} 71 }; 72 }; 73 74 // __stdcall handling 75 struct M { 76 int __stdcall addP(); 77 float __stdcall subtractP(); 78 }; 79 80 // __unaligned handling 81 typedef char __unaligned *aligned_type; 82 typedef struct UnalignedTag { int f; } __unaligned *aligned_type2; 83 84 85 template<typename T> void h1(T (__stdcall M::* const )()) { } 86 87 void m1() { 88 h1<int>(&M::addP); 89 h1(&M::subtractP); 90 } 91 92 93 94 95 96 void f(long long); 97 void f(int); 98 99 int main() 100 { 101 // This is an ambiguous call in standard C++. 102 // This calls f(long long) in Microsoft mode because LL is always signed. 103 f(0xffffffffffffffffLL); 104 f(0xffffffffffffffffi64); 105 } 106 107 // Enumeration types with a fixed underlying type. 108 const int seventeen = 17; 109 typedef int Int; 110 111 struct X0 { 112 enum E1 : Int { SomeOtherValue } field; // expected-warning{{enumeration types with a fixed underlying type are a C++11 extension}} 113 enum E1 : seventeen; 114 }; 115 116 enum : long long { // expected-warning{{enumeration types with a fixed underlying type are a C++11 extension}} 117 SomeValue = 0x100000000 118 }; 119 120 121 class AAA { 122 __declspec(dllimport) void f(void) { } 123 void f2(void); // expected-note{{previous declaration is here}} 124 }; 125 126 __declspec(dllimport) void AAA::f2(void) { // expected-error{{dllimport cannot be applied to non-inline function definition}} 127 // expected-error@-1{{redeclaration of 'AAA::f2' cannot add 'dllimport' attribute}} 128 129 } 130 131 132 133 template <class T> 134 class BB { 135 public: 136 void f(int g = 10 ); // expected-note {{previous definition is here}} 137 }; 138 139 template <class T> 140 void BB<T>::f(int g = 0) { } // expected-warning {{redefinition of default argument}} 141 142 143 144 extern void static_func(); 145 void static_func(); // expected-note {{previous declaration is here}} 146 147 148 static void static_func() // expected-warning {{redeclaring non-static 'static_func' as static is a Microsoft extension}} 149 { 150 151 } 152 153 extern const int static_var; // expected-note {{previous declaration is here}} 154 static const int static_var = 3; // expected-warning {{redeclaring non-static 'static_var' as static is a Microsoft extension}} 155 156 long function_prototype(int a); 157 long (*function_ptr)(int a); 158 159 void function_to_voidptr_conv() { 160 void *a1 = function_prototype; 161 void *a2 = &function_prototype; 162 void *a3 = function_ptr; 163 } 164 165 166 void pointer_to_integral_type_conv(char* ptr) { 167 char ch = (char)ptr; 168 short sh = (short)ptr; 169 ch = (char)ptr; 170 sh = (short)ptr; 171 172 // These are valid C++. 173 bool b = (bool)ptr; 174 b = static_cast<bool>(ptr); 175 176 // This is bad. 177 b = reinterpret_cast<bool>(ptr); // expected-error {{cast from pointer to smaller type 'bool' loses information}} 178 } 179 180 struct PR11150 { 181 class X { 182 virtual void f() = 0; 183 }; 184 185 int array[__is_abstract(X)? 1 : -1]; 186 }; 187 188 void f() { int __except = 0; } 189 190 void ::f(); // expected-warning{{extra qualification on member 'f'}} 191 192 class C { 193 C::C(); // expected-warning{{extra qualification on member 'C'}} 194 }; 195 196 struct StructWithProperty { 197 __declspec(property(get=GetV)) int V1; 198 __declspec(property(put=SetV)) int V2; 199 __declspec(property(get=GetV, put=SetV_NotExist)) int V3; 200 __declspec(property(get=GetV_NotExist, put=SetV)) int V4; 201 __declspec(property(get=GetV, put=SetV)) int V5; 202 203 int GetV() { return 123; } 204 void SetV(int i) {} 205 }; 206 void TestProperty() { 207 StructWithProperty sp; 208 int i = sp.V2; // expected-error{{no getter defined for property 'V2'}} 209 sp.V1 = 12; // expected-error{{no setter defined for property 'V1'}} 210 int j = sp.V4; // expected-error{{no member named 'GetV_NotExist' in 'StructWithProperty'}} expected-error{{cannot find suitable getter for property 'V4'}} 211 sp.V3 = 14; // expected-error{{no member named 'SetV_NotExist' in 'StructWithProperty'}} expected-error{{cannot find suitable setter for property 'V3'}} 212 int k = sp.V5; 213 sp.V5 = k++; 214 } 215 216 /* 4 tests for PseudoObject, begin */ 217 struct SP1 218 { 219 bool operator()() { return true; } 220 }; 221 struct SP2 222 { 223 __declspec(property(get=GetV)) SP1 V; 224 SP1 GetV() { return SP1(); } 225 }; 226 void TestSP2() { 227 SP2 sp2; 228 bool b = sp2.V(); 229 } 230 231 struct SP3 { 232 template <class T> 233 void f(T t) {} 234 }; 235 template <class T> 236 struct SP4 237 { 238 __declspec(property(get=GetV)) int V; 239 int GetV() { return 123; } 240 void f() { SP3 s2; s2.f(V); } 241 }; 242 void TestSP4() { 243 SP4<int> s; 244 s.f(); 245 } 246 247 template <class T> 248 struct SP5 249 { 250 __declspec(property(get=GetV)) T V; 251 int GetV() { return 123; } 252 void f() { int *p = new int[V]; } 253 }; 254 255 template <class T> 256 struct SP6 257 { 258 public: 259 __declspec(property(get=GetV)) T V; 260 T GetV() { return 123; } 261 void f() { int t = V; } 262 }; 263 void TestSP6() { 264 SP6<int> c; 265 c.f(); 266 } 267 /* 4 tests for PseudoObject, end */ 268 269 // Property access: explicit, implicit, with Qualifier 270 struct SP7 { 271 __declspec(property(get=GetV, put=SetV)) int V; 272 int GetV() { return 123; } 273 void SetV(int v) {} 274 275 void ImplicitAccess() { int i = V; V = i; } 276 void ExplicitAccess() { int i = this->V; this->V = i; } 277 }; 278 struct SP8: public SP7 { 279 void AccessWithQualifier() { int i = SP7::V; SP7::V = i; } 280 }; 281 282 // Property usage 283 template <class T> 284 struct SP9 { 285 __declspec(property(get=GetV, put=SetV)) T V; 286 T GetV() { return 0; } 287 void SetV(T v) {} 288 bool f() { V = this->V; return V < this->V; } 289 void g() { V++; } 290 void h() { V*=2; } 291 }; 292 struct SP10 { 293 SP10(int v) {} 294 bool operator<(const SP10& v) { return true; } 295 SP10 operator*(int v) { return *this; } 296 SP10 operator+(int v) { return *this; } 297 SP10& operator=(const SP10& v) { return *this; } 298 }; 299 void TestSP9() { 300 SP9<int> c; 301 int i = c.V; // Decl initializer 302 i = c.V; // Binary op operand 303 c.SetV(c.V); // CallExpr arg 304 int *p = new int[c.V + 1]; // Array size 305 p[c.V] = 1; // Array index 306 307 c.V = 123; // Setter 308 309 c.V++; // Unary op operand 310 c.V *= 2; // Unary op operand 311 312 SP9<int*> c2; 313 c2.V[0] = 123; // Array 314 315 SP9<SP10> c3; 316 c3.f(); // Overloaded binary op operand 317 c3.g(); // Overloaded incdec op operand 318 c3.h(); // Overloaded unary op operand 319 } 320 321 union u { 322 int *i1; 323 int &i2; // expected-warning {{union member 'i2' has reference type 'int &', which is a Microsoft extension}} 324 }; 325 326 // Property getter using reference. 327 struct SP11 { 328 __declspec(property(get=GetV)) int V; 329 int _v; 330 int& GetV() { return _v; } 331 void UseV(); 332 void TakePtr(int *) {} 333 void TakeRef(int &) {} 334 void TakeVal(int) {} 335 }; 336 337 void SP11::UseV() { 338 TakePtr(&V); 339 TakeRef(V); 340 TakeVal(V); 341 } 342 343 struct StructWithUnnamedMember { 344 __declspec(property(get=GetV)) int : 10; // expected-error {{anonymous property is not supported}} 345 }; 346 347 namespace rdar14250378 { 348 class Bar {}; 349 350 namespace NyNamespace { 351 class Foo { 352 public: 353 Bar* EnsureBar(); 354 }; 355 356 class Baz : public Foo { 357 public: 358 friend class Bar; 359 }; 360 361 Bar* Foo::EnsureBar() { 362 return 0; 363 } 364 } 365 } 366 367 // expected-error@+1 {{'sealed' keyword not permitted with interface types}} 368 __interface InterfaceWithSealed sealed { 369 }; 370 371 struct SomeBase { 372 virtual void OverrideMe(); 373 374 // expected-note@+2 {{overridden virtual function is here}} 375 // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}} 376 virtual void SealedFunction() sealed; // expected-note {{overridden virtual function is here}} 377 }; 378 379 // expected-note@+2 {{'SealedType' declared here}} 380 // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}} 381 struct SealedType sealed : SomeBase { 382 // expected-error@+2 {{declaration of 'SealedFunction' overrides a 'sealed' function}} 383 // FIXME. warning can be suppressed if we're also issuing error for overriding a 'final' function. 384 virtual void SealedFunction(); // expected-warning {{'SealedFunction' overrides a member function but is not marked 'override'}} 385 386 // expected-warning@+1 {{'override' keyword is a C++11 extension}} 387 virtual void OverrideMe() override; 388 }; 389 390 // expected-error@+1 {{base 'SealedType' is marked 'sealed'}} 391 struct InheritFromSealed : SealedType {}; 392 393 void AfterClassBody() { 394 // expected-warning@+1 {{attribute 'deprecated' is ignored, place it after "struct" to apply attribute to type declaration}} 395 struct D {} __declspec(deprecated); 396 397 struct __declspec(align(4)) S {} __declspec(align(8)) s1; 398 S s2; 399 _Static_assert(__alignof(S) == 4, ""); 400 _Static_assert(__alignof(s1) == 8, ""); 401 _Static_assert(__alignof(s2) == 4, ""); 402 } 403