test/SemaCXX/MicrosoftExtensions.cpp

   1 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -verify -fms-extensions -fexceptions -fcxx-exceptions
   2
   3
   4 // ::type_info is predeclared with forward class declartion
   5 void f(const type_info &a);
   6
   7
   8 // Microsoft doesn't validate exception specification.
   9 namespace microsoft_exception_spec {
  10
  11 void foo(); // expected-note {{previous declaration}}
  12 void foo() throw(); // expected-warning {{exception specification in declaration does not match previous declaration}}
  13
  14 void r6() throw(...); // expected-note {{previous declaration}}
  15 void r6() throw(int); // expected-warning {{exception specification in declaration does not match previous declaration}}
  16
  17 struct Base {
  18   virtual void f2();
  19   virtual void f3() throw(...);
  20 };
  21
  22 struct Derived : Base {
  23   virtual void f2() throw(...);
  24   virtual void f3();
  25 };
  26
  27 class A {
  28   virtual ~A() throw();  // expected-note {{overridden virtual function is here}}
  29 };
  30
  31 class B : public A {
  32   virtual ~B();  // expected-warning {{exception specification of overriding function is more lax than base version}}
  33 };
  34
  35 }
  36
  37 // MSVC allows type definition in anonymous union and struct
  38 struct A
  39 {
  40   union
  41   {
  42     int a;
  43     struct B  // expected-warning {{types declared in an anonymous union are a Microsoft extension}}
  44     {
  45       int c;
  46     } d;
  47
  48     union C   // expected-warning {{types declared in an anonymous union are a Microsoft extension}}
  49     {
  50       int e;
  51       int ee;
  52     } f;
  53
  54     typedef int D;  // expected-warning {{types declared in an anonymous union are a Microsoft extension}}
  55     struct F;  // expected-warning {{types declared in an anonymous union are a Microsoft extension}}
  56   };
  57
  58   struct
  59   {
  60     int a2;
  61
  62     struct B2  // expected-warning {{types declared in an anonymous struct are a Microsoft extension}}
  63     {
  64       int c2;
  65     } d2;
  66
  67         union C2  // expected-warning {{types declared in an anonymous struct are a Microsoft extension}}
  68     {
  69       int e2;
  70       int ee2;
  71     } f2;
  72
  73     typedef int D2;  // expected-warning {{types declared in an anonymous struct are a Microsoft extension}}
  74     struct F2;  // expected-warning {{types declared in an anonymous struct are a Microsoft extension}}
  75   };
  76 };
  77
  78 // __stdcall handling
  79 struct M {
  80     int __stdcall addP();
  81     float __stdcall subtractP();
  82 };
  83
  84 // __unaligned handling
  85 typedef char __unaligned *aligned_type;
  86
  87
  88 template<typename T> void h1(T (__stdcall M::* const )()) { }
  89
  90 void m1() {
  91   h1<int>(&M::addP);
  92   h1(&M::subtractP);
  93 }
  94
  95
  96
  97
  98
  99 void f(long long);
 100 void f(int);
 101
 102 int main()
 103 {
 104   // This is an ambiguous call in standard C++.
 105   // This calls f(long long) in Microsoft mode because LL is always signed.
 106   f(0xffffffffffffffffLL);
 107   f(0xffffffffffffffffi64);
 108 }
 109
 110 // Enumeration types with a fixed underlying type.
 111 const int seventeen = 17;
 112 typedef int Int;
 113
 114 struct X0 {
 115   enum E1 : Int { SomeOtherValue } field; // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}
 116   enum E1 : seventeen;
 117 };
 118
 119 enum : long long {  // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}
 120   SomeValue = 0x100000000
 121 };
 122
 123
 124 class AAA {
 125 __declspec(dllimport) void f(void) { }
 126 void f2(void);
 127 };
 128
 129 __declspec(dllimport) void AAA::f2(void) { // expected-error {{dllimport attribute can be applied only to symbol}}
 130
 131 }
 132
 133
 134
 135 template <class T>
 136 class BB {
 137 public:
 138    void f(int g = 10 ); // expected-note {{previous definition is here}}
 139 };
 140
 141 template <class T>
 142 void BB<T>::f(int g = 0) { } // expected-warning {{redefinition of default argument}}
 143
 144
 145
 146 extern void static_func();
 147 void static_func(); // expected-note {{previous declaration is here}}
 148
 149
 150 static void static_func() // expected-warning {{static declaration of 'static_func' follows non-static declaration}}
 151 {
 152
 153 }
 154
 155 long function_prototype(int a);
 156 long (*function_ptr)(int a);
 157
 158 void function_to_voidptr_conv() {
 159    void *a1 = function_prototype;
 160    void *a2 = &function_prototype;
 161    void *a3 = function_ptr;
 162 }
 163
 164
 165 void pointer_to_integral_type_conv(char* ptr) {
 166    char ch = (char)ptr;
 167    short sh = (short)ptr;
 168    ch = (char)ptr;
 169    sh = (short)ptr;
 170 }
 171
 172
 173 namespace friend_as_a_forward_decl {
 174
 175 class A {
 176   class Nested {
 177     friend class B;
 178     B* b;
 179   };
 180   B* b;
 181 };
 182 B* global_b;
 183
 184
 185 void f()
 186 {
 187   class Local {
 188     friend class Z;
 189     Z* b;
 190   };
 191   Z* b;
 192 }
 193
 194 }
 195
 196 struct PR11150 {
 197   class X {
 198     virtual void f() = 0;
 199   };
 200
 201   int array[__is_abstract(X)? 1 : -1];
 202 };
 203
 204 void f() { int __except = 0; }
 205