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
|
// RUN: %clang_cc1 -verify %s -std=c++17 -Wno-unused
template<typename ...Ts> void PackInsideTypedefDeclaration() {
([] {
typedef Ts Type;
(void)Type();
}(), ...);
}
template void PackInsideTypedefDeclaration<>();
template void PackInsideTypedefDeclaration<int>();
template void PackInsideTypedefDeclaration<int, float>();
template<typename ...Ts> void PackInsideTypedefDeclarationInvalid() {
[] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
typedef Ts Type;
(void)Type();
};
([] {
typedef Ts Type;
// A reference to a typedef containing an unexpanded pack does not
// itself contain an unexpanded pack.
f(Type()...); // expected-error {{does not contain any unexpanded}}
}, ...);
}
template<typename ...Ts> void PackInsideAliasDeclaration() {
([] {
using Type = Ts;
(void)Type();
}(), ...);
}
template void PackInsideAliasDeclaration<>();
template void PackInsideAliasDeclaration<int>();
template void PackInsideAliasDeclaration<int, float>();
template<typename ...Ts> void PackInsideAliasDeclarationInvalid() {
[] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
using Type = Ts;
(void)Type();
};
([] {
using Type = Ts;
// A reference to an alias containing an unexpanded pack does not
// itself contain an unexpanded pack.
f(Type()...); // expected-error {{does not contain any unexpanded}}
}, ...);
}
template<typename ...Ts> void PackInsideUsingDeclaration() {
([] {
struct A {
using Type = Ts;
};
struct B : A {
using typename A::Type;
};
(void)typename B::Type();
}(), ...);
}
template void PackInsideUsingDeclaration<>();
template void PackInsideUsingDeclaration<int>();
template void PackInsideUsingDeclaration<int, float>();
template<typename ...Ts> void PackInsideUsingDeclarationInvalid() {
([] {
struct A {
using Type = Ts;
};
struct B : A {
using typename A::Type...; // expected-error {{does not contain any unexpanded}}
};
}(), ...);
}
template<typename ...Ts> void PackInsideVarDeclaration() {
([] {
Ts ts;
(void)ts;
}, ...);
}
template void PackInsideVarDeclaration<>();
template void PackInsideVarDeclaration<int>();
template void PackInsideVarDeclaration<int, float>();
template<typename ...Ts> void PackInsideVarDeclarationInvalid() {
[] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
Ts ts;
(void)ts;
};
}
template<typename ...Ts> void PackInsideFunctionDeclaration() {
([] {
Ts ts(Ts);
ts({});
}, ...);
}
template void PackInsideFunctionDeclaration<>();
template void PackInsideFunctionDeclaration<int>();
template void PackInsideFunctionDeclaration<int, float>();
template<typename ...Ts> void PackInsideFunctionDeclarationInvalid() {
[] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
Ts ts(Ts);
ts({});
};
}
template<typename ...Ts> void PackInsideLocalClass() {
([] {
class Local {
Ts ts;
};
Local l;
}, ...);
}
template void PackInsideLocalClass<>();
template void PackInsideLocalClass<int>();
template void PackInsideLocalClass<int, float>();
template<typename ...Ts> void PackInsideLocalClassInvalid() {
[] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
class Local {
Ts ts;
};
Local l;
};
}
template<typename T> using Int = int;
struct AClass {};
template<typename T> using Class = AClass;
template<typename ...Ts> void HiddenPack() {
(Int<Ts>(), ...);
(Int<Ts>{}, ...);
(Class<Ts>(), ...);
(Class<Ts>{}, ...);
([] {
Int<Ts>();
}, ...);
([] {
Int<Ts>{};
}, ...);
([] {
Class<Ts>();
}, ...);
([] {
Class<Ts>{};
}, ...);
}
template void HiddenPack<>();
template void HiddenPack<int>();
template void HiddenPack<int, float>();
template<typename ...Ts> void HiddenPackInvalid() {
Int<Ts>(); // expected-error {{unexpanded}}
Int<Ts>{}; // expected-error {{unexpanded}}
Class<Ts>(); // expected-error {{unexpanded}}
Class<Ts>{}; // expected-error {{unexpanded}}
}
|
