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