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 h1(T (__stdcall M::* const)())88template<typename T> void h1(T (__stdcall M::* const )()) { } 89 m1()90void 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 main()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. 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 { f(void)125__declspec(dllimport) void f(void) { } 126 void f2(void); 127 }; 128 f2(void)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> f(int g=0)142void 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 static_func()150static 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 function_to_voidptr_conv()158void function_to_voidptr_conv() { 159 void *a1 = function_prototype; 160 void *a2 = &function_prototype; 161 void *a3 = function_ptr; 162 } 163 164 pointer_to_integral_type_conv(char * ptr)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 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 f()185void 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 f()204void f() { int __except = 0; } 205 206