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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2a %s
// PR5908
template <typename Iterator>
void Test(Iterator it) {
*(it += 1);
}
namespace PR6045 {
template<unsigned int r>
class A
{
static const unsigned int member = r;
void f();
};
template<unsigned int r>
const unsigned int A<r>::member;
template<unsigned int r>
void A<r>::f()
{
unsigned k;
(void)(k % member);
}
}
namespace PR7198 {
struct A
{
~A() { }
};
template<typename T>
struct B {
struct C : A {};
void f()
{
C c = C();
}
};
}
namespace PR7724 {
template<typename OT> int myMethod()
{ return 2 && sizeof(OT); }
}
namespace test4 {
template <typename T> T *addressof(T &v) {
return reinterpret_cast<T*>(
&const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
}
}
namespace test5 {
template <typename T> class chained_map {
int k;
void lookup() const {
int &v = (int &)k;
}
};
}
namespace test6 {
template<typename T> T f() {
const T &v(0);
return v;
}
int use = f<int>();
}
namespace PR8795 {
template <class _CharT> int test(_CharT t)
{
int data [] = {
sizeof(_CharT) > sizeof(char)
};
return data[0];
}
}
template<typename T> struct CastDependentIntToPointer {
static void* f() {
T *x;
return ((void*)(((unsigned long)(x)|0x1ul)));
}
};
// Regression test for crasher in r194540.
namespace PR10837 {
typedef void t(int);
template<typename> struct A {
void f();
static t g;
};
t *p;
template<typename T> void A<T>::f() {
p = g;
}
template struct A<int>;
}
namespace PR18152 {
template<int N> struct A {
static const int n = {N};
};
template struct A<0>;
}
template<typename T> void stmt_expr_1() {
static_assert( ({ false; }), "" );
}
void stmt_expr_2() {
static_assert( ({ false; }), "" ); // expected-error {{failed}}
}
namespace PR45083 {
struct A { bool x; };
template<typename> struct B : A {
void f() {
const int n = ({ if (x) {} 0; });
}
};
template void B<int>::f();
template<typename> void f() {
decltype(({})) x; // expected-error {{incomplete type}}
}
template void f<int>(); // expected-note {{instantiation of}}
template<typename> auto g() {
auto c = [](auto, int) -> decltype(({})) {};
using T = decltype(c(0.0, 0));
using T = void;
return c(0, 0);
}
using U = decltype(g<int>()); // expected-note {{previous}}
using U = float; // expected-error {{different types ('float' vs 'decltype(g<int>())' (aka 'void'))}}
void h(auto a, decltype(g<char>())*) {} // expected-note {{previous}}
void h(auto a, void*) {} // expected-error {{redefinition}}
void i(auto a) {
[](auto a, int = ({decltype(a) i; i * 2;})){}(a); // expected-error {{invalid operands to binary expression ('decltype(a)' (aka 'void *') and 'int')}} expected-note {{in instantiation of}}
}
void use_i() {
i(0);
i((void*)0); // expected-note {{instantiation of}}
}
}
namespace BindingInStmtExpr {
template<class ...Ts> struct overload : Ts... {
overload(Ts ...ts) : Ts(decltype(ts)(ts))... {}
using Ts::operator()...;
};
template<int> struct N {};
template<class T> auto num_bindings() {
auto f0 = [](auto t, unsigned) { return N<0>(); };
auto f1 = [](auto t, int) -> decltype(({ auto [_1] = t; N<1>(); })) { return {}; };
auto f2 = [](auto t, int) -> decltype(({ auto [_1, _2] = t; N<2>(); })) { return {}; };
auto f3 = [](auto t, int) -> decltype(({ auto [_1, _2, _3] = t; N<3>(); })) { return {}; };
return decltype(overload(f0, f1, f2, f3)(T(), 0))();
}
struct T { int a; int b; };
// Make sure we get a correct, non-dependent type back.
using U = decltype(num_bindings<T>()); // expected-note {{previous}}
using U = N<3>; // expected-error-re {{type alias redefinition with different types ('N<3>' vs {{.*}}N<2>}}
}
|
