Clang Project

clang_source_code/test/Parser/MicrosoftExtensions.cpp
1// RUN: %clang_cc1 %s -triple i386-pc-win32 -std=c++14 -fsyntax-only -Wno-unused-getter-return-value -Wno-unused-value -Wmicrosoft -verify -fms-extensions -fms-compatibility -fdelayed-template-parsing
2
3/* Microsoft attribute tests */
4[repeatable][source_annotation_attribute( Parameter|ReturnValue )]
5struct SA_Post{ SA_Post(); int attr; };
6
7[returnvalue:SA_Post( attr=1)]
8int foo1([SA_Post(attr=1)] void *param);
9
10namespace {
11  [returnvalue:SA_Post(attr=1)]
12  int foo2([SA_Post(attr=1)] void *param);
13}
14
15class T {
16  [returnvalue:SA_Post(attr=1)]
17  int foo3([SA_Post(attr=1)] void *param);
18};
19
20extern "C" {
21  [returnvalue:SA_Post(attr=1)]
22  int foo5([SA_Post(attr=1)] void *param);
23}
24
25class class_attr {
26public:
27  class_attr([SA_Pre(Null=SA_No,NullTerminated=SA_Yes)]  int a)
28  {
29  }
30};
31
32
33
34void uuidof_test1()
35{
36  __uuidof(0);  // expected-error {{you need to include <guiddef.h> before using the '__uuidof' operator}}
37}
38
39typedef struct _GUID
40{
41    unsigned long  Data1;
42    unsigned short Data2;
43    unsigned short Data3;
44    unsigned char  Data4[8];
45} GUID;
46
47struct __declspec(uuid(L"00000000-0000-0000-1234-000000000047")) uuid_attr_bad1 { };// expected-error {{'uuid' attribute requires a string}}
48struct __declspec(uuid(3)) uuid_attr_bad2 { };// expected-error {{'uuid' attribute requires a string}}
49struct __declspec(uuid("0000000-0000-0000-1234-0000500000047")) uuid_attr_bad3 { };// expected-error {{uuid attribute contains a malformed GUID}}
50struct __declspec(uuid("0000000-0000-0000-Z234-000000000047")) uuid_attr_bad4 { };// expected-error {{uuid attribute contains a malformed GUID}}
51struct __declspec(uuid("000000000000-0000-1234-000000000047")) uuid_attr_bad5 { };// expected-error {{uuid attribute contains a malformed GUID}}
52[uuid("000000000000-0000-1234-000000000047")] struct uuid_attr_bad6 { };// expected-error {{uuid attribute contains a malformed GUID}}
53
54__declspec(uuid("000000A0-0000-0000-C000-000000000046")) int i; // expected-warning {{'uuid' attribute only applies to structs, unions, classes, and enums}}
55
56struct __declspec(uuid("000000A0-0000-0000-C000-000000000046"))
57struct_with_uuid { };
58struct struct_without_uuid { };
59
60struct __declspec(uuid("000000A0-0000-0000-C000-000000000049"))
61struct_with_uuid2;
62
63[uuid("000000A0-0000-0000-C000-000000000049")] struct struct_with_uuid3; // expected-warning{{specifying 'uuid' as an ATL attribute is deprecated; use __declspec instead}}
64
65struct
66struct_with_uuid2 {} ;
67
68enum __declspec(uuid("000000A0-0000-0000-C000-000000000046"))
69enum_with_uuid { };
70enum enum_without_uuid { };
71
72int __declspec(uuid("000000A0-0000-0000-C000-000000000046")) inappropriate_uuid; // expected-warning {{'uuid' attribute only applies to}}
73
74int uuid_sema_test()
75{
76   struct_with_uuid var_with_uuid[1];
77   struct_without_uuid var_without_uuid[1];
78
79   __uuidof(struct_with_uuid);
80   __uuidof(struct_with_uuid2);
81   __uuidof(struct_with_uuid3);
82   __uuidof(struct_without_uuid); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
83   __uuidof(struct_with_uuid*);
84   __uuidof(struct_without_uuid*); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
85   __uuidof(struct_with_uuid[1]);
86   __uuidof(struct_with_uuid*[1]); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
87   __uuidof(const struct_with_uuid[1][1]);
88   __uuidof(const struct_with_uuid*[1][1]); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
89
90   __uuidof(enum_with_uuid);
91   __uuidof(enum_without_uuid); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
92   __uuidof(enum_with_uuid*);
93   __uuidof(enum_without_uuid*); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
94   __uuidof(enum_with_uuid[1]);
95   __uuidof(enum_with_uuid*[1]); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
96   __uuidof(const enum_with_uuid[1][1]);
97   __uuidof(const enum_with_uuid*[1][1]); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
98
99   __uuidof(var_with_uuid);
100   __uuidof(var_without_uuid);// expected-error {{cannot call operator __uuidof on a type with no GUID}}
101   __uuidof(var_with_uuid[1]);
102   __uuidof(var_without_uuid[1]);// expected-error {{cannot call operator __uuidof on a type with no GUID}}
103   __uuidof(&var_with_uuid[1]);
104   __uuidof(&var_without_uuid[1]);// expected-error {{cannot call operator __uuidof on a type with no GUID}}
105
106   __uuidof(0);
107   __uuidof(1);// expected-error {{cannot call operator __uuidof on a type with no GUID}}
108}
109
110
111template <class T>
112void template_uuid()
113{
114   T expr;
115
116   __uuidof(T);
117   __uuidof(expr);
118}
119
120
121template <class T, const GUID* g = &__uuidof(T)> // expected-note {{template parameter is declared here}}
122class COM_CLASS_TEMPLATE  { };
123
124typedef COM_CLASS_TEMPLATE<struct_with_uuid, &*&__uuidof(struct_with_uuid)> COM_TYPE_1; // expected-warning {{non-type template argument containing a dereference operation is a Microsoft extension}}
125typedef COM_CLASS_TEMPLATE<struct_with_uuid> COM_TYPE_2;
126
127template <class T, const GUID& g>
128class COM_CLASS_TEMPLATE_REF  { };
129typedef COM_CLASS_TEMPLATE_REF<struct_with_uuid, __uuidof(struct_with_uuid)> COM_TYPE_REF;
130
131  struct late_defined_uuid;
132  template<typename T>
133  void test_late_defined_uuid() {
134    __uuidof(late_defined_uuid);
135  }
136  struct __declspec(uuid("000000A0-0000-0000-C000-000000000049")) late_defined_uuid;
137
138COM_CLASS_TEMPLATE_REF<int, __uuidof(struct_with_uuid)> good_template_arg;
139
140COM_CLASS_TEMPLATE<int, __uuidof(struct_with_uuid)> bad_template_arg; // expected-error {{non-type template argument of type 'const _GUID' is not a constant expression}}
141
142namespace PR16911 {
143struct __declspec(uuid("{12345678-1234-1234-1234-1234567890aB}")) uuid;
144struct __declspec(uuid("{12345678-1234-1234-1234-1234567890aB}")) uuid2;
145
146template <typename T, typename T2>
147struct thing {
148};
149
150struct empty {};
151struct inher : public thing<empty, uuid2> {};
152
153struct __declspec(uuid("{12345678-1234-1234-1234-1234567890aB}")) uuid;
154const struct _GUID *w = &__uuidof(inher); // expected-error{{cannot call operator __uuidof on a type with no GUID}}
155const struct _GUID *x = &__uuidof(thing<uuid, inher>);
156const struct _GUID *y = &__uuidof(thing<uuid2, uuid>); // expected-error{{cannot call operator __uuidof on a type with multiple GUIDs}}
157thing<uuid2, uuid> thing_obj = thing<uuid2, uuid>();
158const struct _GUID *z = &__uuidof(thing_obj); // expected-error{{cannot call operator __uuidof on a type with multiple GUIDs}}
159}
160
161class CtorCall {
162public:
163  CtorCall& operator=(const CtorCall& that);
164
165  int a;
166};
167
168CtorCall& CtorCall::operator=(const CtorCall& that)
169{
170    if (this != &that) {
171        this->CtorCall::~CtorCall();
172        this->CtorCall::CtorCall(that); // expected-warning {{explicit constructor calls are a Microsoft extension}}
173    }
174    return *this;
175}
176
177template <class A>
178class C1 {
179public:
180  template <int B>
181  class Iterator {
182  };
183};
184
185template<class T>
186class C2  {
187  typename C1<T>:: /*template*/  Iterator<0> Mypos; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
188};
189
190template <class T>
191void missing_template_keyword(){
192  typename C1<T>:: /*template*/ Iterator<0> Mypos; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
193}
194
195
196
197class AAAA {
198   typedef int D;
199};
200
201template <typename T>
202class SimpleTemplate {};
203
204template <class T>
205void redundant_typename() {
206   typename T t;// expected-warning {{expected a qualified name after 'typename'}}
207   typename AAAA a;// expected-warning {{expected a qualified name after 'typename'}}
208
209   t = 3;
210
211   typedef typename T* pointerT;// expected-warning {{expected a qualified name after 'typename'}}
212   typedef typename SimpleTemplate<int> templateT;// expected-warning {{expected a qualified name after 'typename'}}
213
214   pointerT pT = &t;
215   *pT = 4;
216
217   int var;
218   int k = typename var;// expected-error {{expected a qualified name after 'typename'}}
219}
220
221template <typename T>
222struct TypenameWrongPlace {
223  typename typedef T::D D;// expected-warning {{expected a qualified name after 'typename'}}
224};
225
226extern TypenameWrongPlace<AAAA> PR16925;
227
228__interface MicrosoftInterface;
229__interface MicrosoftInterface {
230   void foo1() = 0; // expected-note {{overridden virtual function is here}}
231   virtual void foo2() = 0;
232};
233
234__interface MicrosoftDerivedInterface : public MicrosoftInterface {
235  void foo1(); // expected-warning {{'foo1' overrides a member function but is not marked 'override'}}
236  void foo2() override;
237  void foo3();
238};
239
240void interface_test() {
241  MicrosoftInterface* a;
242  a->foo1();
243  MicrosoftDerivedInterface* b;
244  b->foo2();
245}
246
247__int64 x7 = __int64(0);
248_int64 x8 = _int64(0);
249static_assert(sizeof(_int64) == 8, "");
250static_assert(sizeof(_int32) == 4, "");
251static_assert(sizeof(_int16) == 2, "");
252static_assert(sizeof(_int8) == 1, "");
253
254int __identifier(generic) = 3;
255int __identifier(int) = 4;
256struct __identifier(class) { __identifier(class) *__identifier(for); };
257__identifier(class) __identifier(struct) = { &__identifier(struct) };
258
259int __identifier for; // expected-error {{missing '(' after '__identifier'}}
260int __identifier(else} = __identifier(for); // expected-error {{missing ')' after identifier}} expected-note {{to match this '('}}
261#define identifier_weird(x) __identifier(x
262int k = identifier_weird(if)); // expected-error {{use of undeclared identifier 'if'}}
263
264extern int __identifier(and);
265
266void f() {
267  __identifier(() // expected-error {{cannot convert '(' token to an identifier}}
268  __identifier(void) // expected-error {{use of undeclared identifier 'void'}}
269  __identifier()) // expected-error {{cannot convert ')' token to an identifier}}
270  // FIXME: We should pick a friendlier display name for this token kind.
271  __identifier(1) // expected-error {{cannot convert <numeric_constant> token to an identifier}}
272  __identifier(+) // expected-error {{cannot convert '+' token to an identifier}}
273  __identifier("foo") // expected-error {{cannot convert <string_literal> token to an identifier}}
274  __identifier(;) // expected-error {{cannot convert ';' token to an identifier}}
275}
276
277class inline_definition_pure_spec {
278   virtual int f() = 0 { return 0; }// expected-warning {{function definition with pure-specifier is a Microsoft extension}}
279   virtual int f2() = 0;
280};
281
282struct pure_virtual_dtor {
283  virtual ~pure_virtual_dtor() = 0;
284};
285pure_virtual_dtor::~pure_virtual_dtor() { }
286
287struct pure_virtual_dtor_inline {
288  virtual ~pure_virtual_dtor_inline() = 0 { }// expected-warning {{function definition with pure-specifier is a Microsoft extension}}
289};
290
291
292int main () {
293  // Necessary to force instantiation in -fdelayed-template-parsing mode.
294  test_late_defined_uuid<int>();
295  redundant_typename<int>();
296  missing_template_keyword<int>();
297}
298
299namespace access_protected_PTM {
300  class A {
301  protected:
302    void f(); // expected-note {{must name member using the type of the current context 'access_protected_PTM::B'}}
303  };
304
305  class B : public A{
306  public:
307    void test_access();
308    static void test_access_static();
309  };
310
311  void B::test_access() {
312    &A::f; // expected-error {{'f' is a protected member of 'access_protected_PTM::A'}}
313  }
314
315  void B::test_access_static() {
316    &A::f;
317  }
318}
319
320namespace Inheritance {
321  class __single_inheritance A;
322  class __multiple_inheritance B;
323  class __virtual_inheritance C;
324}
325
326struct StructWithProperty {
327  __declspec(property) int V0; // expected-error {{expected '(' after 'property'}}
328  __declspec(property()) int V1; // expected-error {{property does not specify a getter or a putter}}
329  __declspec(property(set)) int V2; // expected-error {{putter for property must be specified as 'put', not 'set'}} expected-error {{expected '=' after 'set'}}
330  __declspec(property(ptu)) int V3; // expected-error {{missing 'get=' or 'put='}}
331  __declspec(property(ptu=PutV)) int V4; // expected-error {{expected 'get' or 'put' in property declaration}}
332  __declspec(property(get)) int V5; // expected-error {{expected '=' after 'get'}}
333  __declspec(property(get&)) int V6; // expected-error {{expected '=' after 'get'}}
334  __declspec(property(get=)) int V7; // expected-error {{expected name of accessor method}}
335  __declspec(property(get=GetV)) int V8; // no-warning
336  __declspec(property(get=GetV=)) int V9; // expected-error {{expected ',' or ')' at end of property accessor list}}
337  __declspec(property(get=GetV,)) int V10; // expected-error {{expected 'get' or 'put' in property declaration}}
338  __declspec(property(get=GetV,put=SetV)) int V11; // no-warning
339  __declspec(property(get=GetV,put=SetV,get=GetV)) int V12; // expected-error {{property declaration specifies 'get' accessor twice}}
340  __declspec(property(get=GetV)) int V13 = 3; // expected-error {{property declaration cannot have an in-class initializer}}
341
342  int GetV() { return 123; }
343  void SetV(int v) {}
344};
345void TestProperty() {
346  StructWithProperty sp;
347  sp.V8;
348  sp.V8 = 0; // expected-error {{no setter defined for property 'V8'}}
349  int i = sp.V11;
350  sp.V11 = i++;
351  sp.V11 += 8;
352  sp.V11++;
353  ++sp.V11;
354}
355
356//expected-warning@+1 {{C++ operator 'and' (aka '&&') used as a macro name}}
357#define and foo
358
359struct __declspec(uuid("00000000-0000-0000-C000-000000000046")) __declspec(novtable) IUnknown {};
360
361typedef bool (__stdcall __stdcall *blarg)(int);
362
363void local_callconv() {
364  bool (__stdcall *p)(int);
365}
366
367struct S7 {
368 int foo() { return 12; }
369 __declspec(property(get=foo) deprecated) int t; // expected-note {{'t' has been explicitly marked deprecated here}}
370};
371
372// Technically, this is legal (though it does nothing)
373__declspec() void quux( void ) {
374  struct S7 s;
375  int i = s.t; // expected-warning {{'t' is deprecated}}
376}
377
378void *_alloca(int);
379
380void foo(void) {
381  __declspec(align(16)) int *buffer = (int *)_alloca(9);
382}
383
384template <int *>
385struct NullptrArg {};
386NullptrArg<nullptr> a;
387
388// Ignored type qualifiers after comma in declarator lists
389typedef int ignored_quals_dummy1, const volatile __ptr32 __ptr64 __w64 __unaligned __sptr __uptr ignored_quals1; // expected-warning {{qualifiers after comma in declarator list are ignored}}
390typedef void(*ignored_quals_dummy2)(), __fastcall ignored_quals2; // expected-warning {{qualifiers after comma in declarator list are ignored}}
391typedef void(*ignored_quals_dummy3)(), __stdcall ignored_quals3; // expected-warning {{qualifiers after comma in declarator list are ignored}}
392typedef void(*ignored_quals_dummy4)(), __thiscall ignored_quals4; // expected-warning {{qualifiers after comma in declarator list are ignored}}
393typedef void(*ignored_quals_dummy5)(), __cdecl ignored_quals5; // expected-warning {{qualifiers after comma in declarator list are ignored}}
394typedef void(*ignored_quals_dummy6)(), __vectorcall ignored_quals6; // expected-warning {{qualifiers after comma in declarator list are ignored}}
395
396namespace {
397bool f(int);
398template <typename T>
399struct A {
400  constexpr A(T t) {
401    __assume(f(t)); // expected-warning{{the argument to '__assume' has side effects that will be discarded}}
402  }
403  constexpr bool g() { return false; }
404};
405constexpr A<int> h() {
406  A<int> b(0); // expected-note {{in instantiation of member function}}
407  return b;
408}
409static_assert(h().g() == false, "");
410}
411
412namespace {
413__declspec(align(16)) struct align_before_key1 {};
414__declspec(align(16)) struct align_before_key2 {} align_before_key2_var;
415__declspec(align(16)) struct align_before_key3 {} *align_before_key3_var;
416static_assert(__alignof(struct align_before_key1) == 16, "");
417static_assert(__alignof(struct align_before_key2) == 16, "");
418static_assert(__alignof(struct align_before_key3) == 16, "");
419}
420
421namespace PR24027 {
422struct S {
423  template <typename T>
424  S(T);
425} f([] {});
426}
427
428namespace pr36638 {
429// Make sure we accept __unaligned method qualifiers on member function
430// pointers.
431struct A;
432void (A::*mp1)(int) __unaligned;
433}
434
CodeThinker, Enjoy your reading code