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