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