test/Parser/MicrosoftExtensions.cpp

   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 )]
   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);  // expected-error {{you need to include <guiddef.h> before using the '__uuidof' operator}}
  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 parameter 1 to be a string}}
  48 struct __declspec(uuid(3)) uuid_attr_bad2 { };// expected-error {{'uuid' attribute requires parameter 1 to be 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
  53
  54
  55 struct __declspec(uuid("000000A0-0000-0000-C000-000000000046"))
  56 struct_with_uuid { };
  57 struct struct_without_uuid { };
  58
  59 struct __declspec(uuid("000000A0-0000-0000-C000-000000000049"))
  60 struct_with_uuid2;
  61
  62 struct
  63 struct_with_uuid2 {} ;
  64
  65 int 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
  88 template <class T>
  89 void template_uuid()
  90 {
  91    T expr;
  92
  93    __uuidof(T);
  94    __uuidof(expr);
  95 }
  96
  97
  98 template <class T, const GUID* g = &__uuidof(T)>
  99 class COM_CLASS_TEMPLATE  { };
 100
 101 typedef COM_CLASS_TEMPLATE<struct_with_uuid, &__uuidof(struct_with_uuid)> COM_TYPE_1;
 102 typedef COM_CLASS_TEMPLATE<struct_with_uuid> COM_TYPE_2;
 103
 104 template <class T, const GUID& g>
 105 class COM_CLASS_TEMPLATE_REF  { };
 106 typedef COM_CLASS_TEMPLATE<struct_with_uuid, __uuidof(struct_with_uuid)> COM_TYPE_REF;
 107
 108
 109 class CtorCall {
 110 public:
 111   CtorCall& operator=(const CtorCall& that);
 112
 113   int a;
 114 };
 115
 116 CtorCall& 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
 125 template <class A>
 126 class C1 {
 127 public:
 128   template <int B>
 129   class Iterator {
 130   };
 131 };
 132
 133 template<class T>
 134 class C2  {
 135   typename C1<T>:: /*template*/  Iterator<0> Mypos; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
 136 };
 137
 138 template <class T>
 139 void 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
 145 class AAAA { };
 146
 147 template <class T>
 148 void 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
 154 int 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);