MicrosoftExtensions.cpp revision 6c20222da814df4cb1ef97681f0e1e8cb5a01b40
1// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -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 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_REF<struct_with_uuid, __uuidof(struct_with_uuid)> COM_TYPE_REF; 107 108 struct late_defined_uuid; 109 template<typename T> 110 void test_late_defined_uuid() { 111 __uuidof(late_defined_uuid); 112 } 113 struct __declspec(uuid("000000A0-0000-0000-C000-000000000049")) late_defined_uuid; 114 115 116class CtorCall { 117public: 118 CtorCall& operator=(const CtorCall& that); 119 120 int a; 121}; 122 123CtorCall& CtorCall::operator=(const CtorCall& that) 124{ 125 if (this != &that) { 126 this->CtorCall::~CtorCall(); 127 this->CtorCall::CtorCall(that); // expected-warning {{explicit constructor calls are a Microsoft extension}} 128 } 129 return *this; 130} 131 132template <class A> 133class C1 { 134public: 135 template <int B> 136 class Iterator { 137 }; 138}; 139 140template<class T> 141class C2 { 142 typename C1<T>:: /*template*/ Iterator<0> Mypos; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}} 143}; 144 145template <class T> 146void missing_template_keyword(){ 147 typename C1<T>:: /*template*/ Iterator<0> Mypos; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}} 148} 149 150 151 152class AAAA { }; 153 154template <typename T> 155class SimpleTemplate {}; 156 157template <class T> 158void redundant_typename() { 159 typename T t;// expected-warning {{expected a qualified name after 'typename'}} 160 typename AAAA a;// expected-warning {{expected a qualified name after 'typename'}} 161 162 t = 3; 163 164 typedef typename T* pointerT;// expected-warning {{expected a qualified name after 'typename'}} 165 typedef typename SimpleTemplate<int> templateT;// expected-warning {{expected a qualified name after 'typename'}} 166 167 pointerT pT = &t; 168 *pT = 4; 169 170 int var; 171 int k = typename var;// expected-error {{expected a qualified name after 'typename'}} 172} 173 174 175__interface MicrosoftInterface; 176__interface MicrosoftInterface { 177 virtual void foo1() = 0; 178 virtual void foo2() = 0; 179}; 180 181void interface_test() { 182 MicrosoftInterface* a; 183 a->foo1(); 184} 185 186__int64 x7 = __int64(0); 187 188 189namespace If_exists_test { 190 191class IF_EXISTS { 192private: 193 typedef int Type; 194}; 195 196int __if_exists_test() { 197 int b=0; 198 __if_exists(IF_EXISTS::Type) { 199 b++; 200 b++; 201 } 202 __if_exists(IF_EXISTS::Type_not) { 203 this wont compile. 204 } 205 __if_not_exists(IF_EXISTS::Type) { 206 this wont compile. 207 } 208 __if_not_exists(IF_EXISTS::Type_not) { 209 b++; 210 b++; 211 } 212} 213 214 215__if_exists(IF_EXISTS::Type) { 216 int var23; 217} 218 219__if_exists(IF_EXISTS::Type_not) { 220 this wont compile. 221} 222 223__if_not_exists(IF_EXISTS::Type) { 224 this wont compile. 225} 226 227__if_not_exists(IF_EXISTS::Type_not) { 228 int var244; 229} 230 231int __if_exists_init_list() { 232 233 int array1[] = { 234 0, 235 __if_exists(IF_EXISTS::Type) {2, } 236 3 237 }; 238 239 int array2[] = { 240 0, 241 __if_exists(IF_EXISTS::Type_not) { this wont compile } 242 3 243 }; 244 245 int array3[] = { 246 0, 247 __if_not_exists(IF_EXISTS::Type_not) {2, } 248 3 249 }; 250 251 int array4[] = { 252 0, 253 __if_not_exists(IF_EXISTS::Type) { this wont compile } 254 3 255 }; 256 257} 258 259 260class IF_EXISTS_CLASS_TEST { 261 __if_exists(IF_EXISTS::Type) { 262 // __if_exists, __if_not_exists can nest 263 __if_not_exists(IF_EXISTS::Type_not) { 264 int var123; 265 } 266 int var23; 267 } 268 269 __if_exists(IF_EXISTS::Type_not) { 270 this wont compile. 271 } 272 273 __if_not_exists(IF_EXISTS::Type) { 274 this wont compile. 275 } 276 277 __if_not_exists(IF_EXISTS::Type_not) { 278 int var244; 279 } 280}; 281 282} 283 284 285int __identifier(generic) = 3; 286 287class inline_definition_pure_spec { 288 virtual int f() = 0 { return 0; }// expected-warning {{function definition with pure-specifier is a Microsoft extension}} 289 virtual int f2() = 0; 290}; 291 292 293int main () { 294 // Necessary to force instantiation in -fdelayed-template-parsing mode. 295 test_late_defined_uuid<int>(); 296 redundant_typename<int>(); 297 missing_template_keyword<int>(); 298} 299 300namespace access_protected_PTM { 301 class A { 302 protected: 303 void f(); // expected-note {{must name member using the type of the current context 'access_protected_PTM::B'}} 304 }; 305 306 class B : public A{ 307 public: 308 void test_access(); 309 static void test_access_static(); 310 }; 311 312 void B::test_access() { 313 &A::f; // expected-error {{'f' is a protected member of 'access_protected_PTM::A'}} 314 } 315 316 void B::test_access_static() { 317 &A::f; 318 } 319} 320