Clang Project

clang_source_code/test/SemaCXX/MicrosoftCompatibility.cpp
1// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -Wmicrosoft -verify -fms-compatibility -fexceptions -fcxx-exceptions -fms-compatibility-version=19.00
2// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -Wmicrosoft -verify -fms-compatibility -fexceptions -fcxx-exceptions -fms-compatibility-version=18.00
3
4#if defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT
5char16_t x;
6char32_t y;
7#else
8typedef unsigned short char16_t;
9typedef unsigned int char32_t;
10#endif
11
12_Atomic(int) z;
13template <typename T>
14struct _Atomic {
15  _Atomic() {}
16  ~_Atomic() {}
17};
18template <typename T>
19struct atomic : _Atomic<T> {
20  typedef _Atomic<T> TheBase;
21  TheBase field;
22};
23_Atomic(int) alpha;
24
25typename decltype(3) a; // expected-warning {{expected a qualified name after 'typename'}}
26
27namespace ms_conversion_rules {
28
29void f(float a);
30void f(int a);
31
32void test()
33{
34    long a = 0;
35    f((long)0);
36 f(a);
37}
38
39}
40
41
42namespace ms_predefined_types {
43  // ::type_info is a built-in forward class declaration.
44  void f(const type_info &a);
45  void f(size_t);
46}
47
48
49namespace ms_protected_scope {
50  struct C { C(); };
51
52  int jump_over_variable_init(bool b) {
53    if (b)
54      goto foo; // expected-warning {{jump from this goto statement to its label is a Microsoft extension}}
55    C c; // expected-note {{jump bypasses variable initialization}}
56  foo:
57    return 1;
58  }
59
60struct Y {
61  ~Y();
62};
63
64void jump_over_var_with_dtor() {
65  goto end; // expected-warning{{jump from this goto statement to its label is a Microsoft extension}}
66  Y y; // expected-note {{jump bypasses variable with a non-trivial destructor}}
67 end:
68    ;
69}
70
71  void jump_over_variable_case(int c) {
72    switch (c) {
73    case 0:
74      int x = 56; // expected-note {{jump bypasses variable initialization}}
75    case 1:       // expected-error {{cannot jump}}
76      x = 10;
77    }
78  }
79
80 
81void exception_jump() {
82  goto l2; // expected-error {{cannot jump}}
83  try { // expected-note {{jump bypasses initialization of try block}}
84     l2: ;
85  } catch(int) {
86  }
87}
88
89int jump_over_indirect_goto() {
90  static void *ps[] = { &&a0 };
91  goto *&&a0; // expected-warning {{jump from this goto statement to its label is a Microsoft extension}}
92  int a = 3; // expected-note {{jump bypasses variable initialization}}
93 a0:
94  return 0;
95}
96  
97}
98
99namespace PR11826 {
100  struct pair {
101    pair(int v) { }
102#if _MSC_VER >= 1900
103    void operator=(pair&& rhs) { } // expected-note {{copy constructor is implicitly deleted because 'pair' has a user-declared move assignment operator}}
104#else
105    void operator=(pair&& rhs) { }
106#endif
107  };
108  void f() {
109    pair p0(3);
110#if _MSC_VER >= 1900
111    pair p = p0; // expected-error {{call to implicitly-deleted copy constructor of 'PR11826::pair'}}
112#else
113    pair p = p0;
114#endif
115  }
116}
117
118namespace PR11826_for_symmetry {
119  struct pair {
120    pair(int v) { }
121#if _MSC_VER >= 1900
122    pair(pair&& rhs) { } // expected-note {{copy assignment operator is implicitly deleted because 'pair' has a user-declared move constructor}}
123#else
124    pair(pair&& rhs) { }
125#endif
126  };
127  void f() {
128    pair p0(3);
129    pair p(4);
130#if _MSC_VER >= 1900
131    p = p0; // expected-error {{object of type 'PR11826_for_symmetry::pair' cannot be assigned because its copy assignment operator is implicitly deleted}}
132#else
133    p = p0;
134#endif
135  }
136}
137
138namespace ms_using_declaration_bug {
139
140class A {
141public: 
142  int f(); 
143};
144
145class B : public A {
146private:   
147  using A::f;
148  void g() {
149    f(); // no diagnostic
150  }
151};
152
153class C : public B { 
154private:   
155  using B::f; // expected-warning {{using declaration referring to inaccessible member 'ms_using_declaration_bug::B::f' (which refers to accessible member 'ms_using_declaration_bug::A::f') is a Microsoft compatibility extension}}
156};
157
158}
159
160namespace using_tag_redeclaration
161{
162  struct S;
163  namespace N {
164    using ::using_tag_redeclaration::S;
165    struct S {}; // expected-note {{previous definition is here}}
166  }
167  void f() {
168    N::S s1;
169    S s2;
170  }
171  void g() {
172    struct S; // expected-note {{forward declaration of 'S'}}
173    S s3; // expected-error {{variable has incomplete type 'S'}}
174  }
175  void h() {
176    using ::using_tag_redeclaration::S;
177    struct S {}; // expected-error {{redefinition of 'S'}}
178  }
179}
180
181
182namespace MissingTypename {
183
184template<class T> class A {
185public:
186  typedef int TYPE;
187};
188
189template<class T> class B {
190public:
191  typedef int TYPE;
192};
193
194
195template<class T, class U>
196class C : private A<T>, public B<U> {
197public:
198   typedef A<T> Base1;
199   typedef B<U> Base2;
200   typedef A<U> Base3;
201
202   A<T>::TYPE a1; // expected-warning {{missing 'typename' prior to dependent type name}}
203   Base1::TYPE a2; // expected-warning {{missing 'typename' prior to dependent type name}}
204
205   B<U>::TYPE a3; // expected-warning {{missing 'typename' prior to dependent type name}}
206   Base2::TYPE a4; // expected-warning {{missing 'typename' prior to dependent type name}}
207
208   A<U>::TYPE a5; // expected-error {{missing 'typename' prior to dependent type name}}
209   Base3::TYPE a6; // expected-error {{missing 'typename' prior to dependent type name}}
210 };
211
212class D {
213public:
214    typedef int Type;
215};
216
217template <class T>
218void function_missing_typename(const T::Type param)// expected-warning {{missing 'typename' prior to dependent type name}}
219{
220    const T::Type var = 2; // expected-warning {{missing 'typename' prior to dependent type name}}
221}
222
223template void function_missing_typename<D>(const D::Type param);
224
225}
226
227//MSVC allows forward enum declaration
228enum ENUM; // expected-warning {{forward references to 'enum' types are a Microsoft extension}}
229ENUM *var = 0;     
230ENUM var2 = (ENUM)3;
231enum ENUM1* var3 = 0;// expected-warning {{forward references to 'enum' types are a Microsoft extension}}
232
233enum ENUM1 { kA };
234enum ENUM1;  // This way round is fine.
235
236enum ENUM2 {
237 ENUM2_a = (enum ENUM2) 4,
238 ENUM2_b = 0x9FFFFFFF, // expected-warning {{enumerator value is not representable in the underlying type 'int'}}
239 ENUM2_c = 0x100000000 // expected-warning {{enumerator value is not representable in the underlying type 'int'}}
240};
241
242namespace NsEnumForwardDecl {
243  enum E *p; // expected-warning {{forward references to 'enum' types are a Microsoft extension}}
244  extern E e;
245}
246// Clang used to complain that NsEnumForwardDecl::E was undeclared below.
247NsEnumForwardDecl::E NsEnumForwardDecl_e;
248namespace NsEnumForwardDecl {
249  extern E e;
250}
251
252namespace PR11791 {
253  template<class _Ty>
254  void del(_Ty *_Ptr) {
255    _Ptr->~_Ty();  // expected-warning {{pseudo-destructors on type void are a Microsoft extension}}
256  }
257
258  void f() {
259    int* a = 0;
260    del((void*)a);  // expected-note {{in instantiation of function template specialization}}
261  }
262}
263
264namespace IntToNullPtrConv {
265  struct Foo {
266    static const int ZERO = 0;
267    typedef void (Foo::*MemberFcnPtr)();
268  };
269
270  struct Bar {
271    const Foo::MemberFcnPtr pB;
272  };
273
274  Bar g_bar = { (Foo::MemberFcnPtr)Foo::ZERO };
275
276  template<int N> int *get_n() { return N; }   // expected-warning {{expression which evaluates to zero treated as a null pointer constant}}
277  int *g_nullptr = get_n<0>();  // expected-note {{in instantiation of function template specialization}}
278}
279
280namespace signed_hex_i64 {
281void f(long long);
282void f(int);
283void g() {
284  // This is an ambiguous call in standard C++.
285  // This calls f(long long) in Microsoft mode because LL is always signed.
286  f(0xffffffffffffffffLL);
287  f(0xffffffffffffffffi64);
288}
289}
290
291typedef void (*FnPtrTy)();
292void (*PR23733_1)() = static_cast<FnPtrTy>((void *)0); // expected-warning {{static_cast between pointer-to-function and pointer-to-object is a Microsoft extension}}
293void (*PR23733_2)() = FnPtrTy((void *)0);
294void (*PR23733_3)() = (FnPtrTy)((void *)0);
295void (*PR23733_4)() = reinterpret_cast<FnPtrTy>((void *)0);
296
297long function_prototype(int a);
298long (*function_ptr)(int a);
299
300void function_to_voidptr_conv() {
301  void *a1 = function_prototype;  // expected-warning {{implicit conversion between pointer-to-function and pointer-to-object is a Microsoft extension}}
302  void *a2 = &function_prototype; // expected-warning {{implicit conversion between pointer-to-function and pointer-to-object is a Microsoft extension}}
303  void *a3 = function_ptr;        // expected-warning {{implicit conversion between pointer-to-function and pointer-to-object is a Microsoft extension}}
304}
305
306namespace member_lookup {
307
308template<typename T>
309struct ConfuseLookup {
310  T* m_val;
311  struct m_val {
312    static size_t ms_test;
313  };
314};
315
316// Microsoft mode allows explicit constructor calls
317// This could confuse name lookup in cases such as this
318template<typename T>
319size_t ConfuseLookup<T>::m_val::ms_test
320  = size_t(&(char&)(reinterpret_cast<ConfuseLookup<T>*>(0)->m_val));
321
322void instantiate() { ConfuseLookup<int>::m_val::ms_test = 1; }
323}
324
325
CodeThinker, Enjoy your reading code