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
h1(T (__stdcall M::* const)())85 template<typename T> void h1(T (__stdcall M::* const )()) { }
86
m1()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
main()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 {
f(void)122 __declspec(dllimport) void f(void) { }
123 void f2(void); // expected-note{{previous declaration is here}}
124 };
125
f2(void)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>
f(int g=0)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
static_func()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
function_to_voidptr_conv()159 void function_to_voidptr_conv() {
160 void *a1 = function_prototype;
161 void *a2 = &function_prototype;
162 void *a3 = function_ptr;
163 }
164
165
pointer_to_integral_type_conv(char * ptr)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
f()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
GetVStructWithProperty203 int GetV() { return 123; }
SetVStructWithProperty204 void SetV(int i) {}
205 };
TestProperty()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 {
operator ()SP1219 bool operator()() { return true; }
220 };
221 struct SP2
222 {
223 __declspec(property(get=GetV)) SP1 V;
GetVSP2224 SP1 GetV() { return SP1(); }
225 };
TestSP2()226 void TestSP2() {
227 SP2 sp2;
228 bool b = sp2.V();
229 }
230
231 struct SP3 {
232 template <class T>
fSP3233 void f(T t) {}
234 };
235 template <class T>
236 struct SP4
237 {
238 __declspec(property(get=GetV)) int V;
GetVSP4239 int GetV() { return 123; }
fSP4240 void f() { SP3 s2; s2.f(V); }
241 };
TestSP4()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;
GetVSP5251 int GetV() { return 123; }
fSP5252 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;
GetVSP6260 T GetV() { return 123; }
fSP6261 void f() { int t = V; }
262 };
TestSP6()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;
GetVSP7272 int GetV() { return 123; }
SetVSP7273 void SetV(int v) {}
274
ImplicitAccessSP7275 void ImplicitAccess() { int i = V; V = i; }
ExplicitAccessSP7276 void ExplicitAccess() { int i = this->V; this->V = i; }
277 };
278 struct SP8: public SP7 {
AccessWithQualifierSP8279 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;
GetVSP9286 T GetV() { return 0; }
SetVSP9287 void SetV(T v) {}
fSP9288 bool f() { V = this->V; return V < this->V; }
gSP9289 void g() { V++; }
hSP9290 void h() { V*=2; }
291 };
292 struct SP10 {
SP10SP10293 SP10(int v) {}
operator <SP10294 bool operator<(const SP10& v) { return true; }
operator *SP10295 SP10 operator*(int v) { return *this; }
operator +SP10296 SP10 operator+(int v) { return *this; }
operator =SP10297 SP10& operator=(const SP10& v) { return *this; }
298 };
TestSP9()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;
GetVSP11330 int& GetV() { return _v; }
331 void UseV();
TakePtrSP11332 void TakePtr(int *) {}
TakeRefSP11333 void TakeRef(int &) {}
TakeValSP11334 void TakeVal(int) {}
335 };
336
UseV()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 struct MSPropertyClass {
getMSPropertyClass348 int get() { return 42; }
349 int __declspec(property(get = get)) n;
350 };
351
f(MSPropertyClass & x)352 int *f(MSPropertyClass &x) {
353 return &x.n; // expected-error {{address of property expression requested}}
354 }
g()355 int MSPropertyClass::*g() {
356 return &MSPropertyClass::n; // expected-error {{address of property expression requested}}
357 }
358
359 namespace rdar14250378 {
360 class Bar {};
361
362 namespace NyNamespace {
363 class Foo {
364 public:
365 Bar* EnsureBar();
366 };
367
368 class Baz : public Foo {
369 public:
370 friend class Bar;
371 };
372
EnsureBar()373 Bar* Foo::EnsureBar() {
374 return 0;
375 }
376 }
377 }
378
379 // expected-error@+1 {{'sealed' keyword not permitted with interface types}}
380 __interface InterfaceWithSealed sealed {
381 };
382
383 struct SomeBase {
384 virtual void OverrideMe();
385
386 // expected-note@+2 {{overridden virtual function is here}}
387 // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}}
388 virtual void SealedFunction() sealed; // expected-note {{overridden virtual function is here}}
389 };
390
391 // expected-note@+2 {{'SealedType' declared here}}
392 // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}}
393 struct SealedType sealed : SomeBase {
394 // expected-error@+2 {{declaration of 'SealedFunction' overrides a 'sealed' function}}
395 // FIXME. warning can be suppressed if we're also issuing error for overriding a 'final' function.
396 virtual void SealedFunction(); // expected-warning {{'SealedFunction' overrides a member function but is not marked 'override'}}
397
398 // expected-warning@+1 {{'override' keyword is a C++11 extension}}
399 virtual void OverrideMe() override;
400 };
401
402 // expected-error@+1 {{base 'SealedType' is marked 'sealed'}}
403 struct InheritFromSealed : SealedType {};
404
AfterClassBody()405 void AfterClassBody() {
406 // expected-warning@+1 {{attribute 'deprecated' is ignored, place it after "struct" to apply attribute to type declaration}}
407 struct D {} __declspec(deprecated);
408
409 struct __declspec(align(4)) S {} __declspec(align(8)) s1;
410 S s2;
411 _Static_assert(__alignof(S) == 4, "");
412 _Static_assert(__alignof(s1) == 8, "");
413 _Static_assert(__alignof(s2) == 4, "");
414 }
415