MicrosoftExtensions.cpp revision f986038beed360c031de8654cfba43a5d3184605 
1// RUN: %clang_cc1 %s -fsyntax-only -Wno-unused-value -Wmicrosoft -verify -fms-extensions
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 parameter 1 to be a string}}
48struct __declspec(uuid(3)) uuid_attr_bad2 { };// expected-error {{'uuid' attribute requires parameter 1 to be 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
53
54
55struct __declspec(uuid("000000A0-0000-0000-C000-000000000046"))
56struct_with_uuid { };
57struct struct_without_uuid { };
58
59struct __declspec(uuid("000000A0-0000-0000-C000-000000000049"))
60struct_with_uuid2;
61
62struct
63struct_with_uuid2 {} ;
64
65int uuid_sema_test()
66{
67   struct_with_uuid var_with_uuid[1];
68   struct_without_uuid var_without_uuid[1];
69
70   __uuidof(struct_with_uuid);
71   __uuidof(struct_with_uuid2);
72   __uuidof(struct_without_uuid); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
73   __uuidof(struct_with_uuid*);
74   __uuidof(struct_without_uuid*); // expected-error {{cannot call operator __uuidof on a type with no GUID}}
75
76   __uuidof(var_with_uuid);
77   __uuidof(var_without_uuid);// expected-error {{cannot call operator __uuidof on a type with no GUID}}
78   __uuidof(var_with_uuid[1]);
79   __uuidof(var_without_uuid[1]);// expected-error {{cannot call operator __uuidof on a type with no GUID}}
80   __uuidof(&var_with_uuid[1]);
81   __uuidof(&var_without_uuid[1]);// expected-error {{cannot call operator __uuidof on a type with no GUID}}
82
83   __uuidof(0);
84   __uuidof(1);// expected-error {{cannot call operator __uuidof on a type with no GUID}}
85}
86
87
88template <class T>
89void template_uuid()
90{
91   T expr;
92
93   __uuidof(T);
94   __uuidof(expr);
95}
96
97
98template <class T, const GUID* g = &__uuidof(T)>
99class COM_CLASS_TEMPLATE  { };
100
101typedef COM_CLASS_TEMPLATE<struct_with_uuid, &__uuidof(struct_with_uuid)> COM_TYPE_1;
102typedef COM_CLASS_TEMPLATE<struct_with_uuid> COM_TYPE_2;
103
104template <class T, const GUID& g>
105class COM_CLASS_TEMPLATE_REF  { };
106typedef COM_CLASS_TEMPLATE<struct_with_uuid, __uuidof(struct_with_uuid)> COM_TYPE_REF;
107
108
109class CtorCall {
110public:
111  CtorCall& operator=(const CtorCall& that);
112
113  int a;
114};
115
116CtorCall& CtorCall::operator=(const CtorCall& that)
117{
118    if (this != &that) {
119        this->CtorCall::~CtorCall();
120        this->CtorCall::CtorCall(that); // expected-warning {{explicit constructor calls are a Microsoft extension}}
121    }
122    return *this;
123}
124
125template <class A>
126class C1 {
127public:
128  template <int B>
129  class Iterator {
130  };
131};
132
133template<class T>
134class C2  {
135  typename C1<T>:: /*template*/  Iterator<0> Mypos; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
136};
137
138template <class T>
139void f(){
140  typename C1<T>:: /*template*/ Iterator<0> Mypos; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
141}
142
143
144
145class AAAA { };
146
147template <class T>
148void redundant_typename() {
149   typename T t;// expected-warning {{expected a qualified name after 'typename'}}
150   typename AAAA a;// expected-warning {{expected a qualified name after 'typename'}}
151   t = 3;
152}
153
154int main() {
155  redundant_typename<int>();
156  f<int>();
157}
158
159
160__interface MicrosoftInterface;
161__interface MicrosoftInterface {
162   virtual void foo1() = 0;
163   virtual void foo2() = 0;
164};
165
166__int64 x7 = __int64(0);
167
168
169
170
171class IF_EXISTS {
172private:
173    typedef int Type;
174};
175
176int __if_exists_test() {
177  int b=0;
178  __if_exists(IF_EXISTS::Type) {
179     b++;
180     b++;
181  }
182  __if_exists(IF_EXISTS::Type_not) {
183     this wont compile.
184  }
185  __if_not_exists(IF_EXISTS::Type) {
186     this wont compile.
187  }
188  __if_not_exists(IF_EXISTS::Type_not) {
189     b++;
190     b++;
191  }
192}
193
194
195__if_exists(IF_EXISTS::Type) {
196  int var23;
197}
198
199__if_exists(IF_EXISTS::Type_not) {
200 this wont compile.
201}
202
203__if_not_exists(IF_EXISTS::Type) {
204 this wont compile.
205}
206
207__if_not_exists(IF_EXISTS::Type_not) {
208  int var244;
209}
210