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.
5namespace microsoft_exception_spec {
6
7void foo(); // expected-note {{previous declaration}}
8void foo() throw(); // expected-warning {{exception specification in declaration does not match previous declaration}}
9
10void r6() throw(...); // expected-note {{previous declaration}}
11void r6() throw(int); // expected-warning {{exception specification in declaration does not match previous declaration}}
12
13struct Base {
14  virtual void f2();
15  virtual void f3() throw(...);
16};
17
18struct Derived : Base {
19  virtual void f2() throw(...);
20  virtual void f3();
21};
22
23class A {
24  virtual ~A() throw();  // expected-note {{overridden virtual function is here}}
25};
26
27class 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
34struct 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
75struct M {
76    int __stdcall addP();
77    float __stdcall subtractP();
78};
79
80// __unaligned handling
81typedef char __unaligned *aligned_type;
82
83
84template<typename T> void h1(T (__stdcall M::* const )()) { }
85
86void m1() {
87  h1<int>(&M::addP);
88  h1(&M::subtractP);
89}
90
91
92
93
94
95void f(long long);
96void f(int);
97
98int 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.
107const int seventeen = 17;
108typedef int Int;
109
110struct 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
115enum : long long {  // expected-warning{{enumeration types with a fixed underlying type are a C++11 extension}}
116  SomeValue = 0x100000000
117};
118
119
120class AAA {
121__declspec(dllimport) void f(void) { }
122void 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
132template <class T>
133class BB {
134public:
135   void f(int g = 10 ); // expected-note {{previous definition is here}}
136};
137
138template <class T>
139void BB<T>::f(int g = 0) { } // expected-warning {{redefinition of default argument}}
140
141
142
143extern void static_func();
144void static_func(); // expected-note {{previous declaration is here}}
145
146
147static void static_func() // expected-warning {{redeclaring non-static 'static_func' as static is a Microsoft extension}}
148{
149
150}
151
152extern const int static_var; // expected-note {{previous declaration is here}}
153static const int static_var = 3; // expected-warning {{redeclaring non-static 'static_var' as static is a Microsoft extension}}
154
155long function_prototype(int a);
156long (*function_ptr)(int a);
157
158void function_to_voidptr_conv() {
159   void *a1 = function_prototype;
160   void *a2 = &function_prototype;
161   void *a3 = function_ptr;
162}
163
164
165void 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
179namespace friend_as_a_forward_decl {
180
181class A {
182  class Nested {
183    friend class B;
184    B* b;
185  };
186  B* b;
187};
188B* global_b;
189
190
191void f()
192{
193  class Local {
194    friend class Z;
195    Z* b;
196  };
197  Z* b;
198}
199
200}
201
202struct PR11150 {
203  class X {
204    virtual void f() = 0;
205  };
206
207  int array[__is_abstract(X)? 1 : -1];
208};
209
210void f() { int __except = 0; }
211
212void ::f(); // expected-warning{{extra qualification on member 'f'}}
213
214class C {
215  C::C(); // expected-warning{{extra qualification on member 'C'}}
216};
217
218struct 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};
228void 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 */
239struct SP1
240{
241  bool operator()() { return true; }
242};
243struct SP2
244{
245  __declspec(property(get=GetV)) SP1 V;
246  SP1 GetV() { return SP1(); }
247};
248void TestSP2() {
249  SP2 sp2;
250  bool b = sp2.V();
251}
252
253struct SP3 {
254  template <class T>
255  void f(T t) {}
256};
257template <class T>
258struct SP4
259{
260  __declspec(property(get=GetV)) int V;
261  int GetV() { return 123; }
262  void f() { SP3 s2; s2.f(V); }
263};
264void TestSP4() {
265  SP4<int> s;
266  s.f();
267}
268
269template <class T>
270struct SP5
271{
272  __declspec(property(get=GetV)) T V;
273  int GetV() { return 123; }
274  void f() { int *p = new int[V]; }
275};
276
277template <class T>
278struct SP6
279{
280public:
281  __declspec(property(get=GetV)) T V;
282  T GetV() { return 123; }
283  void f() { int t = V; }
284};
285void TestSP6() {
286  SP6<int> c;
287  c.f();
288}
289/* 4 tests for PseudoObject, end */
290
291// Property access: explicit, implicit, with Qualifier
292struct 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};
300struct SP8: public SP7 {
301  void AccessWithQualifier() { int i = SP7::V; SP7::V = i; }
302};
303
304// Property usage
305template <class T>
306struct 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};
314struct 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};
321void 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
343union 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.
349struct 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
359void SP11::UseV() {
360  TakePtr(&V);
361  TakeRef(V);
362  TakeVal(V);
363}
364
365struct StructWithUnnamedMember {
366  __declspec(property(get=GetV)) int : 10; // expected-error {{anonymous property is not supported}}
367};
368
369namespace 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
393struct 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}}
403struct 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'}}
412struct InheritFromSealed : SealedType {};
413
414void 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