MicrosoftExtensions.cpp revision 5dbed6674bda07dd147183932bc843c52205633f
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 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 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 __uuidof(struct_with_uuid[1]); 76 __uuidof(struct_with_uuid*[1]); // expected-error {{cannot call operator __uuidof on a type with no GUID}} 77 __uuidof(const struct_with_uuid[1][1]); 78 __uuidof(const struct_with_uuid*[1][1]); // expected-error {{cannot call operator __uuidof on a type with no GUID}} 79 80 __uuidof(var_with_uuid); 81 __uuidof(var_without_uuid);// expected-error {{cannot call operator __uuidof on a type with no GUID}} 82 __uuidof(var_with_uuid[1]); 83 __uuidof(var_without_uuid[1]);// expected-error {{cannot call operator __uuidof on a type with no GUID}} 84 __uuidof(&var_with_uuid[1]); 85 __uuidof(&var_without_uuid[1]);// expected-error {{cannot call operator __uuidof on a type with no GUID}} 86 87 __uuidof(0); 88 __uuidof(1);// expected-error {{cannot call operator __uuidof on a type with no GUID}} 89} 90 91 92template <class T> 93void template_uuid() 94{ 95 T expr; 96 97 __uuidof(T); 98 __uuidof(expr); 99} 100 101 102template <class T, const GUID* g = &__uuidof(T)> // expected-note {{template parameter is declared here}} 103class COM_CLASS_TEMPLATE { }; 104 105typedef 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}} 106typedef COM_CLASS_TEMPLATE<struct_with_uuid> COM_TYPE_2; 107 108template <class T, const GUID& g> 109class COM_CLASS_TEMPLATE_REF { }; 110typedef COM_CLASS_TEMPLATE_REF<struct_with_uuid, __uuidof(struct_with_uuid)> COM_TYPE_REF; 111 112 struct late_defined_uuid; 113 template<typename T> 114 void test_late_defined_uuid() { 115 __uuidof(late_defined_uuid); 116 } 117 struct __declspec(uuid("000000A0-0000-0000-C000-000000000049")) late_defined_uuid; 118 119COM_CLASS_TEMPLATE_REF<int, __uuidof(struct_with_uuid)> good_template_arg; 120 121COM_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}} 122 123namespace PR16911 { 124struct __declspec(uuid("{12345678-1234-1234-1234-1234567890aB}")) uuid; 125struct __declspec(uuid("{12345678-1234-1234-1234-1234567890aB}")) uuid2; 126 127template <typename T, typename T2> 128struct thing { 129}; 130 131struct empty {}; 132struct inher : public thing<empty, uuid2> {}; 133 134struct __declspec(uuid("{12345678-1234-1234-1234-1234567890aB}")) uuid; 135const struct _GUID *w = &__uuidof(inher); // expected-error{{cannot call operator __uuidof on a type with no GUID}} 136const struct _GUID *x = &__uuidof(thing<uuid, inher>); 137const struct _GUID *y = &__uuidof(thing<uuid2, uuid>); // expected-error{{cannot call operator __uuidof on a type with multiple GUIDs}} 138thing<uuid2, uuid> thing_obj = thing<uuid2, uuid>(); 139const struct _GUID *z = &__uuidof(thing_obj); // expected-error{{cannot call operator __uuidof on a type with multiple GUIDs}} 140} 141 142class CtorCall { 143public: 144 CtorCall& operator=(const CtorCall& that); 145 146 int a; 147}; 148 149CtorCall& CtorCall::operator=(const CtorCall& that) 150{ 151 if (this != &that) { 152 this->CtorCall::~CtorCall(); 153 this->CtorCall::CtorCall(that); // expected-warning {{explicit constructor calls are a Microsoft extension}} 154 } 155 return *this; 156} 157 158template <class A> 159class C1 { 160public: 161 template <int B> 162 class Iterator { 163 }; 164}; 165 166template<class T> 167class C2 { 168 typename C1<T>:: /*template*/ Iterator<0> Mypos; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}} 169}; 170 171template <class T> 172void missing_template_keyword(){ 173 typename C1<T>:: /*template*/ Iterator<0> Mypos; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}} 174} 175 176 177 178class AAAA { 179 typedef int D; 180}; 181 182template <typename T> 183class SimpleTemplate {}; 184 185template <class T> 186void redundant_typename() { 187 typename T t;// expected-warning {{expected a qualified name after 'typename'}} 188 typename AAAA a;// expected-warning {{expected a qualified name after 'typename'}} 189 190 t = 3; 191 192 typedef typename T* pointerT;// expected-warning {{expected a qualified name after 'typename'}} 193 typedef typename SimpleTemplate<int> templateT;// expected-warning {{expected a qualified name after 'typename'}} 194 195 pointerT pT = &t; 196 *pT = 4; 197 198 int var; 199 int k = typename var;// expected-error {{expected a qualified name after 'typename'}} 200} 201 202template <typename T> 203struct TypenameWrongPlace { 204 typename typedef T::D D;// expected-warning {{expected a qualified name after 'typename'}} 205}; 206 207extern TypenameWrongPlace<AAAA> PR16925; 208 209__interface MicrosoftInterface; 210__interface MicrosoftInterface { 211 void foo1() = 0; 212 virtual void foo2() = 0; 213}; 214 215__interface MicrosoftDerivedInterface : public MicrosoftInterface { 216 void foo1(); 217 void foo2() override; 218 void foo3(); 219}; 220 221void interface_test() { 222 MicrosoftInterface* a; 223 a->foo1(); 224 MicrosoftDerivedInterface* b; 225 b->foo2(); 226} 227 228__int64 x7 = __int64(0); 229 230 231namespace If_exists_test { 232 233class IF_EXISTS { 234private: 235 typedef int Type; 236}; 237 238int __if_exists_test() { 239 int b=0; 240 __if_exists(IF_EXISTS::Type) { 241 b++; 242 b++; 243 } 244 __if_exists(IF_EXISTS::Type_not) { 245 this wont compile. 246 } 247 __if_not_exists(IF_EXISTS::Type) { 248 this wont compile. 249 } 250 __if_not_exists(IF_EXISTS::Type_not) { 251 b++; 252 b++; 253 } 254} 255 256 257__if_exists(IF_EXISTS::Type) { 258 int var23; 259} 260 261__if_exists(IF_EXISTS::Type_not) { 262 this wont compile. 263} 264 265__if_not_exists(IF_EXISTS::Type) { 266 this wont compile. 267} 268 269__if_not_exists(IF_EXISTS::Type_not) { 270 int var244; 271} 272 273int __if_exists_init_list() { 274 275 int array1[] = { 276 0, 277 __if_exists(IF_EXISTS::Type) {2, } 278 3 279 }; 280 281 int array2[] = { 282 0, 283 __if_exists(IF_EXISTS::Type_not) { this wont compile } 284 3 285 }; 286 287 int array3[] = { 288 0, 289 __if_not_exists(IF_EXISTS::Type_not) {2, } 290 3 291 }; 292 293 int array4[] = { 294 0, 295 __if_not_exists(IF_EXISTS::Type) { this wont compile } 296 3 297 }; 298 299} 300 301 302class IF_EXISTS_CLASS_TEST { 303 __if_exists(IF_EXISTS::Type) { 304 // __if_exists, __if_not_exists can nest 305 __if_not_exists(IF_EXISTS::Type_not) { 306 int var123; 307 } 308 int var23; 309 } 310 311 __if_exists(IF_EXISTS::Type_not) { 312 this wont compile. 313 } 314 315 __if_not_exists(IF_EXISTS::Type) { 316 this wont compile. 317 } 318 319 __if_not_exists(IF_EXISTS::Type_not) { 320 int var244; 321 } 322}; 323 324} 325 326 327int __identifier(generic) = 3; 328 329class inline_definition_pure_spec { 330 virtual int f() = 0 { return 0; }// expected-warning {{function definition with pure-specifier is a Microsoft extension}} 331 virtual int f2() = 0; 332}; 333 334struct pure_virtual_dtor { 335 virtual ~pure_virtual_dtor() = 0; 336}; 337pure_virtual_dtor::~pure_virtual_dtor() { } 338 339struct pure_virtual_dtor_inline { 340 virtual ~pure_virtual_dtor_inline() = 0 { }// expected-warning {{function definition with pure-specifier is a Microsoft extension}} 341}; 342 343 344int main () { 345 // Necessary to force instantiation in -fdelayed-template-parsing mode. 346 test_late_defined_uuid<int>(); 347 redundant_typename<int>(); 348 missing_template_keyword<int>(); 349} 350 351namespace access_protected_PTM { 352 class A { 353 protected: 354 void f(); // expected-note {{must name member using the type of the current context 'access_protected_PTM::B'}} 355 }; 356 357 class B : public A{ 358 public: 359 void test_access(); 360 static void test_access_static(); 361 }; 362 363 void B::test_access() { 364 &A::f; // expected-error {{'f' is a protected member of 'access_protected_PTM::A'}} 365 } 366 367 void B::test_access_static() { 368 &A::f; 369 } 370} 371 372namespace Inheritance { 373 class __single_inheritance A; 374 class __multiple_inheritance B; 375 class __virtual_inheritance C; 376} 377 378struct StructWithProperty { 379 __declspec(property) int V0; // expected-error {{expected '(' after 'property'}} 380 __declspec(property()) int V1; // expected-error {{property does not specify a getter or a putter}} 381 __declspec(property(set)) int V2; // expected-error {{putter for property must be specified as 'put', not 'set'}} expected-error {{expected '=' after 'set'}} 382 __declspec(property(ptu)) int V3; // expected-error {{missing 'get=' or 'put='}} 383 __declspec(property(ptu=PutV)) int V4; // expected-error {{expected 'get' or 'put' in property declaration}} 384 __declspec(property(get)) int V5; // expected-error {{expected '=' after 'get'}} 385 __declspec(property(get&)) int V6; // expected-error {{expected '=' after 'get'}} 386 __declspec(property(get=)) int V7; // expected-error {{expected name of accessor method}} 387 __declspec(property(get=GetV)) int V8; // no-warning 388 __declspec(property(get=GetV=)) int V9; // expected-error {{expected ',' or ')' at end of property accessor list}} 389 __declspec(property(get=GetV,)) int V10; // expected-error {{expected 'get' or 'put' in property declaration}} 390 __declspec(property(get=GetV,put=SetV)) int V11; // no-warning 391 __declspec(property(get=GetV,put=SetV,get=GetV)) int V12; // expected-error {{property declaration specifies 'get' accessor twice}} 392 393 int GetV() { return 123; } 394 void SetV(int v) {} 395}; 396void TestProperty() { 397 StructWithProperty sp; 398 sp.V8; 399 sp.V8 = 0; // expected-error {{no setter defined for property 'V8'}} 400 int i = sp.V11; 401 sp.V11 = i++; 402 sp.V11 += 8; 403 sp.V11++; 404 ++sp.V11; 405} 406