1 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -verify -fms-compatibility -fexceptions -fcxx-exceptions
2 
3 
4 
5 namespace ms_conversion_rules {
6 
7 void f(float a);
8 void f(int a);
9 
10 void test()
11 {
12     long a = 0;
13     f((long)0);
14 	f(a);
15 }
16 
17 }
18 
19 
20 
21 namespace ms_protected_scope {
22   struct C { C(); };
23 
24   int jump_over_variable_init(bool b) {
25     if (b)
26       goto foo; // expected-warning {{illegal goto into protected scope}}
27     C c; // expected-note {{jump bypasses variable initialization}}
28   foo:
29     return 1;
30   }
31 
32 struct Y {
33   ~Y();
34 };
35 
36 void jump_over_var_with_dtor() {
37   goto end; // expected-warning{{goto into protected scope}}
38   Y y; // expected-note {{jump bypasses variable with a non-trivial destructor}}
39  end:
40     ;
41 }
42 
43   void jump_over_variable_case(int c) {
44     switch (c) {
45     case 0:
46       int x = 56; // expected-note {{jump bypasses variable initialization}}
47     case 1:       // expected-error {{switch case is in protected scope}}
48       x = 10;
49     }
50   }
51 
52 
53 void exception_jump() {
54   goto l2; // expected-error {{illegal goto into protected scope}}
55   try { // expected-note {{jump bypasses initialization of try block}}
56      l2: ;
57   } catch(int) {
58   }
59 }
60 
61 int jump_over_indirect_goto() {
62   static void *ps[] = { &&a0 };
63   goto *&&a0; // expected-warning {{goto into protected scope}}
64   int a = 3; // expected-note {{jump bypasses variable initialization}}
65  a0:
66   return 0;
67 }
68 
69 }
70 
71 
72 
73 namespace ms_using_declaration_bug {
74 
75 class A {
76 public:
77   int f();
78 };
79 
80 class B : public A {
81 private:
82   using A::f;
83 };
84 
85 class C : public B {
86 private:
87   using B::f; // expected-warning {{using declaration refers to inaccessible member 'ms_using_declaration_bug::B::f', which refers to accessible member 'ms_using_declaration_bug::A::f', accepted for Microsoft compatibility}}
88 };
89 
90 }
91 
92 
93 namespace MissingTypename {
94 
95 template<class T> class A {
96 public:
97 	 typedef int TYPE;
98 };
99 
100 template<class T> class B {
101 public:
102 	 typedef int TYPE;
103 };
104 
105 
106 template<class T, class U>
107 class C : private A<T>, public B<U> {
108 public:
109    typedef A<T> Base1;
110    typedef B<U> Base2;
111    typedef A<U> Base3;
112 
113    A<T>::TYPE a1; // expected-warning {{missing 'typename' prior to dependent type name}}
114    Base1::TYPE a2; // expected-warning {{missing 'typename' prior to dependent type name}}
115 
116    B<U>::TYPE a3; // expected-warning {{missing 'typename' prior to dependent type name}}
117    Base2::TYPE a4; // expected-warning {{missing 'typename' prior to dependent type name}}
118 
119    A<U>::TYPE a5; // expected-error {{missing 'typename' prior to dependent type name}}
120    Base3::TYPE a6; // expected-error {{missing 'typename' prior to dependent type name}}
121  };
122 
123 class D {
124 public:
125     typedef int Type;
126 };
127 
128 template <class T>
129 void function_missing_typename(const T::Type param)// expected-warning {{missing 'typename' prior to dependent type name}}
130 {
131     const T::Type var = 2; // expected-warning {{missing 'typename' prior to dependent type name}}
132 }
133 
134 template void function_missing_typename<D>(const D::Type param);
135 
136 }
137 
138 
139 
140