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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
|
// RUN: %clang_cc1 %s -fsyntax-only -std=c++23 -verify=expected,new
// RUN: %clang_cc1 %s -fsyntax-only -std=c++23 -fno-relaxed-template-template-args -verify=expected,old
namespace issue1 {
template<class T, class U = T> class B {};
template<template<class> class P, class T> void f(P<T>);
// new-note@-1 {{deduced type 'B<[...], (default) int>' of 1st parameter does not match adjusted type 'B<[...], float>' of argument [with P = B, T = int]}}
// old-note@-2 2{{template template argument has different template parameters}}
void g() {
f(B<int>()); // old-error {{no matching function for call}}
f(B<int,float>()); // expected-error {{no matching function for call}}
}
} // namespace issue1
namespace issue2 {
template<typename> struct match;
template<template<typename> class t,typename T> struct match<t<T>>;
template<template<typename,typename> class t,typename T0,typename T1>
struct match<t<T0,T1>> {};
template<typename,typename = void> struct other {};
template struct match<other<void,void>>;
} // namespace issue2
namespace type {
template<class T1, class T2 = float> struct A;
template<class T3> struct B;
template<template<class T4 > class TT1, class T5 > struct B<TT1<T5 >> ;
template<template<class T6, class T7> class TT2, class T8, class T9> struct B<TT2<T8, T9>> {};
template struct B<A<int>>;
} // namespace type
namespace value {
template<class T1, int V1 = 1> struct A;
template<class T2> struct B;
template<template<class T3 > class TT1, class T4 > struct B<TT1<T4 >> ;
template<template<class T5, int V2> class TT2, class T6, int V3> struct B<TT2<T6, V3>> {};
template struct B<A<int>>;
} // namespace value
namespace templ {
template <class T1> struct A;
template<class T2, template <class T3> class T4 = A> struct B {};
template<class T5> struct C;
template<template<class T6> class TT1, class T7> struct C<TT1<T7>>;
template<template<class T8, template <class T9> class> class TT2,
class T10, template <class T11> class TT3>
struct C<TT2<T10, TT3>> {};
template struct C<B<int>>;
} // namespace templ
namespace class_template {
template <class T1, class T2 = float> struct A;
template <class T3> struct B;
template <template <class T4> class TT1, class T5> struct B<TT1<T5>>;
// new-note@-1 {{partial specialization matches}}
template <class T6, class T7> struct B<A<T6, T7>> {};
// new-note@-1 {{partial specialization matches}}
template struct B<A<int>>;
// new-error@-1 {{ambiguous partial specialization}}
} // namespace class_template
namespace type_pack1 {
template<class T2> struct A;
template<template<class ...T3s> class TT1, class T4> struct A<TT1<T4>> ;
template<template<class T5 > class TT2, class T6> struct A<TT2<T6>> {};
template<class T1> struct B;
template struct A<B<char>>;
} // namespace type_pack1
namespace type_pack2 {
template<class T2> struct A;
template<template<class ...T3s> class TT1, class ...T4> struct A<TT1<T4...>> ;
template<template<class T5 > class TT2, class ...T6> struct A<TT2<T6...>> {};
template<class T1> struct B;
template struct A<B<char>>;
} // namespace type_pack2
namespace type_pack3 {
template<class T1, class T2 = float> struct A;
template<class T3> struct B;
template<template<class T4 > class TT1, class T5 > struct B<TT1<T5 >>;
// new-note@-1 {{template is declared here}}
template<template<class T6, class ...T7s> class TT2, class T8, class ...T9s> struct B<TT2<T8, T9s...>>;
// old-note@-1 {{template is declared here}}
template struct B<A<int>>;
// expected-error@-1 {{explicit instantiation of undefined template}}
} // namespace type_pack3
namespace gcc_issue {
template<class T1, class T2> struct A;
template<template<class T1> class TT1, class T2> struct A<TT1<T2>, typename TT1<T2>::type>;
// new-note@-1 {{partial specialization matches}}
template<template<class T3, class T4> class TT2, class T5, class T6>
struct A<TT2<T5, T6>, typename TT2<T5, T5>::type>;
// new-note@-1 {{partial specialization matches}}
// old-note@-2 {{template is declared here}}
template <class T7, class T8 = T7> struct B { using type = int; };
template struct A<B<int>, int>;
// new-error@-1 {{ambiguous partial specializations}}
// old-error@-2 {{explicit instantiation of undefined template}}
} // namespace gcc_issue
namespace ttp_defaults {
template <template <class T1> class TT1> struct A {};
// old-note@-1 2{{previous template template parameter}}
template <template <class T2> class TT2> void f(A<TT2>);
// new-note@-1 {{explicit instantiation candidate}}
// old-note@-2 {{invalid explicitly-specified argument for template parameter 'TT2'}}
// FIXME: The default arguments on the TTP are not available during partial ordering.
template <template <class T3, class T4 = float> class TT3> void f(A<TT3>) {};
// new-note@-1 {{explicit instantiation candidate}}
// old-error@-2 {{template template argument has different template parameters}}
// old-note@-3 {{too many template parameters}}
template <class T5, class T6 = int> struct B;
// old-note@-1 {{too many template parameters}}
template void f<B>(A<B>);
// new-error@-1 {{partial ordering for explicit instantiation of 'f' is ambiguous}}
// old-error@-2 {{template template argument has different template parameters}}
// old-error@-3 {{explicit instantiation of 'f' does not refer to a function template}}
} // namespace ttp_defaults
namespace ttp_only {
template <template <class... > class TT1> struct A { static constexpr int V = 0; };
template <template <class > class TT2> struct A<TT2> { static constexpr int V = 1; };
// new-note@-1 {{partial specialization matches}}
template <template <class, class> class TT3> struct A<TT3> { static constexpr int V = 2; };
// new-note@-1 {{partial specialization matches}}
template <class ... > struct B;
template <class > struct C;
template <class, class > struct D;
template <class, class, class> struct E;
static_assert(A<B>::V == 0); // new-error {{ambiguous partial specializations}}
static_assert(A<C>::V == 1);
static_assert(A<D>::V == 2);
static_assert(A<E>::V == 0);
} // namespace ttp_only
namespace consistency {
template<class T> struct nondeduced { using type = T; };
template<class T8, class T9 = float> struct B;
namespace t1 {
template<class T1, class T2, class T3> struct A;
template<template<class, class> class TT1,
class T1, class T2, class T3, class T4>
struct A<TT1<T1, T2>, TT1<T3, T4>, typename nondeduced<TT1<T1, T2>>::type> {};
template<template<class> class UU1,
template<class> class UU2,
class U1, class U2>
struct A<UU1<U1>, UU2<U2>, typename nondeduced<UU1<U1>>::type>;
template struct A<B<int>, B<int>, B<int>>;
} // namespace t1
namespace t2 {
template<class T1, class T2, class T3> struct A;
template<template<class, class> class TT1,
class T1, class T2, class T3, class T4>
struct A<TT1<T1, T2>, TT1<T3, T4>, typename nondeduced<TT1<T1, T4>>::type> {};
// new-note@-1 {{partial specialization matches}}
template<template<class> class UU1,
template<class> class UU2,
class U1, class U2>
struct A<UU1<U1>, UU2<U2>, typename nondeduced<UU1<U1>>::type>;
// new-note@-1 {{partial specialization matches}}
template struct A<B<int>, B<int>, B<int>>;
// new-error@-1 {{ambiguous partial specializations}}
} // namespace t2
namespace t3 {
template<class T1, class T2, class T3> struct A;
template<template<class, class> class TT1,
class T1, class T2, class T3, class T4>
struct A<TT1<T1, T2>, TT1<T3, T4>, typename nondeduced<TT1<T1, T2>>::type> {};
// new-note@-1 {{partial specialization matches}}
template<template<class> class UU1,
class U1, class U2>
struct A<UU1<U1>, UU1<U2>, typename nondeduced<UU1<U1>>::type>;
// new-note@-1 {{partial specialization matches}}
template struct A<B<int>, B<int>, B<int>>;
// new-error@-1 {{ambiguous partial specializations}}
} // namespace t3
namespace t4 {
template<class T1, class T2, class T3> struct A;
template<template<class, class> class TT1,
class T1, class T2, class T3, class T4>
struct A<TT1<T1, T2>, TT1<T3, T4>, typename nondeduced<TT1<T1, T4>>::type> {};
// new-note@-1 {{partial specialization matches}}
template<template<class> class UU1,
class U1, class U2>
struct A<UU1<U1>, UU1<U2>, typename nondeduced<UU1<U1>>::type>;
// new-note@-1 {{partial specialization matches}}
template struct A<B<int>, B<int>, B<int>>;
// new-error@-1 {{ambiguous partial specializations}}
} // namespace t4
namespace t5 {
template<class T1, class T2> struct A;
template<template<class, class> class TT1,
class T1, class T2, class T3, class T4>
struct A<TT1<T1, T2>, TT1<T3, T4>> {};
// new-note@-1 {{partial specialization matches}}
template<template<class> class UU1,
class U1, class U2>
struct A<UU1<U1>, UU1<U2>>;
// new-note@-1 {{partial specialization matches}}
template struct A<B<int>, B<int>>;
// new-error@-1 {{ambiguous partial specializations}}
} // namespace t5
namespace t6 {
template<class T1, class T2> struct A;
template<template<class, class> class TT1,
class T1, class T2, class T3>
struct A<TT1<T1, T2>, TT1<T1, T3>> {};
// new-note@-1 {{partial specialization matches}}
template<template<class> class UU1,
class U1, class U2>
struct A<UU1<U1>, UU1<U2>>;
// new-note@-1 {{partial specialization matches}}
template struct A<B<int>, B<int>>;
// new-error@-1 {{ambiguous partial specializations}}
} // namespace t6
} // namespace consistency
namespace classes {
namespace canon {
template<class T, class U> struct A {};
template<template<class> class TT> auto f(TT<int> a) { return a; }
// old-note@-1 2{{template template argument has different template parameters}}
// new-note@-2 2{{substitution failure: too few template arguments}}
A<int, float> v1;
A<int, double> v2;
using X = decltype(f(v1));
// expected-error@-1 {{no matching function for call}}
using X = decltype(f(v2));
// expected-error@-1 {{no matching function for call}}
} // namespace canon
namespace expr {
template <class T1, int E1> struct A {
static constexpr auto val = E1;
};
template <template <class T3> class TT> void f(TT<int> v) {
// old-note@-1 {{template template argument has different template parameters}}
// new-note@-2 {{substitution failure: too few template arguments}}
static_assert(v.val == 3);
};
void test() {
f(A<int, 3>());
// expected-error@-1 {{no matching function for call}}
}
} // namespace expr
namespace packs {
template <class T1, class ...T2s> struct A {
static constexpr auto val = sizeof...(T2s);
};
template <template <class T3> class TT> void f(TT<int> v) {
// old-note@-1 {{template template argument has different template parameters}}
// new-note@-2 {{deduced type 'A<[...], (no argument), (no argument), (no argument)>' of 1st parameter does not match adjusted type 'A<[...], void, void, void>' of argument [with TT = A]}}
static_assert(v.val == 3);
};
void test() {
f(A<int, void, void, void>());
// expected-error@-1 {{no matching function for call}}
}
} // namespace packs
} // namespace classes
namespace regression1 {
template <typename T, typename Y> struct map {};
template <typename T> class foo {};
template <template <typename...> class MapType, typename Value>
Value bar(MapType<int, Value> map);
template <template <typename...> class MapType, typename Value>
Value bar(MapType<int, foo<Value>> map);
void aux() {
map<int, foo<int>> input;
bar(input);
}
} // namespace regression1
|
