1 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -Wmicrosoft -verify -fms-compatibility -fexceptions -fcxx-exceptions 2 3 4 typedef unsigned short char16_t; 5 typedef unsigned int char32_t; 6 7 typename decltype(3) a; // expected-warning {{expected a qualified name after 'typename'}} 8 9 namespace ms_conversion_rules { 10 11 void f(float a); 12 void f(int a); 13 14 void test() 15 { 16 long a = 0; 17 f((long)0); 18 f(a); 19 } 20 21 } 22 23 24 namespace ms_predefined_types { 25 // ::type_info is a built-in forward class declaration. 26 void f(const type_info &a); 27 void f(size_t); 28 } 29 30 31 namespace ms_protected_scope { 32 struct C { C(); }; 33 34 int jump_over_variable_init(bool b) { 35 if (b) 36 goto foo; // expected-warning {{goto into protected scope}} 37 C c; // expected-note {{jump bypasses variable initialization}} 38 foo: 39 return 1; 40 } 41 42 struct Y { 43 ~Y(); 44 }; 45 46 void jump_over_var_with_dtor() { 47 goto end; // expected-warning{{goto into protected scope}} 48 Y y; // expected-note {{jump bypasses variable with a non-trivial destructor}} 49 end: 50 ; 51 } 52 53 void jump_over_variable_case(int c) { 54 switch (c) { 55 case 0: 56 int x = 56; // expected-note {{jump bypasses variable initialization}} 57 case 1: // expected-error {{switch case is in protected scope}} 58 x = 10; 59 } 60 } 61 62 63 void exception_jump() { 64 goto l2; // expected-error {{goto into protected scope}} 65 try { // expected-note {{jump bypasses initialization of try block}} 66 l2: ; 67 } catch(int) { 68 } 69 } 70 71 int jump_over_indirect_goto() { 72 static void *ps[] = { &&a0 }; 73 goto *&&a0; // expected-warning {{goto into protected scope}} 74 int a = 3; // expected-note {{jump bypasses variable initialization}} 75 a0: 76 return 0; 77 } 78 79 } 80 81 namespace PR11826 { 82 struct pair { 83 pair(int v) { } 84 void operator=(pair&& rhs) { } 85 }; 86 void f() { 87 pair p0(3); 88 pair p = p0; 89 } 90 } 91 92 namespace PR11826_for_symmetry { 93 struct pair { 94 pair(int v) { } 95 pair(pair&& rhs) { } 96 }; 97 void f() { 98 pair p0(3); 99 pair p(4); 100 p = p0; 101 } 102 } 103 104 namespace ms_using_declaration_bug { 105 106 class A { 107 public: 108 int f(); 109 }; 110 111 class B : public A { 112 private: 113 using A::f; 114 void g() { 115 f(); // no diagnostic 116 } 117 }; 118 119 class C : public B { 120 private: 121 using B::f; // expected-warning {{using declaration referring to inaccessible member 'ms_using_declaration_bug::B::f' (which refers to accessible member 'ms_using_declaration_bug::A::f') is a Microsoft compatibility extension}} 122 }; 123 124 } 125 126 namespace using_tag_redeclaration 127 { 128 struct S; 129 namespace N { 130 using ::using_tag_redeclaration::S; 131 struct S {}; // expected-note {{previous definition is here}} 132 } 133 void f() { 134 N::S s1; 135 S s2; 136 } 137 void g() { 138 struct S; // expected-note {{forward declaration of 'S'}} 139 S s3; // expected-error {{variable has incomplete type 'S'}} 140 } 141 void h() { 142 using ::using_tag_redeclaration::S; 143 struct S {}; // expected-error {{redefinition of 'S'}} 144 } 145 } 146 147 148 namespace MissingTypename { 149 150 template<class T> class A { 151 public: 152 typedef int TYPE; 153 }; 154 155 template<class T> class B { 156 public: 157 typedef int TYPE; 158 }; 159 160 161 template<class T, class U> 162 class C : private A<T>, public B<U> { 163 public: 164 typedef A<T> Base1; 165 typedef B<U> Base2; 166 typedef A<U> Base3; 167 168 A<T>::TYPE a1; // expected-warning {{missing 'typename' prior to dependent type name}} 169 Base1::TYPE a2; // expected-warning {{missing 'typename' prior to dependent type name}} 170 171 B<U>::TYPE a3; // expected-warning {{missing 'typename' prior to dependent type name}} 172 Base2::TYPE a4; // expected-warning {{missing 'typename' prior to dependent type name}} 173 174 A<U>::TYPE a5; // expected-error {{missing 'typename' prior to dependent type name}} 175 Base3::TYPE a6; // expected-error {{missing 'typename' prior to dependent type name}} 176 }; 177 178 class D { 179 public: 180 typedef int Type; 181 }; 182 183 template <class T> 184 void function_missing_typename(const T::Type param)// expected-warning {{missing 'typename' prior to dependent type name}} 185 { 186 const T::Type var = 2; // expected-warning {{missing 'typename' prior to dependent type name}} 187 } 188 189 template void function_missing_typename<D>(const D::Type param); 190 191 } 192 193 enum ENUM2 { 194 ENUM2_a = (enum ENUM2) 4, 195 ENUM2_b = 0x9FFFFFFF, // expected-warning {{enumerator value is not representable in the underlying type 'int'}} 196 ENUM2_c = 0x100000000 // expected-warning {{enumerator value is not representable in the underlying type 'int'}} 197 }; 198 199 200 namespace PR11791 { 201 template<class _Ty> 202 void del(_Ty *_Ptr) { 203 _Ptr->~_Ty(); // expected-warning {{pseudo-destructors on type void are a Microsoft extension}} 204 } 205 206 void f() { 207 int* a = 0; 208 del((void*)a); // expected-note {{in instantiation of function template specialization}} 209 } 210 } 211 212 namespace IntToNullPtrConv { 213 struct Foo { 214 static const int ZERO = 0; 215 typedef void (Foo::*MemberFcnPtr)(); 216 }; 217 218 struct Bar { 219 const Foo::MemberFcnPtr pB; 220 }; 221 222 Bar g_bar = { (Foo::MemberFcnPtr)Foo::ZERO }; 223 224 template<int N> int *get_n() { return N; } // expected-warning {{expression which evaluates to zero treated as a null pointer constant}} 225 int *g_nullptr = get_n<0>(); // expected-note {{in instantiation of function template specialization}} 226 } 227