1 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
2 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fexceptions -fcxx-exceptions -DTEST2
3
4 #if TEST1
5
6 // Microsoft doesn't validate exception specification.
7 namespace microsoft_exception_spec {
8
9 void foo(); // expected-note {{previous declaration}}
10 void foo() throw(); // expected-warning {{exception specification in declaration does not match previous declaration}}
11
12 void r6() throw(...); // expected-note {{previous declaration}}
13 void r6() throw(int); // expected-warning {{exception specification in declaration does not match previous declaration}}
14
15 struct Base {
16 virtual void f2();
17 virtual void f3() throw(...);
18 };
19
20 struct Derived : Base {
21 virtual void f2() throw(...);
22 virtual void f3();
23 };
24
25 class A {
26 virtual ~A() throw(); // expected-note {{overridden virtual function is here}}
27 };
28
29 class B : public A {
30 virtual ~B(); // expected-warning {{exception specification of overriding function is more lax than base version}}
31 };
32
33 }
34
35 // MSVC allows type definition in anonymous union and struct
36 struct A
37 {
38 union
39 {
40 int a;
41 struct B // expected-warning {{types declared in an anonymous union are a Microsoft extension}}
42 {
43 int c;
44 } d;
45
46 union C // expected-warning {{types declared in an anonymous union are a Microsoft extension}}
47 {
48 int e;
49 int ee;
50 } f;
51
52 typedef int D; // expected-warning {{types declared in an anonymous union are a Microsoft extension}}
53 struct F; // expected-warning {{types declared in an anonymous union are a Microsoft extension}}
54 };
55
56 struct
57 {
58 int a2;
59
60 struct B2 // expected-warning {{types declared in an anonymous struct are a Microsoft extension}}
61 {
62 int c2;
63 } d2;
64
65 union C2 // expected-warning {{types declared in an anonymous struct are a Microsoft extension}}
66 {
67 int e2;
68 int ee2;
69 } f2;
70
71 typedef int D2; // expected-warning {{types declared in an anonymous struct are a Microsoft extension}}
72 struct F2; // expected-warning {{types declared in an anonymous struct are a Microsoft extension}}
73 };
74 };
75
76 // __stdcall handling
77 struct M {
78 int __stdcall addP();
79 float __stdcall subtractP();
80 };
81
82 // __unaligned handling
83 typedef char __unaligned *aligned_type;
84 typedef struct UnalignedTag { int f; } __unaligned *aligned_type2;
85 typedef char __unaligned aligned_type3;
86
87 struct aligned_type4 {
88 int i;
89 };
90
91 __unaligned int aligned_type4::*p1_aligned_type4 = &aligned_type4::i;
92 int aligned_type4::* __unaligned p2_aligned_type4 = &aligned_type4::i;
93 __unaligned int aligned_type4::* __unaligned p3_aligned_type4 = &aligned_type4::i;
94 void (aligned_type4::*__unaligned p4_aligned_type4)();
95
96 // Check that __unaligned qualifier can be used for overloading
foo_unaligned(int * arg)97 void foo_unaligned(int *arg) {}
foo_unaligned(__unaligned int * arg)98 void foo_unaligned(__unaligned int *arg) {}
foo_unaligned(int arg)99 void foo_unaligned(int arg) {} // expected-note {{previous definition is here}}
foo_unaligned(__unaligned int arg)100 void foo_unaligned(__unaligned int arg) {} // expected-error {{redefinition of 'foo_unaligned'}}
101 class A_unaligned {};
102 class B_unaligned : public A_unaligned {};
foo_unaligned(__unaligned A_unaligned * arg)103 int foo_unaligned(__unaligned A_unaligned *arg) { return 0; }
foo_unaligned(B_unaligned * arg)104 void *foo_unaligned(B_unaligned *arg) { return 0; }
105
test_unaligned()106 void test_unaligned() {
107 int *p1 = 0;
108 foo_unaligned(p1);
109
110 __unaligned int *p2 = 0;
111 foo_unaligned(p2);
112
113 __unaligned B_unaligned *p3 = 0;
114 int p4 = foo_unaligned(p3);
115
116 B_unaligned *p5 = p3; // expected-error {{cannot initialize a variable of type 'B_unaligned *' with an lvalue of type '__unaligned B_unaligned *'}}
117
118 __unaligned B_unaligned *p6 = p3;
119
120 p1_aligned_type4 = p2_aligned_type4;
121 p2_aligned_type4 = p1_aligned_type4; // expected-error {{assigning to 'int aligned_type4::*' from incompatible type '__unaligned int aligned_type4::*'}}
122 p3_aligned_type4 = p1_aligned_type4;
123
124 __unaligned int a[10];
125 int *b = a; // expected-error {{cannot initialize a variable of type 'int *' with an lvalue of type '__unaligned int [10]'}}
126 }
127
128 // Test from PR27367
129 // We should accept assignment of an __unaligned pointer to a non-__unaligned
130 // pointer to void
131 typedef struct _ITEMIDLIST { int i; } ITEMIDLIST;
132 typedef ITEMIDLIST __unaligned *LPITEMIDLIST;
133 extern "C" __declspec(dllimport) void __stdcall CoTaskMemFree(void* pv);
FreeIDListArray(LPITEMIDLIST * ppidls)134 __inline void FreeIDListArray(LPITEMIDLIST *ppidls) {
135 CoTaskMemFree(*ppidls);
136 __unaligned int *x = 0;
137 void *y = x;
138 }
139
140 // Test from PR27666
141 // We should accept type conversion of __unaligned to non-__unaligned references
142 typedef struct in_addr {
143 public:
in_addrin_addr144 in_addr(in_addr &a) {} // expected-note {{candidate constructor not viable: no known conversion from '__unaligned IN_ADDR *' (aka '__unaligned in_addr *') to 'in_addr &' for 1st argument; dereference the argument with *}}
in_addrin_addr145 in_addr(in_addr *a) {} // expected-note {{candidate constructor not viable: 1st argument ('__unaligned IN_ADDR *' (aka '__unaligned in_addr *')) would lose __unaligned qualifier}}
146 } IN_ADDR;
147
f(IN_ADDR __unaligned * a)148 void f(IN_ADDR __unaligned *a) {
149 IN_ADDR local_addr = *a;
150 IN_ADDR local_addr2 = a; // expected-error {{no viable conversion from '__unaligned IN_ADDR *' (aka '__unaligned in_addr *') to 'IN_ADDR' (aka 'in_addr')}}
151 }
152
h1(T (__stdcall M::* const)())153 template<typename T> void h1(T (__stdcall M::* const )()) { }
154
m1()155 void m1() {
156 h1<int>(&M::addP);
157 h1(&M::subtractP);
158 }
159
160
161
162
163
164 void f(long long);
165 void f(int);
166
main()167 int main()
168 {
169 // This is an ambiguous call in standard C++.
170 // This calls f(long long) in Microsoft mode because LL is always signed.
171 f(0xffffffffffffffffLL);
172 f(0xffffffffffffffffi64);
173 }
174
175 // Enumeration types with a fixed underlying type.
176 const int seventeen = 17;
177 typedef int Int;
178
179 struct X0 {
180 enum E1 : Int { SomeOtherValue } field; // expected-warning{{enumeration types with a fixed underlying type are a C++11 extension}}
181 enum E1 : seventeen;
182 };
183
184 enum : long long { // expected-warning{{enumeration types with a fixed underlying type are a C++11 extension}}
185 SomeValue = 0x100000000
186 };
187
188
189 class AAA {
f(void)190 __declspec(dllimport) void f(void) { }
191 void f2(void); // expected-note{{previous declaration is here}}
192 };
193
f2(void)194 __declspec(dllimport) void AAA::f2(void) { // expected-error{{dllimport cannot be applied to non-inline function definition}}
195 // expected-error@-1{{redeclaration of 'AAA::f2' cannot add 'dllimport' attribute}}
196
197 }
198
199
200
201 template <class T>
202 class BB {
203 public:
204 void f(int g = 10 ); // expected-note {{previous definition is here}}
205 };
206
207 template <class T>
f(int g=0)208 void BB<T>::f(int g = 0) { } // expected-warning {{redefinition of default argument}}
209
210
211
212 extern void static_func();
213 void static_func(); // expected-note {{previous declaration is here}}
214
215
static_func()216 static void static_func() // expected-warning {{redeclaring non-static 'static_func' as static is a Microsoft extension}}
217 {
218
219 }
220
221 extern const int static_var; // expected-note {{previous declaration is here}}
222 static const int static_var = 3; // expected-warning {{redeclaring non-static 'static_var' as static is a Microsoft extension}}
223
pointer_to_integral_type_conv(char * ptr)224 void pointer_to_integral_type_conv(char* ptr) {
225 char ch = (char)ptr;
226 short sh = (short)ptr;
227 ch = (char)ptr;
228 sh = (short)ptr;
229
230 // These are valid C++.
231 bool b = (bool)ptr;
232 b = static_cast<bool>(ptr);
233
234 // This is bad.
235 b = reinterpret_cast<bool>(ptr); // expected-error {{cast from pointer to smaller type 'bool' loses information}}
236 }
237
238 struct PR11150 {
239 class X {
240 virtual void f() = 0;
241 };
242
243 int array[__is_abstract(X)? 1 : -1];
244 };
245
f()246 void f() { int __except = 0; }
247
248 void ::f(); // expected-warning{{extra qualification on member 'f'}}
249
250 class C {
251 C::C(); // expected-warning{{extra qualification on member 'C'}}
252 };
253
254 struct StructWithProperty {
255 __declspec(property(get=GetV)) int V1;
256 __declspec(property(put=SetV)) int V2;
257 __declspec(property(get=GetV, put=SetV_NotExist)) int V3;
258 __declspec(property(get=GetV_NotExist, put=SetV)) int V4;
259 __declspec(property(get=GetV, put=SetV)) int V5;
260
GetVStructWithProperty261 int GetV() { return 123; }
SetVStructWithProperty262 void SetV(int i) {}
263 };
TestProperty()264 void TestProperty() {
265 StructWithProperty sp;
266 int i = sp.V2; // expected-error{{no getter defined for property 'V2'}}
267 sp.V1 = 12; // expected-error{{no setter defined for property 'V1'}}
268 int j = sp.V4; // expected-error{{no member named 'GetV_NotExist' in 'StructWithProperty'}} expected-error{{cannot find suitable getter for property 'V4'}}
269 sp.V3 = 14; // expected-error{{no member named 'SetV_NotExist' in 'StructWithProperty'}} expected-error{{cannot find suitable setter for property 'V3'}}
270 int k = sp.V5;
271 sp.V5 = k++;
272 }
273
274 /* 4 tests for PseudoObject, begin */
275 struct SP1
276 {
operator ()SP1277 bool operator()() { return true; }
278 };
279 struct SP2
280 {
281 __declspec(property(get=GetV)) SP1 V;
GetVSP2282 SP1 GetV() { return SP1(); }
283 };
TestSP2()284 void TestSP2() {
285 SP2 sp2;
286 bool b = sp2.V();
287 }
288
289 struct SP3 {
290 template <class T>
fSP3291 void f(T t) {}
292 };
293 template <class T>
294 struct SP4
295 {
296 __declspec(property(get=GetV)) int V;
GetVSP4297 int GetV() { return 123; }
fSP4298 void f() { SP3 s2; s2.f(V); }
299 };
TestSP4()300 void TestSP4() {
301 SP4<int> s;
302 s.f();
303 }
304
305 template <class T>
306 struct SP5
307 {
308 __declspec(property(get=GetV)) T V;
GetVSP5309 int GetV() { return 123; }
fSP5310 void f() { int *p = new int[V]; }
311 };
312
313 template <class T>
314 struct SP6
315 {
316 public:
317 __declspec(property(get=GetV)) T V;
GetVSP6318 T GetV() { return 123; }
fSP6319 void f() { int t = V; }
320 };
TestSP6()321 void TestSP6() {
322 SP6<int> c;
323 c.f();
324 }
325 /* 4 tests for PseudoObject, end */
326
327 // Property access: explicit, implicit, with Qualifier
328 struct SP7 {
329 __declspec(property(get=GetV, put=SetV)) int V;
GetVSP7330 int GetV() { return 123; }
SetVSP7331 void SetV(int v) {}
332
ImplicitAccessSP7333 void ImplicitAccess() { int i = V; V = i; }
ExplicitAccessSP7334 void ExplicitAccess() { int i = this->V; this->V = i; }
335 };
336 struct SP8: public SP7 {
AccessWithQualifierSP8337 void AccessWithQualifier() { int i = SP7::V; SP7::V = i; }
338 };
339
340 // Property usage
341 template <class T>
342 struct SP9 {
343 __declspec(property(get=GetV, put=SetV)) T V;
GetVSP9344 T GetV() { return 0; }
SetVSP9345 void SetV(T v) {}
fSP9346 bool f() { V = this->V; return V < this->V; }
gSP9347 void g() { V++; }
hSP9348 void h() { V*=2; }
349 };
350 struct SP10 {
SP10SP10351 SP10(int v) {}
operator <SP10352 bool operator<(const SP10& v) { return true; }
operator *SP10353 SP10 operator*(int v) { return *this; }
operator +SP10354 SP10 operator+(int v) { return *this; }
operator =SP10355 SP10& operator=(const SP10& v) { return *this; }
356 };
TestSP9()357 void TestSP9() {
358 SP9<int> c;
359 int i = c.V; // Decl initializer
360 i = c.V; // Binary op operand
361 c.SetV(c.V); // CallExpr arg
362 int *p = new int[c.V + 1]; // Array size
363 p[c.V] = 1; // Array index
364
365 c.V = 123; // Setter
366
367 c.V++; // Unary op operand
368 c.V *= 2; // Unary op operand
369
370 SP9<int*> c2;
371 c2.V[0] = 123; // Array
372
373 SP9<SP10> c3;
374 c3.f(); // Overloaded binary op operand
375 c3.g(); // Overloaded incdec op operand
376 c3.h(); // Overloaded unary op operand
377 }
378
379 union u {
380 int *i1;
381 int &i2; // expected-warning {{union member 'i2' has reference type 'int &', which is a Microsoft extension}}
382 };
383
384 // Property getter using reference.
385 struct SP11 {
386 __declspec(property(get=GetV)) int V;
387 int _v;
GetVSP11388 int& GetV() { return _v; }
389 void UseV();
TakePtrSP11390 void TakePtr(int *) {}
TakeRefSP11391 void TakeRef(int &) {}
TakeValSP11392 void TakeVal(int) {}
393 };
394
UseV()395 void SP11::UseV() {
396 TakePtr(&V);
397 TakeRef(V);
398 TakeVal(V);
399 }
400
401 struct StructWithUnnamedMember {
402 __declspec(property(get=GetV)) int : 10; // expected-error {{anonymous property is not supported}}
403 };
404
405 struct MSPropertyClass {
getMSPropertyClass406 int get() { return 42; }
407 int __declspec(property(get = get)) n;
408 };
409
f(MSPropertyClass & x)410 int *f(MSPropertyClass &x) {
411 return &x.n; // expected-error {{address of property expression requested}}
412 }
g()413 int MSPropertyClass::*g() {
414 return &MSPropertyClass::n; // expected-error {{address of property expression requested}}
415 }
416
417 namespace rdar14250378 {
418 class Bar {};
419
420 namespace NyNamespace {
421 class Foo {
422 public:
423 Bar* EnsureBar();
424 };
425
426 class Baz : public Foo {
427 public:
428 friend class Bar;
429 };
430
EnsureBar()431 Bar* Foo::EnsureBar() {
432 return 0;
433 }
434 }
435 }
436
437 // expected-error@+1 {{'sealed' keyword not permitted with interface types}}
438 __interface InterfaceWithSealed sealed {
439 };
440
441 struct SomeBase {
442 virtual void OverrideMe();
443
444 // expected-note@+2 {{overridden virtual function is here}}
445 // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}}
446 virtual void SealedFunction() sealed; // expected-note {{overridden virtual function is here}}
447 };
448
449 // expected-note@+2 {{'SealedType' declared here}}
450 // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}}
451 struct SealedType sealed : SomeBase {
452 // expected-error@+2 {{declaration of 'SealedFunction' overrides a 'sealed' function}}
453 // FIXME. warning can be suppressed if we're also issuing error for overriding a 'final' function.
454 virtual void SealedFunction(); // expected-warning {{'SealedFunction' overrides a member function but is not marked 'override'}}
455
456 // expected-warning@+1 {{'override' keyword is a C++11 extension}}
457 virtual void OverrideMe() override;
458 };
459
460 // expected-error@+1 {{base 'SealedType' is marked 'sealed'}}
461 struct InheritFromSealed : SealedType {};
462
AfterClassBody()463 void AfterClassBody() {
464 // expected-warning@+1 {{attribute 'deprecated' is ignored, place it after "struct" to apply attribute to type declaration}}
465 struct D {} __declspec(deprecated);
466
467 struct __declspec(align(4)) S {} __declspec(align(8)) s1;
468 S s2;
469 _Static_assert(__alignof(S) == 4, "");
470 _Static_assert(__alignof(s1) == 8, "");
471 _Static_assert(__alignof(s2) == 4, "");
472 }
473
474 namespace PR24246 {
475 template <typename TX> struct A {
476 template <bool> struct largest_type_select;
477 // expected-warning@+1 {{explicit specialization of 'largest_type_select' within class scope is a Microsoft extension}}
478 template <> struct largest_type_select<false> {
479 blah x; // expected-error {{unknown type name 'blah'}}
480 };
481 };
482 }
483
484 namespace PR25265 {
485 struct S {
486 int fn() throw(); // expected-note {{previous declaration is here}}
487 };
488
fn()489 int S::fn() { return 0; } // expected-warning {{is missing exception specification}}
490 }
491
492 #elif TEST2
493
494 // Check that __unaligned is not recognized if MS extensions are not enabled
495 typedef char __unaligned *aligned_type; // expected-error {{expected ';' after top level declarator}}
496
497 #else
498
499 #error Unknown test mode
500
501 #endif
502
503