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
|
// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
#if __cplusplus >= 201103L
namespace dr2211 { // dr2211: 8
void f() {
int a;
auto f = [a](int a) { (void)a; }; // expected-error {{a lambda parameter cannot shadow an explicitly captured entity}}
// expected-note@-1{{variable 'a' is explicitly captured here}}
auto g = [=](int a) { (void)a; };
}
}
#endif
namespace dr2213 { // dr2213: yes
template <typename T, typename U>
struct A;
template <typename U>
struct A<int, U>;
} // namespace dr2213
namespace dr2229 { // dr2229: 7
struct AnonBitfieldQualifiers {
const unsigned : 1; // expected-error {{anonymous bit-field cannot have qualifiers}}
volatile unsigned : 1; // expected-error {{anonymous bit-field cannot have qualifiers}}
const volatile unsigned : 1; // expected-error {{anonymous bit-field cannot have qualifiers}}
unsigned : 1;
const unsigned i1 : 1;
volatile unsigned i2 : 1;
const volatile unsigned i3 : 1;
};
}
namespace dr2233 { // dr2233: 11
#if __cplusplus >= 201103L
template <typename... T>
void f(int i = 0, T... args) {}
template <typename... T>
void g(int i = 0, T... args, T... args2) {}
template <typename... T>
void h(int i = 0, T... args, int j = 1) {}
template <typename... T, typename... U>
void i(int i = 0, T... args, int j = 1, U... args2) {}
template <class... Ts>
void j(int i = 0, Ts... ts) {}
template <>
void j<int>(int i, int j) {}
template
void j(int, int, int);
extern template
void j(int, int, int, int);
// PR23029
// Ensure instantiating the templates works.
void use() {
f();
f(0, 1);
f<int>(1, 2);
g<int>(1, 2, 3);
h(0, 1);
i();
i(3);
i<int>(3, 2);
i<int>(3, 2, 1);
i<int, int>(1, 2, 3, 4, 5);
j();
j(1);
j(1, 2);
j<int>(1, 2);
}
namespace MultilevelSpecialization {
template<typename ...T> struct A {
template <T... V> void f(int i = 0, int (&... arr)[V]);
};
template<> template<>
void A<int, int>::f<1, 1>(int i, int (&arr1a)[1], int (&arr2a)[1]) {}
// FIXME: I believe this example is valid, at least up to the first explicit
// specialization, but Clang can't cope with explicit specializations that
// expand packs into a sequence of parameters. If we ever start accepting
// that, we'll need to decide whether it's OK for arr1a to be missing its
// default argument -- how far back do we look when determining whether a
// parameter was expanded from a pack?
// -- zygoloid 2020-06-02
template<typename ...T> struct B {
template <T... V> void f(int i = 0, int (&... arr)[V]);
};
template<> template<int a, int b>
void B<int, int>::f(int i, int (&arr1)[a], int (&arr2)[b]) {} // expected-error {{does not match}}
template<> template<>
void B<int, int>::f<1, 1>(int i, int (&arr1a)[1], int (&arr2a)[1]) {}
}
namespace CheckAfterMerging1 {
template <typename... T> void f() {
void g(int, int = 0);
void g(int = 0, T...);
g();
}
void h() { f<int>(); }
}
namespace CheckAfterMerging2 {
template <typename... T> void f() {
void g(int = 0, T...);
void g(int, int = 0);
g();
}
void h() { f<int>(); }
}
#endif
} // namespace dr2233
namespace dr2292 { // dr2292: 9
#if __cplusplus >= 201103L
template<typename T> using id = T;
void test(int *p) {
p->template id<int>::~id<int>();
}
#endif
}
|
