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 
83 
84 template<typename T> void h1(T (__stdcall M::* const )()) { }
85 
86 void m1() {
87   h1<int>(&M::addP);
88   h1(&M::subtractP);
89 }
90 
91 
92 
93 
94 
95 void f(long long);
96 void f(int);
97 
98 int main()
99 {
100   // This is an ambiguous call in standard C++.
101   // This calls f(long long) in Microsoft mode because LL is always signed.
102   f(0xffffffffffffffffLL);
103   f(0xffffffffffffffffi64);
104 }
105 
106 // Enumeration types with a fixed underlying type.
107 const int seventeen = 17;
108 typedef int Int;
109 
110 struct X0 {
111   enum E1 : Int { SomeOtherValue } field; // expected-warning{{enumeration types with a fixed underlying type are a C++11 extension}}
112   enum E1 : seventeen;
113 };
114 
115 enum : long long {  // expected-warning{{enumeration types with a fixed underlying type are a C++11 extension}}
116   SomeValue = 0x100000000
117 };
118 
119 
120 class AAA {
121 __declspec(dllimport) void f(void) { }
122 void f2(void); // expected-note{{previous declaration is here}}
123 };
124 
125 __declspec(dllimport) void AAA::f2(void) { // expected-error{{dllimport cannot be applied to non-inline function definition}}
126                                            // expected-error@-1{{redeclaration of 'AAA::f2' cannot add 'dllimport' attribute}}
127 
128 }
129 
130 
131 
132 template <class T>
133 class BB {
134 public:
135    void f(int g = 10 ); // expected-note {{previous definition is here}}
136 };
137 
138 template <class T>
139 void BB<T>::f(int g = 0) { } // expected-warning {{redefinition of default argument}}
140 
141 
142 
143 extern void static_func();
144 void static_func(); // expected-note {{previous declaration is here}}
145 
146 
147 static void static_func() // expected-warning {{redeclaring non-static 'static_func' as static is a Microsoft extension}}
148 {
149 
150 }
151 
152 extern const int static_var; // expected-note {{previous declaration is here}}
153 static const int static_var = 3; // expected-warning {{redeclaring non-static 'static_var' as static is a Microsoft extension}}
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   bool f() { V = this->V; return 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 
389 // expected-error@+1 {{'sealed' keyword not permitted with interface types}}
390 __interface InterfaceWithSealed sealed {
391 };
392 
393 struct SomeBase {
394   virtual void OverrideMe();
395 
396   // expected-note@+2 {{overridden virtual function is here}}
397   // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}}
398   virtual void SealedFunction() sealed;
399 };
400 
401 // expected-note@+2 {{'SealedType' declared here}}
402 // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}}
403 struct SealedType sealed : SomeBase {
404   // expected-error@+1 {{declaration of 'SealedFunction' overrides a 'sealed' function}}
405   virtual void SealedFunction();
406 
407   // expected-warning@+1 {{'override' keyword is a C++11 extension}}
408   virtual void OverrideMe() override;
409 };
410 
411 // expected-error@+1 {{base 'SealedType' is marked 'sealed'}}
412 struct InheritFromSealed : SealedType {};
413 
414 void AfterClassBody() {
415   // expected-warning@+1 {{attribute 'deprecated' is ignored, place it after "struct" to apply attribute to type declaration}}
416   struct D {} __declspec(deprecated);
417 
418   struct __declspec(align(4)) S {} __declspec(align(8)) s1;
419   S s2;
420   _Static_assert(__alignof(S) == 4, "");
421   _Static_assert(__alignof(s1) == 8, "");
422   _Static_assert(__alignof(s2) == 4, "");
423 }
424