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    void operator=(pair&& rhs) { }
103  };
104  void f() {
105    pair p0(3);
106    pair p = p0;
107  }
108}
109
110namespace PR11826_for_symmetry {
111  struct pair {
112    pair(int v) { }
113    pair(pair&& rhs) { }
114  };
115  void f() {
116    pair p0(3);
117    pair p(4);
118    p = p0;
119  }
120}
121
122namespace ms_using_declaration_bug {
123
124class A {
125public:
126  int f();
127};
128
129class B : public A {
130private:
131  using A::f;
132  void g() {
133    f(); // no diagnostic
134  }
135};
136
137class C : public B {
138private:
139  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}}
140};
141
142}
143
144namespace using_tag_redeclaration
145{
146  struct S;
147  namespace N {
148    using ::using_tag_redeclaration::S;
149    struct S {}; // expected-note {{previous definition is here}}
150  }
151  void f() {
152    N::S s1;
153    S s2;
154  }
155  void g() {
156    struct S; // expected-note {{forward declaration of 'S'}}
157    S s3; // expected-error {{variable has incomplete type 'S'}}
158  }
159  void h() {
160    using ::using_tag_redeclaration::S;
161    struct S {}; // expected-error {{redefinition of 'S'}}
162  }
163}
164
165
166namespace MissingTypename {
167
168template<class T> class A {
169public:
170	 typedef int TYPE;
171};
172
173template<class T> class B {
174public:
175	 typedef int TYPE;
176};
177
178
179template<class T, class U>
180class C : private A<T>, public B<U> {
181public:
182   typedef A<T> Base1;
183   typedef B<U> Base2;
184   typedef A<U> Base3;
185
186   A<T>::TYPE a1; // expected-warning {{missing 'typename' prior to dependent type name}}
187   Base1::TYPE a2; // expected-warning {{missing 'typename' prior to dependent type name}}
188
189   B<U>::TYPE a3; // expected-warning {{missing 'typename' prior to dependent type name}}
190   Base2::TYPE a4; // expected-warning {{missing 'typename' prior to dependent type name}}
191
192   A<U>::TYPE a5; // expected-error {{missing 'typename' prior to dependent type name}}
193   Base3::TYPE a6; // expected-error {{missing 'typename' prior to dependent type name}}
194 };
195
196class D {
197public:
198    typedef int Type;
199};
200
201template <class T>
202void function_missing_typename(const T::Type param)// expected-warning {{missing 'typename' prior to dependent type name}}
203{
204    const T::Type var = 2; // expected-warning {{missing 'typename' prior to dependent type name}}
205}
206
207template void function_missing_typename<D>(const D::Type param);
208
209}
210
211enum ENUM2 {
212	ENUM2_a = (enum ENUM2) 4,
213	ENUM2_b = 0x9FFFFFFF, // expected-warning {{enumerator value is not representable in the underlying type 'int'}}
214	ENUM2_c = 0x100000000 // expected-warning {{enumerator value is not representable in the underlying type 'int'}}
215};
216
217
218namespace PR11791 {
219  template<class _Ty>
220  void del(_Ty *_Ptr) {
221    _Ptr->~_Ty();  // expected-warning {{pseudo-destructors on type void are a Microsoft extension}}
222  }
223
224  void f() {
225    int* a = 0;
226    del((void*)a);  // expected-note {{in instantiation of function template specialization}}
227  }
228}
229
230namespace IntToNullPtrConv {
231  struct Foo {
232    static const int ZERO = 0;
233    typedef void (Foo::*MemberFcnPtr)();
234  };
235
236  struct Bar {
237    const Foo::MemberFcnPtr pB;
238  };
239
240  Bar g_bar = { (Foo::MemberFcnPtr)Foo::ZERO };
241
242  template<int N> int *get_n() { return N; }   // expected-warning {{expression which evaluates to zero treated as a null pointer constant}}
243  int *g_nullptr = get_n<0>();  // expected-note {{in instantiation of function template specialization}}
244}
245