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 5void f(const type_info &a); 6 7 8// Microsoft doesn't validate exception specification. 9namespace microsoft_exception_spec { 10 11void foo(); // expected-note {{previous declaration}} 12void foo() throw(); // expected-warning {{exception specification in declaration does not match previous declaration}} 13 14void r6() throw(...); // expected-note {{previous declaration}} 15void r6() throw(int); // expected-warning {{exception specification in declaration does not match previous declaration}} 16 17struct Base { 18 virtual void f2(); 19 virtual void f3() throw(...); 20}; 21 22struct Derived : Base { 23 virtual void f2() throw(...); 24 virtual void f3(); 25}; 26 27class A { 28 virtual ~A() throw(); // expected-note {{overridden virtual function is here}} 29}; 30 31class 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 38struct 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 79struct M { 80 int __stdcall addP(); 81 float __stdcall subtractP(); 82}; 83 84// __unaligned handling 85typedef char __unaligned *aligned_type; 86 87 88template<typename T> void h1(T (__stdcall M::* const )()) { } 89 90void m1() { 91 h1<int>(&M::addP); 92 h1(&M::subtractP); 93} 94 95 96 97 98 99void f(long long); 100void f(int); 101 102int 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. 111const int seventeen = 17; 112typedef int Int; 113 114struct 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 119enum : long long { // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}} 120 SomeValue = 0x100000000 121}; 122 123 124class AAA { 125__declspec(dllimport) void f(void) { } 126void 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 135template <class T> 136class BB { 137public: 138 void f(int g = 10 ); // expected-note {{previous definition is here}} 139}; 140 141template <class T> 142void BB<T>::f(int g = 0) { } // expected-warning {{redefinition of default argument}} 143 144 145 146extern void static_func(); 147void static_func(); // expected-note {{previous declaration is here}} 148 149 150static void static_func() // expected-warning {{static declaration of 'static_func' follows non-static declaration}} 151{ 152 153} 154 155long function_prototype(int a); 156long (*function_ptr)(int a); 157 158void function_to_voidptr_conv() { 159 void *a1 = function_prototype; 160 void *a2 = &function_prototype; 161 void *a3 = function_ptr; 162} 163 164 165void 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 173namespace friend_as_a_forward_decl { 174 175class A { 176 class Nested { 177 friend class B; 178 B* b; 179 }; 180 B* b; 181}; 182B* global_b; 183 184 185void f() 186{ 187 class Local { 188 friend class Z; 189 Z* b; 190 }; 191 Z* b; 192} 193 194} 195 196struct PR11150 { 197 class X { 198 virtual void f() = 0; 199 }; 200 201 int array[__is_abstract(X)? 1 : -1]; 202}; 203 204void f() { int __except = 0; } 205 206