pt.c source code [gcc/cp/pt.c] - Woboq Code Browser

1	/ Handle parameterized types (templates) for GNU -- C++ --.*
2	Copyright (C) 1992-2017 Free Software Foundation, Inc.
3	Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4	Rewritten by Jason Merrill (jason@cygnus.com).
5
6	This file is part of GCC.
7
8	GCC is free software; you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation; either version 3, or (at your option)
11	any later version.
12
13	GCC is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with GCC; see the file COPYING3. If not see
20	<http://www.gnu.org/licenses/>. /*
21
22	/ Known bugs or deficiencies include:*
23
24	all methods must be provided in header files; can't use a source
25	file that contains only the method templates and "just win". /*
26
27	#include "config.h"
28	#include "system.h"
29	#include "coretypes.h"
30	#include "cp-tree.h"
31	#include "timevar.h"
32	#include "stringpool.h"
33	#include "varasm.h"
34	#include "attribs.h"
35	#include "stor-layout.h"
36	#include "intl.h"
37	#include "c-family/c-objc.h"
38	#include "cp-objcp-common.h"
39	#include "toplev.h"
40	#include "tree-iterator.h"
41	#include "type-utils.h"
42	#include "gimplify.h"
43	#include "gcc-rich-location.h"
44
45	/ The type of functions taking a tree, and some additional data, and*
46	returning an int. /*
47	typedef int (tree_fn_t) (tree, void**);
48
49	/ The PENDING_TEMPLATES is a TREE_LIST of templates whose*
50	instantiations have been deferred, either because their definitions
51	were not yet available, or because we were putting off doing the work. /*
52	struct GTY ((chain_next ("%h.next"))) pending_template {
53	struct pending_template *next;
54	struct tinst_level *tinst;
55	};
56
57	static GTY(()) struct pending_template *pending_templates;
58	static GTY(()) struct pending_template *last_pending_template;
59
60	int processing_template_parmlist;
61	static int template_header_count;
62
63	static GTY(()) tree saved_trees;
64	static vec<int> inline_parm_levels;
65
66	static GTY(()) struct tinst_level *current_tinst_level;
67
68	static GTY(()) tree saved_access_scope;
69
70	/ Live only within one (recursive) call to tsubst_expr. We use*
71	this to pass the statement expression node from the STMT_EXPR
72	to the EXPR_STMT that is its result. /*
73	static tree cur_stmt_expr;
74
75	// -------------------------------------------------------------------------- //
76	// Local Specialization Stack
77	//
78	// Implementation of the RAII helper for creating new local
79	// specializations.
80	local_specialization_stack::local_specialization_stack (lss_policy policy)
81	: saved (local_specializations)
82	{
83	if (policy == lss_blank \|\| !saved)
84	local_specializations = new hash_map<tree, tree>;
85	else
86	local_specializations = new hash_map<tree, tree>(*saved);
87	}
88
89	local_specialization_stack::~local_specialization_stack ()
90	{
91	delete local_specializations;
92	local_specializations = saved;
93	}
94
95	/ True if we've recursed into fn_type_unification too many times. /
96	static bool excessive_deduction_depth;
97
98	struct GTY((for_user)) spec_entry
99	{
100	tree tmpl;
101	tree args;
102	tree spec;
103	};
104
105	struct spec_hasher : ggc_ptr_hash<spec_entry>
106	{
107	static hashval_t hash (spec_entry *);
108	static bool equal (spec_entry , spec_entry );
109	};
110
111	static GTY (()) hash_table<spec_hasher> *decl_specializations;
112
113	static GTY (()) hash_table<spec_hasher> *type_specializations;
114
115	/ Contains canonical template parameter types. The vector is indexed by*
116	the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
117	TREE_LIST, whose TREE_VALUEs contain the canonical template
118	parameters of various types and levels. /*
119	static GTY(()) vec<tree, va_gc> *canonical_template_parms;
120
121	#define UNIFY_ALLOW_NONE 0
122	#define UNIFY_ALLOW_MORE_CV_QUAL 1
123	#define UNIFY_ALLOW_LESS_CV_QUAL 2
124	#define UNIFY_ALLOW_DERIVED 4
125	#define UNIFY_ALLOW_INTEGER 8
126	#define UNIFY_ALLOW_OUTER_LEVEL 16
127	#define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
128	#define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
129
130	enum template_base_result {
131	tbr_incomplete_type,
132	tbr_ambiguous_baseclass,
133	tbr_success
134	};
135
136	static void push_access_scope (tree);
137	static void pop_access_scope (tree);
138	static bool resolve_overloaded_unification (tree, tree, tree, tree,
139	unification_kind_t, int,
140	bool);
141	static int try_one_overload (tree, tree, tree, tree, tree,
142	unification_kind_t, int, bool, bool);
143	static int unify (tree, tree, tree, tree, int, bool);
144	static void add_pending_template (tree);
145	static tree reopen_tinst_level (struct tinst_level *);
146	static tree tsubst_initializer_list (tree, tree);
147	static tree get_partial_spec_bindings (tree, tree, tree);
148	static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
149	bool, bool);
150	static tree coerce_innermost_template_parms (tree, tree, tree, tsubst_flags_t,
151	bool, bool);
152	static void tsubst_enum (tree, tree, tree);
153	static tree add_to_template_args (tree, tree);
154	static tree add_outermost_template_args (tree, tree);
155	static bool check_instantiated_args (tree, tree, tsubst_flags_t);
156	static int maybe_adjust_types_for_deduction (unification_kind_t, tree, tree,
157	tree);
158	static int type_unification_real (tree, tree, tree, const tree *,
159	unsigned int, int, unification_kind_t, int,
160	vec<deferred_access_check, va_gc> **,
161	bool);
162	static void note_template_header (int);
163	static tree convert_nontype_argument_function (tree, tree, tsubst_flags_t);
164	static tree convert_nontype_argument (tree, tree, tsubst_flags_t);
165	static tree convert_template_argument (tree, tree, tree,
166	tsubst_flags_t, int, tree);
167	static tree for_each_template_parm (tree, tree_fn_t, void*,
168	hash_set<tree> , bool*, tree_fn_t = NULL);
169	static tree expand_template_argument_pack (tree);
170	static tree build_template_parm_index (int, int, int, tree, tree);
171	static bool inline_needs_template_parms (tree, bool);
172	static void push_inline_template_parms_recursive (tree, int);
173	static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
174	static int mark_template_parm (tree, void *);
175	static int template_parm_this_level_p (tree, void *);
176	static tree tsubst_friend_function (tree, tree);
177	static tree tsubst_friend_class (tree, tree);
178	static int can_complete_type_without_circularity (tree);
179	static tree get_bindings (tree, tree, tree, bool);
180	static int template_decl_level (tree);
181	static int check_cv_quals_for_unify (int, tree, tree);
182	static void template_parm_level_and_index (tree, int, int**);
183	static int unify_pack_expansion (tree, tree, tree,
184	tree, unification_kind_t, bool, bool);
185	static tree copy_template_args (tree);
186	static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
187	static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
188	static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
189	static tree most_specialized_partial_spec (tree, tsubst_flags_t);
190	static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
191	static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree);
192	static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
193	static bool check_specialization_scope (void);
194	static tree process_partial_specialization (tree);
195	static void set_current_access_from_decl (tree);
196	static enum template_base_result get_template_base (tree, tree, tree, tree,
197	bool , tree *);
198	static tree try_class_unification (tree, tree, tree, tree, bool);
199	static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
200	tree, tree);
201	static bool template_template_parm_bindings_ok_p (tree, tree);
202	static void tsubst_default_arguments (tree, tsubst_flags_t);
203	static tree for_each_template_parm_r (tree , int* , void* *);
204	static tree copy_default_args_to_explicit_spec_1 (tree, tree);
205	static void copy_default_args_to_explicit_spec (tree);
206	static bool invalid_nontype_parm_type_p (tree, tsubst_flags_t);
207	static bool dependent_template_arg_p (tree);
208	static bool any_template_arguments_need_structural_equality_p (tree);
209	static bool dependent_type_p_r (tree);
210	static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
211	static tree tsubst_decl (tree, tree, tsubst_flags_t);
212	static void perform_typedefs_access_check (tree tmpl, tree targs);
213	static void append_type_to_template_for_access_check_1 (tree, tree, tree,
214	location_t);
215	static tree listify (tree);
216	static tree listify_autos (tree, tree);
217	static tree tsubst_template_parm (tree, tree, tsubst_flags_t);
218	static tree instantiate_alias_template (tree, tree, tsubst_flags_t);
219	static bool complex_alias_template_p (const_tree tmpl);
220	static tree tsubst_attributes (tree, tree, tsubst_flags_t, tree);
221	static tree canonicalize_expr_argument (tree, tsubst_flags_t);
222	static tree make_argument_pack (tree);
223	static void register_parameter_specializations (tree, tree);
224
225	/ Make the current scope suitable for access checking when we are*
226	processing T. T can be FUNCTION_DECL for instantiated function
227	template, VAR_DECL for static member variable, or TYPE_DECL for
228	alias template (needed by instantiate_decl). /*
229
230	static void
231	push_access_scope (tree t)
232	{
233	gcc_assert (VAR_OR_FUNCTION_DECL_P (t)
234	\|\| TREE_CODE (t) == TYPE_DECL);
235
236	if (DECL_FRIEND_CONTEXT (t))
237	push_nested_class (DECL_FRIEND_CONTEXT (t));
238	else if (DECL_CLASS_SCOPE_P (t))
239	push_nested_class (DECL_CONTEXT (t));
240	else
241	push_to_top_level ();
242
243	if (TREE_CODE (t) == FUNCTION_DECL)
244	{
245	saved_access_scope = tree_cons
246	(NULL_TREE, current_function_decl, saved_access_scope);
247	current_function_decl = t;
248	}
249	}
250
251	/ Restore the scope set up by push_access_scope. T is the node we*
252	are processing. /*
253
254	static void
255	pop_access_scope (tree t)
256	{
257	if (TREE_CODE (t) == FUNCTION_DECL)
258	{
259	current_function_decl = TREE_VALUE (saved_access_scope);
260	saved_access_scope = TREE_CHAIN (saved_access_scope);
261	}
262
263	if (DECL_FRIEND_CONTEXT (t) \|\| DECL_CLASS_SCOPE_P (t))
264	pop_nested_class ();
265	else
266	pop_from_top_level ();
267	}
268
269	/ Do any processing required when DECL (a member template*
270	declaration) is finished. Returns the TEMPLATE_DECL corresponding
271	to DECL, unless it is a specialization, in which case the DECL
272	itself is returned. /*
273
274	tree
275	finish_member_template_decl (tree decl)
276	{
277	if (decl == error_mark_node)
278	return error_mark_node;
279
280	gcc_assert (DECL_P (decl));
281
282	if (TREE_CODE (decl) == TYPE_DECL)
283	{
284	tree type;
285
286	type = TREE_TYPE (decl);
287	if (type == error_mark_node)
288	return error_mark_node;
289	if (MAYBE_CLASS_TYPE_P (type)
290	&& CLASSTYPE_TEMPLATE_INFO (type)
291	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
292	{
293	tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
294	check_member_template (tmpl);
295	return tmpl;
296	}
297	return NULL_TREE;
298	}
299	else if (TREE_CODE (decl) == FIELD_DECL)
300	error ("data member %qD cannot be a member template", decl);
301	else if (DECL_TEMPLATE_INFO (decl))
302	{
303	if (!DECL_TEMPLATE_SPECIALIZATION (decl))
304	{
305	check_member_template (DECL_TI_TEMPLATE (decl));
306	return DECL_TI_TEMPLATE (decl);
307	}
308	else
309	return decl;
310	}
311	else
312	error ("invalid member template declaration %qD", decl);
313
314	return error_mark_node;
315	}
316
317	/ Create a template info node. /
318
319	tree
320	build_template_info (tree template_decl, tree template_args)
321	{
322	tree result = make_node (TEMPLATE_INFO);
323	TI_TEMPLATE (result) = template_decl;
324	TI_ARGS (result) = template_args;
325	return result;
326	}
327
328	/ Return the template info node corresponding to T, whatever T is. /
329
330	tree
331	get_template_info (const_tree t)
332	{
333	tree tinfo = NULL_TREE;
334
335	if (!t \|\| t == error_mark_node)
336	return NULL;
337
338	if (TREE_CODE (t) == NAMESPACE_DECL
339	\|\| TREE_CODE (t) == PARM_DECL)
340	return NULL;
341
342	if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
343	tinfo = DECL_TEMPLATE_INFO (t);
344
345	if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
346	t = TREE_TYPE (t);
347
348	if (OVERLOAD_TYPE_P (t))
349	tinfo = TYPE_TEMPLATE_INFO (t);
350	else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
351	tinfo = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
352
353	return tinfo;
354	}
355
356	/ Returns the template nesting level of the indicated class TYPE.*
357
358	For example, in:
359	template <class T>
360	struct A
361	{
362	template <class U>
363	struct B {};
364	};
365
366	A<T>::B<U> has depth two, while A<T> has depth one.
367	Both A<T>::B<int> and A<int>::B<U> have depth one, if
368	they are instantiations, not specializations.
369
370	This function is guaranteed to return 0 if passed NULL_TREE so
371	that, for example, `template_class_depth (current_class_type)' is
372	always safe. /*
373
374	int
375	template_class_depth (tree type)
376	{
377	int depth;
378
379	for (depth = `0`; type && TREE_CODE (type) != NAMESPACE_DECL; )
380	{
381	tree tinfo = get_template_info (type);
382
383	if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
384	&& uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
385	++depth;
386
387	if (DECL_P (type))
388	type = CP_DECL_CONTEXT (type);
389	else if (LAMBDA_TYPE_P (type))
390	type = LAMBDA_TYPE_EXTRA_SCOPE (type);
391	else
392	type = CP_TYPE_CONTEXT (type);
393	}
394
395	return depth;
396	}
397
398	/ Subroutine of maybe_begin_member_template_processing.*
399	Returns true if processing DECL needs us to push template parms. /*
400
401	static bool
402	inline_needs_template_parms (tree decl, bool nsdmi)
403	{
404	if (!decl \|\| (!nsdmi && ! DECL_TEMPLATE_INFO (decl)))
405	return false;
406
407	return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
408	> (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
409	}
410
411	/ Subroutine of maybe_begin_member_template_processing.*
412	Push the template parms in PARMS, starting from LEVELS steps into the
413	chain, and ending at the beginning, since template parms are listed
414	innermost first. /*
415
416	static void
417	push_inline_template_parms_recursive (tree parmlist, int levels)
418	{
419	tree parms = TREE_VALUE (parmlist);
420	int i;
421
422	if (levels > `1`)
423	push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - `1`);
424
425	++processing_template_decl;
426	current_template_parms
427	= tree_cons (size_int (processing_template_decl),
428	parms, current_template_parms);
429	TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = `1`;
430
431	begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
432	NULL);
433	for (i = `0`; i < TREE_VEC_LENGTH (parms); ++i)
434	{
435	tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
436
437	if (error_operand_p (parm))
438	continue;
439
440	gcc_assert (DECL_P (parm));
441
442	switch (TREE_CODE (parm))
443	{
444	case TYPE_DECL:
445	case TEMPLATE_DECL:
446	pushdecl (parm);
447	break;
448
449	case PARM_DECL:
450	/ Push the CONST_DECL. /
451	pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm)));
452	break;
453
454	default:
455	gcc_unreachable ();
456	}
457	}
458	}
459
460	/ Restore the template parameter context for a member template, a*
461	friend template defined in a class definition, or a non-template
462	member of template class. /*
463
464	void
465	maybe_begin_member_template_processing (tree decl)
466	{
467	tree parms;
468	int levels = `0`;
469	bool nsdmi = TREE_CODE (decl) == FIELD_DECL;
470
471	if (nsdmi)
472	{
473	tree ctx = DECL_CONTEXT (decl);
474	decl = (CLASSTYPE_TEMPLATE_INFO (ctx)
475	/ Disregard full specializations (c++/60999). /
476	&& uses_template_parms (ctx)
477	? CLASSTYPE_TI_TEMPLATE (ctx) : NULL_TREE);
478	}
479
480	if (inline_needs_template_parms (decl, nsdmi))
481	{
482	parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
483	levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
484
485	if (DECL_TEMPLATE_SPECIALIZATION (decl))
486	{
487	--levels;
488	parms = TREE_CHAIN (parms);
489	}
490
491	push_inline_template_parms_recursive (parms, levels);
492	}
493
494	/ Remember how many levels of template parameters we pushed so that*
495	we can pop them later. /*
496	inline_parm_levels.safe_push (levels);
497	}
498
499	/ Undo the effects of maybe_begin_member_template_processing. /
500
501	void
502	maybe_end_member_template_processing (void)
503	{
504	int i;
505	int last;
506
507	if (inline_parm_levels.length () == `0`)
508	return;
509
510	last = inline_parm_levels.pop ();
511	for (i = `0`; i < last; ++i)
512	{
513	--processing_template_decl;
514	current_template_parms = TREE_CHAIN (current_template_parms);
515	poplevel (`0`, `0`, `0`);
516	}
517	}
518
519	/ Return a new template argument vector which contains all of ARGS,*
520	but has as its innermost set of arguments the EXTRA_ARGS. /*
521
522	static tree
523	add_to_template_args (tree args, tree extra_args)
524	{
525	tree new_args;
526	int extra_depth;
527	int i;
528	int j;
529
530	if (args == NULL_TREE \|\| extra_args == error_mark_node)
531	return extra_args;
532
533	extra_depth = TMPL_ARGS_DEPTH (extra_args);
534	new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
535
536	for (i = `1`; i <= TMPL_ARGS_DEPTH (args); ++i)
537	SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
538
539	for (j = `1`; j <= extra_depth; ++j, ++i)
540	SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
541
542	return new_args;
543	}
544
545	/ Like add_to_template_args, but only the outermost ARGS are added to*
546	the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
547	(EXTRA_ARGS) levels are added. This function is used to combine
548	the template arguments from a partial instantiation with the
549	template arguments used to attain the full instantiation from the
550	partial instantiation. /*
551
552	static tree
553	add_outermost_template_args (tree args, tree extra_args)
554	{
555	tree new_args;
556
557	/ If there are more levels of EXTRA_ARGS than there are ARGS,*
558	something very fishy is going on. /*
559	gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
560
561	/ If all the new arguments will be the EXTRA_ARGS, just return*
562	them. /*
563	if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
564	return extra_args;
565
566	/ For the moment, we make ARGS look like it contains fewer levels. /
567	TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
568
569	new_args = add_to_template_args (args, extra_args);
570
571	/ Now, we restore ARGS to its full dimensions. /
572	TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
573
574	return new_args;
575	}
576
577	/ Return the N levels of innermost template arguments from the ARGS. /
578
579	tree
580	get_innermost_template_args (tree args, int n)
581	{
582	tree new_args;
583	int extra_levels;
584	int i;
585
586	gcc_assert (n >= `0`);
587
588	/ If N is 1, just return the innermost set of template arguments. /
589	if (n == `1`)
590	return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
591
592	/ If we're not removing anything, just return the arguments we were*
593	given. /*
594	extra_levels = TMPL_ARGS_DEPTH (args) - n;
595	gcc_assert (extra_levels >= `0`);
596	if (extra_levels == `0`)
597	return args;
598
599	/ Make a new set of arguments, not containing the outer arguments. /
600	new_args = make_tree_vec (n);
601	for (i = `1`; i <= n; ++i)
602	SET_TMPL_ARGS_LEVEL (new_args, i,
603	TMPL_ARGS_LEVEL (args, i + extra_levels));
604
605	return new_args;
606	}
607
608	/ The inverse of get_innermost_template_args: Return all but the innermost*
609	EXTRA_LEVELS levels of template arguments from the ARGS. /*
610
611	static tree
612	strip_innermost_template_args (tree args, int extra_levels)
613	{
614	tree new_args;
615	int n = TMPL_ARGS_DEPTH (args) - extra_levels;
616	int i;
617
618	gcc_assert (n >= `0`);
619
620	/ If N is 1, just return the outermost set of template arguments. /
621	if (n == `1`)
622	return TMPL_ARGS_LEVEL (args, `1`);
623
624	/ If we're not removing anything, just return the arguments we were*
625	given. /*
626	gcc_assert (extra_levels >= `0`);
627	if (extra_levels == `0`)
628	return args;
629
630	/ Make a new set of arguments, not containing the inner arguments. /
631	new_args = make_tree_vec (n);
632	for (i = `1`; i <= n; ++i)
633	SET_TMPL_ARGS_LEVEL (new_args, i,
634	TMPL_ARGS_LEVEL (args, i));
635
636	return new_args;
637	}
638
639	/ We've got a template header coming up; push to a new level for storing*
640	the parms. /*
641
642	void
643	begin_template_parm_list (void)
644	{
645	/ We use a non-tag-transparent scope here, which causes pushtag to*
646	put tags in this scope, rather than in the enclosing class or
647	namespace scope. This is the right thing, since we want
648	TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
649	global template class, push_template_decl handles putting the
650	TEMPLATE_DECL into top-level scope. For a nested template class,
651	e.g.:
652
653	template <class T> struct S1 {
654	template <class T> struct S2 {};
655	};
656
657	pushtag contains special code to insert the TEMPLATE_DECL for S2
658	at the right scope. /*
659	begin_scope (sk_template_parms, NULL);
660	++processing_template_decl;
661	++processing_template_parmlist;
662	note_template_header (`0`);
663
664	/ Add a dummy parameter level while we process the parameter list. /
665	current_template_parms
666	= tree_cons (size_int (processing_template_decl),
667	make_tree_vec (`0`),
668	current_template_parms);
669	}
670
671	/ This routine is called when a specialization is declared. If it is*
672	invalid to declare a specialization here, an error is reported and
673	false is returned, otherwise this routine will return true. /*
674
675	static bool
676	check_specialization_scope (void)
677	{
678	tree scope = current_scope ();
679
680	/ [temp.expl.spec]*
681
682	An explicit specialization shall be declared in the namespace of
683	which the template is a member, or, for member templates, in the
684	namespace of which the enclosing class or enclosing class
685	template is a member. An explicit specialization of a member
686	function, member class or static data member of a class template
687	shall be declared in the namespace of which the class template
688	is a member. /*
689	if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
690	{
691	error ("explicit specialization in non-namespace scope %qD", scope);
692	return false;
693	}
694
695	/ [temp.expl.spec]*
696
697	In an explicit specialization declaration for a member of a class
698	template or a member template that appears in namespace scope,
699	the member template and some of its enclosing class templates may
700	remain unspecialized, except that the declaration shall not
701	explicitly specialize a class member template if its enclosing
702	class templates are not explicitly specialized as well. /*
703	if (current_template_parms)
704	{
705	error ("enclosing class templates are not explicitly specialized");
706	return false;
707	}
708
709	return true;
710	}
711
712	/ We've just seen template <>. /
713
714	bool
715	begin_specialization (void)
716	{
717	begin_scope (sk_template_spec, NULL);
718	note_template_header (`1`);
719	return check_specialization_scope ();
720	}
721
722	/ Called at then end of processing a declaration preceded by*
723	template<>. /*
724
725	void
726	end_specialization (void)
727	{
728	finish_scope ();
729	reset_specialization ();
730	}
731
732	/ Any template <>'s that we have seen thus far are not referring to a*
733	function specialization. /*
734
735	void
736	reset_specialization (void)
737	{
738	processing_specialization = `0`;
739	template_header_count = `0`;
740	}
741
742	/ We've just seen a template header. If SPECIALIZATION is nonzero,*
743	it was of the form template <>. /*
744
745	static void
746	note_template_header (int specialization)
747	{
748	processing_specialization = specialization;
749	template_header_count++;
750	}
751
752	/ We're beginning an explicit instantiation. /
753
754	void
755	begin_explicit_instantiation (void)
756	{
757	gcc_assert (!processing_explicit_instantiation);
758	processing_explicit_instantiation = true;
759	}
760
761
762	void
763	end_explicit_instantiation (void)
764	{
765	gcc_assert (processing_explicit_instantiation);
766	processing_explicit_instantiation = false;
767	}
768
769	/ An explicit specialization or partial specialization of TMPL is being*
770	declared. Check that the namespace in which the specialization is
771	occurring is permissible. Returns false iff it is invalid to
772	specialize TMPL in the current namespace. /*
773
774	static bool
775	check_specialization_namespace (tree tmpl)
776	{
777	tree tpl_ns = decl_namespace_context (tmpl);
778
779	/ [tmpl.expl.spec]*
780
781	An explicit specialization shall be declared in a namespace enclosing the
782	specialized template. An explicit specialization whose declarator-id is
783	not qualified shall be declared in the nearest enclosing namespace of the
784	template, or, if the namespace is inline (7.3.1), any namespace from its
785	enclosing namespace set. /*
786	if (current_scope() != DECL_CONTEXT (tmpl)
787	&& !at_namespace_scope_p ())
788	{
789	error ("specialization of %qD must appear at namespace scope", tmpl);
790	return false;
791	}
792
793	if (is_nested_namespace (current_namespace, tpl_ns, cxx_dialect < cxx11))
794	/ Same or enclosing namespace. /
795	return true;
796	else
797	{
798	permerror (input_location,
799	"specialization of %qD in different namespace", tmpl);
800	inform (DECL_SOURCE_LOCATION (tmpl),
801	" from definition of %q#D", tmpl);
802	return false;
803	}
804	}
805
806	/ SPEC is an explicit instantiation. Check that it is valid to*
807	perform this explicit instantiation in the current namespace. /*
808
809	static void
810	check_explicit_instantiation_namespace (tree spec)
811	{
812	tree ns;
813
814	/ DR 275: An explicit instantiation shall appear in an enclosing*
815	namespace of its template. /*
816	ns = decl_namespace_context (spec);
817	if (!is_nested_namespace (current_namespace, ns))
818	permerror (input_location, "explicit instantiation of %qD in namespace %qD "
819	"(which does not enclose namespace %qD)",
820	spec, current_namespace, ns);
821	}
822
823	// Returns the type of a template specialization only if that
824	// specialization needs to be defined. Otherwise (e.g., if the type has
825	// already been defined), the function returns NULL_TREE.
826	static tree
827	maybe_new_partial_specialization (tree type)
828	{
829	// An implicit instantiation of an incomplete type implies
830	// the definition of a new class template.
831	//
832	// template<typename T>
833	// struct S;
834	//
835	// template<typename T>
836	// struct S<T>;*
837	//
838	// Here, S<T> is an implicit instantiation of S whose type*
839	// is incomplete.
840	if (CLASSTYPE_IMPLICIT_INSTANTIATION (type) && !COMPLETE_TYPE_P (type))
841	return type;
842
843	// It can also be the case that TYPE is a completed specialization.
844	// Continuing the previous example, suppose we also declare:
845	//
846	// template<typename T>
847	// requires Integral<T>
848	// struct S<T>;*
849	//
850	// Here, S<T> refers to the specialization S<T> defined
851	// above. However, we need to differentiate definitions because
852	// we intend to define a new partial specialization. In this case,
853	// we rely on the fact that the constraints are different for
854	// this declaration than that above.
855	//
856	// Note that we also get here for injected class names and
857	// late-parsed template definitions. We must ensure that we
858	// do not create new type declarations for those cases.
859	if (flag_concepts && CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
860	{
861	tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
862	tree args = CLASSTYPE_TI_ARGS (type);
863
864	// If there are no template parameters, this cannot be a new
865	// partial template specializtion?
866	if (!current_template_parms)
867	return NULL_TREE;
868
869	// The injected-class-name is not a new partial specialization.
870	if (DECL_SELF_REFERENCE_P (TYPE_NAME (type)))
871	return NULL_TREE;
872
873	// If the constraints are not the same as those of the primary
874	// then, we can probably create a new specialization.
875	tree type_constr = current_template_constraints ();
876
877	if (type == TREE_TYPE (tmpl))
878	{
879	tree main_constr = get_constraints (tmpl);
880	if (equivalent_constraints (type_constr, main_constr))
881	return NULL_TREE;
882	}
883
884	// Also, if there's a pre-existing specialization with matching
885	// constraints, then this also isn't new.
886	tree specs = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
887	while (specs)
888	{
889	tree spec_tmpl = TREE_VALUE (specs);
890	tree spec_args = TREE_PURPOSE (specs);
891	tree spec_constr = get_constraints (spec_tmpl);
892	if (comp_template_args (args, spec_args)
893	&& equivalent_constraints (type_constr, spec_constr))
894	return NULL_TREE;
895	specs = TREE_CHAIN (specs);
896	}
897
898	// Create a new type node (and corresponding type decl)
899	// for the newly declared specialization.
900	tree t = make_class_type (TREE_CODE (type));
901	CLASSTYPE_DECLARED_CLASS (t) = CLASSTYPE_DECLARED_CLASS (type);
902	SET_TYPE_TEMPLATE_INFO (t, build_template_info (tmpl, args));
903
904	/ We only need a separate type node for storing the definition of this*
905	partial specialization; uses of S<T> are unconstrained, so all are*
906	equivalent. So keep TYPE_CANONICAL the same. /*
907	TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
908
909	// Build the corresponding type decl.
910	tree d = create_implicit_typedef (DECL_NAME (tmpl), t);
911	DECL_CONTEXT (d) = TYPE_CONTEXT (t);
912	DECL_SOURCE_LOCATION (d) = input_location;
913
914	return t;
915	}
916
917	return NULL_TREE;
918	}
919
920	/ The TYPE is being declared. If it is a template type, that means it*
921	is a partial specialization. Do appropriate error-checking. /*
922
923	tree
924	maybe_process_partial_specialization (tree type)
925	{
926	tree context;
927
928	if (type == error_mark_node)
929	return error_mark_node;
930
931	/ A lambda that appears in specialization context is not itself a*
932	specialization. /*
933	if (CLASS_TYPE_P (type) && CLASSTYPE_LAMBDA_EXPR (type))
934	return type;
935
936	if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
937	{
938	error ("name of class shadows template template parameter %qD",
939	TYPE_NAME (type));
940	return error_mark_node;
941	}
942
943	context = TYPE_CONTEXT (type);
944
945	if (TYPE_ALIAS_P (type))
946	{
947	tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (type);
948
949	if (tinfo && DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo)))
950	error ("specialization of alias template %qD",
951	TI_TEMPLATE (tinfo));
952	else
953	error ("explicit specialization of non-template %qT", type);
954	return error_mark_node;
955	}
956	else if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
957	{
958	/ This is for ordinary explicit specialization and partial*
959	specialization of a template class such as:
960
961	template <> class C<int>;
962
963	or:
964
965	template <class T> class C<T>;*
966
967	Make sure that `C<int>' and `C<T>' are implicit instantiations. /
968
969	if (tree t = maybe_new_partial_specialization (type))
970	{
971	if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t))
972	&& !at_namespace_scope_p ())
973	return error_mark_node;
974	SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t);
975	DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t)) = input_location;
976	if (processing_template_decl)
977	{
978	tree decl = push_template_decl (TYPE_MAIN_DECL (t));
979	if (decl == error_mark_node)
980	return error_mark_node;
981	return TREE_TYPE (decl);
982	}
983	}
984	else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
985	error ("specialization of %qT after instantiation", type);
986	else if (errorcount && !processing_specialization
987	&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type)
988	&& !uses_template_parms (CLASSTYPE_TI_ARGS (type)))
989	/ Trying to define a specialization either without a template<> header*
990	or in an inappropriate place. We've already given an error, so just
991	bail now so we don't actually define the specialization. /*
992	return error_mark_node;
993	}
994	else if (CLASS_TYPE_P (type)
995	&& !CLASSTYPE_USE_TEMPLATE (type)
996	&& CLASSTYPE_TEMPLATE_INFO (type)
997	&& context && CLASS_TYPE_P (context)
998	&& CLASSTYPE_TEMPLATE_INFO (context))
999	{
1000	/ This is for an explicit specialization of member class*
1001	template according to [temp.expl.spec/18]:
1002
1003	template <> template <class U> class C<int>::D;
1004
1005	The context `C<int>' must be an implicit instantiation.
1006	Otherwise this is just a member class template declared
1007	earlier like:
1008
1009	template <> class C<int> { template <class U> class D; };
1010	template <> template <class U> class C<int>::D;
1011
1012	In the first case, `C<int>::D' is a specialization of `C<T>::D'
1013	while in the second case, `C<int>::D' is a primary template
1014	and `C<T>::D' may not exist. /*
1015
1016	if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
1017	&& !COMPLETE_TYPE_P (type))
1018	{
1019	tree t;
1020	tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
1021
1022	if (current_namespace
1023	!= decl_namespace_context (tmpl))
1024	{
1025	permerror (input_location,
1026	"specializing %q#T in different namespace", type);
1027	permerror (DECL_SOURCE_LOCATION (tmpl),
1028	" from definition of %q#D", tmpl);
1029	}
1030
1031	/ Check for invalid specialization after instantiation:*
1032
1033	template <> template <> class C<int>::D<int>;
1034	template <> template <class U> class C<int>::D; /*
1035
1036	for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
1037	t; t = TREE_CHAIN (t))
1038	{
1039	tree inst = TREE_VALUE (t);
1040	if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst)
1041	\|\| !COMPLETE_OR_OPEN_TYPE_P (inst))
1042	{
1043	/ We already have a full specialization of this partial*
1044	instantiation, or a full specialization has been
1045	looked up but not instantiated. Reassign it to the
1046	new member specialization template. /*
1047	spec_entry elt;
1048	spec_entry *entry;
1049
1050	elt.tmpl = most_general_template (tmpl);
1051	elt.args = CLASSTYPE_TI_ARGS (inst);
1052	elt.spec = inst;
1053
1054	type_specializations->remove_elt (&elt);
1055
1056	elt.tmpl = tmpl;
1057	elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
1058
1059	spec_entry **slot
1060	= type_specializations->find_slot (&elt, INSERT);
1061	entry = ggc_alloc<spec_entry> ();
1062	*entry = elt;
1063	*slot = entry;
1064	}
1065	else
1066	/ But if we've had an implicit instantiation, that's a*
1067	problem ([temp.expl.spec]/6). /*
1068	error ("specialization %qT after instantiation %qT",
1069	type, inst);
1070	}
1071
1072	/ Mark TYPE as a specialization. And as a result, we only*
1073	have one level of template argument for the innermost
1074	class template. /*
1075	SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
1076	DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
1077	CLASSTYPE_TI_ARGS (type)
1078	= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
1079	}
1080	}
1081	else if (processing_specialization)
1082	{
1083	/ Someday C++0x may allow for enum template specialization. /
1084	if (cxx_dialect > cxx98 && TREE_CODE (type) == ENUMERAL_TYPE
1085	&& CLASS_TYPE_P (context) && CLASSTYPE_USE_TEMPLATE (context))
1086	pedwarn (input_location, OPT_Wpedantic, "template specialization "
1087	"of %qD not allowed by ISO C++", type);
1088	else
1089	{
1090	error ("explicit specialization of non-template %qT", type);
1091	return error_mark_node;
1092	}
1093	}
1094
1095	return type;
1096	}
1097
1098	/ Returns nonzero if we can optimize the retrieval of specializations*
1099	for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1100	do not use DECL_TEMPLATE_SPECIALIZATIONS at all. /*
1101
1102	static inline bool
1103	optimize_specialization_lookup_p (tree tmpl)
1104	{
1105	return (DECL_FUNCTION_TEMPLATE_P (tmpl)
1106	&& DECL_CLASS_SCOPE_P (tmpl)
1107	/ DECL_CLASS_SCOPE_P holds of T::f even if T is a template*
1108	parameter. /*
1109	&& CLASS_TYPE_P (DECL_CONTEXT (tmpl))
1110	/ The optimized lookup depends on the fact that the*
1111	template arguments for the member function template apply
1112	purely to the containing class, which is not true if the
1113	containing class is an explicit or partial
1114	specialization. /*
1115	&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
1116	&& !DECL_MEMBER_TEMPLATE_P (tmpl)
1117	&& !DECL_CONV_FN_P (tmpl)
1118	/ It is possible to have a template that is not a member*
1119	template and is not a member of a template class:
1120
1121	template <typename T>
1122	struct S { friend A::f(); };
1123
1124	Here, the friend function is a template, but the context does
1125	not have template information. The optimized lookup relies
1126	on having ARGS be the template arguments for both the class
1127	and the function template. /*
1128	&& !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
1129	}
1130
1131	/ Make sure ARGS doesn't use any inappropriate typedefs; we should have*
1132	gone through coerce_template_parms by now. /*
1133
1134	static void
1135	verify_unstripped_args (tree args)
1136	{
1137	++processing_template_decl;
1138	if (!any_dependent_template_arguments_p (args))
1139	{
1140	tree inner = INNERMOST_TEMPLATE_ARGS (args);
1141	for (int i = `0`; i < TREE_VEC_LENGTH (inner); ++i)
1142	{
1143	tree arg = TREE_VEC_ELT (inner, i);
1144	if (TREE_CODE (arg) == TEMPLATE_DECL)
1145	/ OK /;
1146	else if (TYPE_P (arg))
1147	gcc_assert (strip_typedefs (arg, NULL) == arg);
1148	else if (strip_typedefs (TREE_TYPE (arg), NULL) != TREE_TYPE (arg))
1149	/ Allow typedefs on the type of a non-type argument, since a*
1150	parameter can have them. /*;
1151	else
1152	gcc_assert (strip_typedefs_expr (arg, NULL) == arg);
1153	}
1154	}
1155	--processing_template_decl;
1156	}
1157
1158	/ Retrieve the specialization (in the sense of [temp.spec] - a*
1159	specialization is either an instantiation or an explicit
1160	specialization) of TMPL for the given template ARGS. If there is
1161	no such specialization, return NULL_TREE. The ARGS are a vector of
1162	arguments, or a vector of vectors of arguments, in the case of
1163	templates with more than one level of parameters.
1164
1165	If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1166	then we search for a partial specialization matching ARGS. This
1167	parameter is ignored if TMPL is not a class template.
1168
1169	We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1170	result is a NONTYPE_ARGUMENT_PACK. /*
1171
1172	static tree
1173	retrieve_specialization (tree tmpl, tree args, hashval_t hash)
1174	{
1175	if (tmpl == NULL_TREE)
1176	return NULL_TREE;
1177
1178	if (args == error_mark_node)
1179	return NULL_TREE;
1180
1181	gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL
1182	\|\| TREE_CODE (tmpl) == FIELD_DECL);
1183
1184	/ There should be as many levels of arguments as there are*
1185	levels of parameters. /*
1186	gcc_assert (TMPL_ARGS_DEPTH (args)
1187	== (TREE_CODE (tmpl) == TEMPLATE_DECL
1188	? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl))
1189	: template_class_depth (DECL_CONTEXT (tmpl))));
1190
1191	if (flag_checking)
1192	verify_unstripped_args (args);
1193
1194	/ Lambda functions in templates aren't instantiated normally, but through*
1195	tsubst_lambda_expr. /*
1196	if (lambda_fn_in_template_p (tmpl))
1197	return NULL_TREE;
1198
1199	if (optimize_specialization_lookup_p (tmpl))
1200	{
1201	/ The template arguments actually apply to the containing*
1202	class. Find the class specialization with those
1203	arguments. /*
1204	tree class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
1205	tree class_specialization
1206	= retrieve_specialization (class_template, args, `0`);
1207	if (!class_specialization)
1208	return NULL_TREE;
1209
1210	/ Find the instance of TMPL. /
1211	tree fns = get_class_binding (class_specialization, DECL_NAME (tmpl));
1212	for (ovl_iterator iter (fns); iter; ++iter)
1213	{
1214	tree fn = *iter;
1215	if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl
1216	/ using-declarations can add base methods to the method vec,*
1217	and we don't want those here. /*
1218	&& DECL_CONTEXT (fn) == class_specialization)
1219	return fn;
1220	}
1221	return NULL_TREE;
1222	}
1223	else
1224	{
1225	spec_entry *found;
1226	spec_entry elt;
1227	hash_table<spec_hasher> *specializations;
1228
1229	elt.tmpl = tmpl;
1230	elt.args = args;
1231	elt.spec = NULL_TREE;
1232
1233	if (DECL_CLASS_TEMPLATE_P (tmpl))
1234	specializations = type_specializations;
1235	else
1236	specializations = decl_specializations;
1237
1238	if (hash == `0`)
1239	hash = spec_hasher::hash (&elt);
1240	found = specializations->find_with_hash (&elt, hash);
1241	if (found)
1242	return found->spec;
1243	}
1244
1245	return NULL_TREE;
1246	}
1247
1248	/ Like retrieve_specialization, but for local declarations. /
1249
1250	tree
1251	retrieve_local_specialization (tree tmpl)
1252	{
1253	if (local_specializations == NULL)
1254	return NULL_TREE;
1255
1256	tree *slot = local_specializations->get (tmpl);
1257	return slot ? *slot : NULL_TREE;
1258	}
1259
1260	/ Returns nonzero iff DECL is a specialization of TMPL. /
1261
1262	int
1263	is_specialization_of (tree decl, tree tmpl)
1264	{
1265	tree t;
1266
1267	if (TREE_CODE (decl) == FUNCTION_DECL)
1268	{
1269	for (t = decl;
1270	t != NULL_TREE;
1271	t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1272	if (t == tmpl)
1273	return `1`;
1274	}
1275	else
1276	{
1277	gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1278
1279	for (t = TREE_TYPE (decl);
1280	t != NULL_TREE;
1281	t = CLASSTYPE_USE_TEMPLATE (t)
1282	? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1283	if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1284	return `1`;
1285	}
1286
1287	return `0`;
1288	}
1289
1290	/ Returns nonzero iff DECL is a specialization of friend declaration*
1291	FRIEND_DECL according to [temp.friend]. /*
1292
1293	bool
1294	is_specialization_of_friend (tree decl, tree friend_decl)
1295	{
1296	bool need_template = true;
1297	int template_depth;
1298
1299	gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1300	\|\| TREE_CODE (decl) == TYPE_DECL);
1301
1302	/ For [temp.friend/6] when FRIEND_DECL is an ordinary member function*
1303	of a template class, we want to check if DECL is a specialization
1304	if this. /*
1305	if (TREE_CODE (friend_decl) == FUNCTION_DECL
1306	&& DECL_TEMPLATE_INFO (friend_decl)
1307	&& !DECL_USE_TEMPLATE (friend_decl))
1308	{
1309	/ We want a TEMPLATE_DECL for `is_specialization_of'. /
1310	friend_decl = DECL_TI_TEMPLATE (friend_decl);
1311	need_template = false;
1312	}
1313	else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1314	&& !PRIMARY_TEMPLATE_P (friend_decl))
1315	need_template = false;
1316
1317	/ There is nothing to do if this is not a template friend. /
1318	if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1319	return false;
1320
1321	if (is_specialization_of (decl, friend_decl))
1322	return true;
1323
1324	/ [temp.friend/6]*
1325	A member of a class template may be declared to be a friend of a
1326	non-template class. In this case, the corresponding member of
1327	every specialization of the class template is a friend of the
1328	class granting friendship.
1329
1330	For example, given a template friend declaration
1331
1332	template <class T> friend void A<T>::f();
1333
1334	the member function below is considered a friend
1335
1336	template <> struct A<int> {
1337	void f();
1338	};
1339
1340	For this type of template friend, TEMPLATE_DEPTH below will be
1341	nonzero. To determine if DECL is a friend of FRIEND, we first
1342	check if the enclosing class is a specialization of another. /*
1343
1344	template_depth = template_class_depth (CP_DECL_CONTEXT (friend_decl));
1345	if (template_depth
1346	&& DECL_CLASS_SCOPE_P (decl)
1347	&& is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1348	CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
1349	{
1350	/ Next, we check the members themselves. In order to handle*
1351	a few tricky cases, such as when FRIEND_DECL's are
1352
1353	template <class T> friend void A<T>::g(T t);
1354	template <class T> template <T t> friend void A<T>::h();
1355
1356	and DECL's are
1357
1358	void A<int>::g(int);
1359	template <int> void A<int>::h();
1360
1361	we need to figure out ARGS, the template arguments from
1362	the context of DECL. This is required for template substitution
1363	of `T' in the function parameter of `g' and template parameter
1364	of `h' in the above examples. Here ARGS corresponds to `int'. /*
1365
1366	tree context = DECL_CONTEXT (decl);
1367	tree args = NULL_TREE;
1368	int current_depth = `0`;
1369
1370	while (current_depth < template_depth)
1371	{
1372	if (CLASSTYPE_TEMPLATE_INFO (context))
1373	{
1374	if (current_depth == `0`)
1375	args = TYPE_TI_ARGS (context);
1376	else
1377	args = add_to_template_args (TYPE_TI_ARGS (context), args);
1378	current_depth++;
1379	}
1380	context = TYPE_CONTEXT (context);
1381	}
1382
1383	if (TREE_CODE (decl) == FUNCTION_DECL)
1384	{
1385	bool is_template;
1386	tree friend_type;
1387	tree decl_type;
1388	tree friend_args_type;
1389	tree decl_args_type;
1390
1391	/ Make sure that both DECL and FRIEND_DECL are templates or*
1392	non-templates. /*
1393	is_template = DECL_TEMPLATE_INFO (decl)
1394	&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1395	if (need_template ^ is_template)
1396	return false;
1397	else if (is_template)
1398	{
1399	/ If both are templates, check template parameter list. /
1400	tree friend_parms
1401	= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1402	args, tf_none);
1403	if (!comp_template_parms
1404	(DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1405	friend_parms))
1406	return false;
1407
1408	decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1409	}
1410	else
1411	decl_type = TREE_TYPE (decl);
1412
1413	friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
1414	tf_none, NULL_TREE);
1415	if (friend_type == error_mark_node)
1416	return false;
1417
1418	/ Check if return types match. /
1419	if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1420	return false;
1421
1422	/ Check if function parameter types match, ignoring the*
1423	`this' parameter. /*
1424	friend_args_type = TYPE_ARG_TYPES (friend_type);
1425	decl_args_type = TYPE_ARG_TYPES (decl_type);
1426	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
1427	friend_args_type = TREE_CHAIN (friend_args_type);
1428	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1429	decl_args_type = TREE_CHAIN (decl_args_type);
1430
1431	return compparms (decl_args_type, friend_args_type);
1432	}
1433	else
1434	{
1435	/ DECL is a TYPE_DECL /
1436	bool is_template;
1437	tree decl_type = TREE_TYPE (decl);
1438
1439	/ Make sure that both DECL and FRIEND_DECL are templates or*
1440	non-templates. /*
1441	is_template
1442	= CLASSTYPE_TEMPLATE_INFO (decl_type)
1443	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1444
1445	if (need_template ^ is_template)
1446	return false;
1447	else if (is_template)
1448	{
1449	tree friend_parms;
1450	/ If both are templates, check the name of the two*
1451	TEMPLATE_DECL's first because is_friend didn't. /*
1452	if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1453	!= DECL_NAME (friend_decl))
1454	return false;
1455
1456	/ Now check template parameter list. /
1457	friend_parms
1458	= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1459	args, tf_none);
1460	return comp_template_parms
1461	(DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1462	friend_parms);
1463	}
1464	else
1465	return (DECL_NAME (decl)
1466	== DECL_NAME (friend_decl));
1467	}
1468	}
1469	return false;
1470	}
1471
1472	/ Register the specialization SPEC as a specialization of TMPL with*
1473	the indicated ARGS. IS_FRIEND indicates whether the specialization
1474	is actually just a friend declaration. Returns SPEC, or an
1475	equivalent prior declaration, if available.
1476
1477	We also store instantiations of field packs in the hash table, even
1478	though they are not themselves templates, to make lookup easier. /*
1479
1480	static tree
1481	register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
1482	hashval_t hash)
1483	{
1484	tree fn;
1485	spec_entry **slot = NULL;
1486	spec_entry elt;
1487
1488	gcc_assert ((TREE_CODE (tmpl) == TEMPLATE_DECL && DECL_P (spec))
1489	\|\| (TREE_CODE (tmpl) == FIELD_DECL
1490	&& TREE_CODE (spec) == NONTYPE_ARGUMENT_PACK));
1491
1492	if (TREE_CODE (spec) == FUNCTION_DECL
1493	&& uses_template_parms (DECL_TI_ARGS (spec)))
1494	/ This is the FUNCTION_DECL for a partial instantiation. Don't*
1495	register it; we want the corresponding TEMPLATE_DECL instead.
1496	We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1497	the more obvious `uses_template_parms (spec)' to avoid problems
1498	with default function arguments. In particular, given
1499	something like this:
1500
1501	template <class T> void f(T t1, T t = T())
1502
1503	the default argument expression is not substituted for in an
1504	instantiation unless and until it is actually needed. /*
1505	return spec;
1506
1507	if (optimize_specialization_lookup_p (tmpl))
1508	/ We don't put these specializations in the hash table, but we might*
1509	want to give an error about a mismatch. /*
1510	fn = retrieve_specialization (tmpl, args, `0`);
1511	else
1512	{
1513	elt.tmpl = tmpl;
1514	elt.args = args;
1515	elt.spec = spec;
1516
1517	if (hash == `0`)
1518	hash = spec_hasher::hash (&elt);
1519
1520	slot =
1521	decl_specializations->find_slot_with_hash (&elt, hash, INSERT);
1522	if (*slot)
1523	fn = ((spec_entry ) slot)->spec;
1524	else
1525	fn = NULL_TREE;
1526	}
1527
1528	/ We can sometimes try to re-register a specialization that we've*
1529	already got. In particular, regenerate_decl_from_template calls
1530	duplicate_decls which will update the specialization list. But,
1531	we'll still get called again here anyhow. It's more convenient
1532	to simply allow this than to try to prevent it. /*
1533	if (fn == spec)
1534	return spec;
1535	else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1536	{
1537	if (DECL_TEMPLATE_INSTANTIATION (fn))
1538	{
1539	if (DECL_ODR_USED (fn)
1540	\|\| DECL_EXPLICIT_INSTANTIATION (fn))
1541	{
1542	error ("specialization of %qD after instantiation",
1543	fn);
1544	return error_mark_node;
1545	}
1546	else
1547	{
1548	tree clone;
1549	/ This situation should occur only if the first*
1550	specialization is an implicit instantiation, the
1551	second is an explicit specialization, and the
1552	implicit instantiation has not yet been used. That
1553	situation can occur if we have implicitly
1554	instantiated a member function and then specialized
1555	it later.
1556
1557	We can also wind up here if a friend declaration that
1558	looked like an instantiation turns out to be a
1559	specialization:
1560
1561	template <class T> void foo(T);
1562	class S { friend void foo<>(int) };
1563	template <> void foo(int);
1564
1565	We transform the existing DECL in place so that any
1566	pointers to it become pointers to the updated
1567	declaration.
1568
1569	If there was a definition for the template, but not
1570	for the specialization, we want this to look as if
1571	there were no definition, and vice versa. /*
1572	DECL_INITIAL (fn) = NULL_TREE;
1573	duplicate_decls (spec, fn, is_friend);
1574	/ The call to duplicate_decls will have applied*
1575	[temp.expl.spec]:
1576
1577	An explicit specialization of a function template
1578	is inline only if it is explicitly declared to be,
1579	and independently of whether its function template
1580	is.
1581
1582	to the primary function; now copy the inline bits to
1583	the various clones. /*
1584	FOR_EACH_CLONE (clone, fn)
1585	{
1586	DECL_DECLARED_INLINE_P (clone)
1587	= DECL_DECLARED_INLINE_P (fn);
1588	DECL_SOURCE_LOCATION (clone)
1589	= DECL_SOURCE_LOCATION (fn);
1590	DECL_DELETED_FN (clone)
1591	= DECL_DELETED_FN (fn);
1592	}
1593	check_specialization_namespace (tmpl);
1594
1595	return fn;
1596	}
1597	}
1598	else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1599	{
1600	tree dd = duplicate_decls (spec, fn, is_friend);
1601	if (dd == error_mark_node)
1602	/ We've already complained in duplicate_decls. /
1603	return error_mark_node;
1604
1605	if (dd == NULL_TREE && DECL_INITIAL (spec))
1606	/ Dup decl failed, but this is a new definition. Set the*
1607	line number so any errors match this new
1608	definition. /*
1609	DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1610
1611	return fn;
1612	}
1613	}
1614	else if (fn)
1615	return duplicate_decls (spec, fn, is_friend);
1616
1617	/ A specialization must be declared in the same namespace as the*
1618	template it is specializing. /*
1619	if (DECL_P (spec) && DECL_TEMPLATE_SPECIALIZATION (spec)
1620	&& !check_specialization_namespace (tmpl))
1621	DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
1622
1623	if (slot != NULL / !optimize_specialization_lookup_p (tmpl) /)
1624	{
1625	spec_entry *entry = ggc_alloc<spec_entry> ();
1626	gcc_assert (tmpl && args && spec);
1627	*entry = elt;
1628	*slot = entry;
1629	if ((TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
1630	&& PRIMARY_TEMPLATE_P (tmpl)
1631	&& DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
1632	\|\| variable_template_p (tmpl))
1633	/ If TMPL is a forward declaration of a template function, keep a list*
1634	of all specializations in case we need to reassign them to a friend
1635	template later in tsubst_friend_function.
1636
1637	Also keep a list of all variable template instantiations so that
1638	process_partial_specialization can check whether a later partial
1639	specialization would have used it. /*
1640	DECL_TEMPLATE_INSTANTIATIONS (tmpl)
1641	= tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1642	}
1643
1644	return spec;
1645	}
1646
1647	/ Returns true iff two spec_entry nodes are equivalent. /
1648
1649	int comparing_specializations;
1650
1651	bool
1652	spec_hasher::equal (spec_entry e1, spec_entry e2)
1653	{
1654	int equal;
1655
1656	++comparing_specializations;
1657	equal = (e1->tmpl == e2->tmpl
1658	&& comp_template_args (e1->args, e2->args));
1659	if (equal && flag_concepts
1660	/ tmpl could be a FIELD_DECL for a capture pack. /
1661	&& TREE_CODE (e1->tmpl) == TEMPLATE_DECL
1662	&& VAR_P (DECL_TEMPLATE_RESULT (e1->tmpl))
1663	&& uses_template_parms (e1->args))
1664	{
1665	/ Partial specializations of a variable template can be distinguished by*
1666	constraints. /*
1667	tree c1 = e1->spec ? get_constraints (e1->spec) : NULL_TREE;
1668	tree c2 = e2->spec ? get_constraints (e2->spec) : NULL_TREE;
1669	equal = equivalent_constraints (c1, c2);
1670	}
1671	--comparing_specializations;
1672
1673	return equal;
1674	}
1675
1676	/ Returns a hash for a template TMPL and template arguments ARGS. /
1677
1678	static hashval_t
1679	hash_tmpl_and_args (tree tmpl, tree args)
1680	{
1681	hashval_t val = iterative_hash_object (DECL_UID (tmpl), `0`);
1682	return iterative_hash_template_arg (args, val);
1683	}
1684
1685	/ Returns a hash for a spec_entry node based on the TMPL and ARGS members,*
1686	ignoring SPEC. /*
1687
1688	hashval_t
1689	spec_hasher::hash (spec_entry *e)
1690	{
1691	return hash_tmpl_and_args (e->tmpl, e->args);
1692	}
1693
1694	/ Recursively calculate a hash value for a template argument ARG, for use*
1695	in the hash tables of template specializations. /*
1696
1697	hashval_t
1698	iterative_hash_template_arg (tree arg, hashval_t val)
1699	{
1700	unsigned HOST_WIDE_INT i;
1701	enum tree_code code;
1702	char tclass;
1703
1704	if (arg == NULL_TREE)
1705	return iterative_hash_object (arg, val);
1706
1707	if (!TYPE_P (arg))
1708	STRIP_NOPS (arg);
1709
1710	if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
1711	gcc_unreachable ();
1712
1713	code = TREE_CODE (arg);
1714	tclass = TREE_CODE_CLASS (code);
1715
1716	val = iterative_hash_object (code, val);
1717
1718	switch (code)
1719	{
1720	case ERROR_MARK:
1721	return val;
1722
1723	case IDENTIFIER_NODE:
1724	return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg), val);
1725
1726	case TREE_VEC:
1727	{
1728	int i, len = TREE_VEC_LENGTH (arg);
1729	for (i = `0`; i < len; ++i)
1730	val = iterative_hash_template_arg (TREE_VEC_ELT (arg, i), val);
1731	return val;
1732	}
1733
1734	case TYPE_PACK_EXPANSION:
1735	case EXPR_PACK_EXPANSION:
1736	val = iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
1737	return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg), val);
1738
1739	case TYPE_ARGUMENT_PACK:
1740	case NONTYPE_ARGUMENT_PACK:
1741	return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
1742
1743	case TREE_LIST:
1744	for (; arg; arg = TREE_CHAIN (arg))
1745	val = iterative_hash_template_arg (TREE_VALUE (arg), val);
1746	return val;
1747
1748	case OVERLOAD:
1749	for (lkp_iterator iter (arg); iter; ++iter)
1750	val = iterative_hash_template_arg (*iter, val);
1751	return val;
1752
1753	case CONSTRUCTOR:
1754	{
1755	tree field, value;
1756	iterative_hash_template_arg (TREE_TYPE (arg), val);
1757	FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg), i, field, value)
1758	{
1759	val = iterative_hash_template_arg (field, val);
1760	val = iterative_hash_template_arg (value, val);
1761	}
1762	return val;
1763	}
1764
1765	case PARM_DECL:
1766	if (!DECL_ARTIFICIAL (arg))
1767	{
1768	val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
1769	val = iterative_hash_object (DECL_PARM_LEVEL (arg), val);
1770	}
1771	return iterative_hash_template_arg (TREE_TYPE (arg), val);
1772
1773	case TARGET_EXPR:
1774	return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
1775
1776	case PTRMEM_CST:
1777	val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
1778	return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
1779
1780	case TEMPLATE_PARM_INDEX:
1781	val = iterative_hash_template_arg
1782	(TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
1783	val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
1784	return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
1785
1786	case TRAIT_EXPR:
1787	val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
1788	val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
1789	return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
1790
1791	case BASELINK:
1792	val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
1793	val);
1794	return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
1795	val);
1796
1797	case MODOP_EXPR:
1798	val = iterative_hash_template_arg (TREE_OPERAND (arg, `0`), val);
1799	code = TREE_CODE (TREE_OPERAND (arg, `1`));
1800	val = iterative_hash_object (code, val);
1801	return iterative_hash_template_arg (TREE_OPERAND (arg, `2`), val);
1802
1803	case LAMBDA_EXPR:
1804	/ A lambda can't appear in a template arg, but don't crash on*
1805	erroneous input. /*
1806	gcc_assert (seen_error ());
1807	return val;
1808
1809	case CAST_EXPR:
1810	case IMPLICIT_CONV_EXPR:
1811	case STATIC_CAST_EXPR:
1812	case REINTERPRET_CAST_EXPR:
1813	case CONST_CAST_EXPR:
1814	case DYNAMIC_CAST_EXPR:
1815	case NEW_EXPR:
1816	val = iterative_hash_template_arg (TREE_TYPE (arg), val);
1817	/ Now hash operands as usual. /
1818	break;
1819
1820	default:
1821	break;
1822	}
1823
1824	switch (tclass)
1825	{
1826	case tcc_type:
1827	if (alias_template_specialization_p (arg))
1828	{
1829	// We want an alias specialization that survived strip_typedefs
1830	// to hash differently from its TYPE_CANONICAL, to avoid hash
1831	// collisions that compare as different in template_args_equal.
1832	// These could be dependent specializations that strip_typedefs
1833	// left alone, or untouched specializations because
1834	// coerce_template_parms returns the unconverted template
1835	// arguments if it sees incomplete argument packs.
1836	tree ti = TYPE_ALIAS_TEMPLATE_INFO (arg);
1837	return hash_tmpl_and_args (TI_TEMPLATE (ti), TI_ARGS (ti));
1838	}
1839	if (TYPE_CANONICAL (arg))
1840	return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg)),
1841	val);
1842	else if (TREE_CODE (arg) == DECLTYPE_TYPE)
1843	return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
1844	/ Otherwise just compare the types during lookup. /
1845	return val;
1846
1847	case tcc_declaration:
1848	case tcc_constant:
1849	return iterative_hash_expr (arg, val);
1850
1851	default:
1852	gcc_assert (IS_EXPR_CODE_CLASS (tclass));
1853	{
1854	unsigned n = cp_tree_operand_length (arg);
1855	for (i = `0`; i < n; ++i)
1856	val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
1857	return val;
1858	}
1859	}
1860	gcc_unreachable ();
1861	return `0`;
1862	}
1863
1864	/ Unregister the specialization SPEC as a specialization of TMPL.*
1865	Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1866	if the SPEC was listed as a specialization of TMPL.
1867
1868	Note that SPEC has been ggc_freed, so we can't look inside it. /*
1869
1870	bool
1871	reregister_specialization (tree spec, tree tinfo, tree new_spec)
1872	{
1873	spec_entry *entry;
1874	spec_entry elt;
1875
1876	elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
1877	elt.args = TI_ARGS (tinfo);
1878	elt.spec = NULL_TREE;
1879
1880	entry = decl_specializations->find (&elt);
1881	if (entry != NULL)
1882	{
1883	gcc_assert (entry->spec == spec \|\| entry->spec == new_spec);
1884	gcc_assert (new_spec != NULL_TREE);
1885	entry->spec = new_spec;
1886	return `1`;
1887	}
1888
1889	return `0`;
1890	}
1891
1892	/ Like register_specialization, but for local declarations. We are*
1893	registering SPEC, an instantiation of TMPL. /*
1894
1895	void
1896	register_local_specialization (tree spec, tree tmpl)
1897	{
1898	gcc_assert (tmpl != spec);
1899	local_specializations->put (tmpl, spec);
1900	}
1901
1902	/ TYPE is a class type. Returns true if TYPE is an explicitly*
1903	specialized class. /*
1904
1905	bool
1906	explicit_class_specialization_p (tree type)
1907	{
1908	if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1909	return false;
1910	return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1911	}
1912
1913	/ Print the list of functions at FNS, going through all the overloads*
1914	for each element of the list. Alternatively, FNS can not be a
1915	TREE_LIST, in which case it will be printed together with all the
1916	overloads.
1917
1918	MORE and STR should respectively be FALSE and NULL when the function*
1919	is called from the outside. They are used internally on recursive
1920	calls. print_candidates manages the two parameters and leaves NULL
1921	in STR when it ends. /
1922
1923	static void
1924	print_candidates_1 (tree fns, char *str, bool* more = false)
1925	{
1926	if (TREE_CODE (fns) == TREE_LIST)
1927	for (; fns; fns = TREE_CHAIN (fns))
1928	print_candidates_1 (TREE_VALUE (fns), str, more \|\| TREE_CHAIN (fns));
1929	else
1930	for (lkp_iterator iter (fns); iter;)
1931	{
1932	tree cand = *iter;
1933	++iter;
1934
1935	const char pfx = str;
1936	if (!pfx)
1937	{
1938	if (more \|\| iter)
1939	pfx = _("candidates are:");
1940	else
1941	pfx = _("candidate is:");
1942	*str = get_spaces (pfx);
1943	}
1944	inform (DECL_SOURCE_LOCATION (cand), "%s %#qD", pfx, cand);
1945	}
1946	}
1947
1948	/ Print the list of candidate FNS in an error message. FNS can also*
1949	be a TREE_LIST of non-functions in the case of an ambiguous lookup. /*
1950
1951	void
1952	print_candidates (tree fns)
1953	{
1954	char *str = NULL;
1955	print_candidates_1 (fns, &str);
1956	free (str);
1957	}
1958
1959	/ Get a (possibly) constrained template declaration for the*
1960	purpose of ordering candidates. /*
1961	static tree
1962	get_template_for_ordering (tree list)
1963	{
1964	gcc_assert (TREE_CODE (list) == TREE_LIST);
1965	tree f = TREE_VALUE (list);
1966	if (tree ti = DECL_TEMPLATE_INFO (f))
1967	return TI_TEMPLATE (ti);
1968	return f;
1969	}
1970
1971	/ Among candidates having the same signature, return the*
1972	most constrained or NULL_TREE if there is no best candidate.
1973	If the signatures of candidates vary (e.g., template
1974	specialization vs. member function), then there can be no
1975	most constrained.
1976
1977	Note that we don't compare constraints on the functions
1978	themselves, but rather those of their templates. /*
1979	static tree
1980	most_constrained_function (tree candidates)
1981	{
1982	// Try to find the best candidate in a first pass.
1983	tree champ = candidates;
1984	for (tree c = TREE_CHAIN (champ); c; c = TREE_CHAIN (c))
1985	{
1986	int winner = more_constrained (get_template_for_ordering (champ),
1987	get_template_for_ordering (c));
1988	if (winner == -`1`)
1989	champ = c; // The candidate is more constrained
1990	else if (winner == `0`)
1991	return NULL_TREE; // Neither is more constrained
1992	}
1993
1994	// Verify that the champ is better than previous candidates.
1995	for (tree c = candidates; c != champ; c = TREE_CHAIN (c)) {
1996	if (!more_constrained (get_template_for_ordering (champ),
1997	get_template_for_ordering (c)))
1998	return NULL_TREE;
1999	}
2000
2001	return champ;
2002	}
2003
2004
2005	/ Returns the template (one of the functions given by TEMPLATE_ID)*
2006	which can be specialized to match the indicated DECL with the
2007	explicit template args given in TEMPLATE_ID. The DECL may be
2008	NULL_TREE if none is available. In that case, the functions in
2009	TEMPLATE_ID are non-members.
2010
2011	If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2012	specialization of a member template.
2013
2014	The TEMPLATE_COUNT is the number of references to qualifying
2015	template classes that appeared in the name of the function. See
2016	check_explicit_specialization for a more accurate description.
2017
2018	TSK indicates what kind of template declaration (if any) is being
2019	declared. TSK_TEMPLATE indicates that the declaration given by
2020	DECL, though a FUNCTION_DECL, has template parameters, and is
2021	therefore a template function.
2022
2023	The template args (those explicitly specified and those deduced)
2024	are output in a newly created vector TARGS_OUT.*
2025
2026	If it is impossible to determine the result, an error message is
2027	issued. The error_mark_node is returned to indicate failure. /*
2028
2029	static tree
2030	determine_specialization (tree template_id,
2031	tree decl,
2032	tree* targs_out,
2033	int need_member_template,
2034	int template_count,
2035	tmpl_spec_kind tsk)
2036	{
2037	tree fns;
2038	tree targs;
2039	tree explicit_targs;
2040	tree candidates = NULL_TREE;
2041
2042	/ A TREE_LIST of templates of which DECL may be a specialization.*
2043	The TREE_VALUE of each node is a TEMPLATE_DECL. The
2044	corresponding TREE_PURPOSE is the set of template arguments that,
2045	when used to instantiate the template, would produce a function
2046	with the signature of DECL. /*
2047	tree templates = NULL_TREE;
2048	int header_count;
2049	cp_binding_level *b;
2050
2051	*targs_out = NULL_TREE;
2052
2053	if (template_id == error_mark_node \|\| decl == error_mark_node)
2054	return error_mark_node;
2055
2056	/ We shouldn't be specializing a member template of an*
2057	unspecialized class template; we already gave an error in
2058	check_specialization_scope, now avoid crashing. /*
2059	if (template_count && DECL_CLASS_SCOPE_P (decl)
2060	&& template_class_depth (DECL_CONTEXT (decl)) > `0`)
2061	{
2062	gcc_assert (errorcount);
2063	return error_mark_node;
2064	}
2065
2066	fns = TREE_OPERAND (template_id, `0`);
2067	explicit_targs = TREE_OPERAND (template_id, `1`);
2068
2069	if (fns == error_mark_node)
2070	return error_mark_node;
2071
2072	/ Check for baselinks. /
2073	if (BASELINK_P (fns))
2074	fns = BASELINK_FUNCTIONS (fns);
2075
2076	if (TREE_CODE (decl) == FUNCTION_DECL && !is_overloaded_fn (fns))
2077	{
2078	error ("%qD is not a function template", fns);
2079	return error_mark_node;
2080	}
2081	else if (VAR_P (decl) && !variable_template_p (fns))
2082	{
2083	error ("%qD is not a variable template", fns);
2084	return error_mark_node;
2085	}
2086
2087	/ Count the number of template headers specified for this*
2088	specialization. /*
2089	header_count = `0`;
2090	for (b = current_binding_level;
2091	b->kind == sk_template_parms;
2092	b = b->level_chain)
2093	++header_count;
2094
2095	tree orig_fns = fns;
2096
2097	if (variable_template_p (fns))
2098	{
2099	tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns));
2100	targs = coerce_template_parms (parms, explicit_targs, fns,
2101	tf_warning_or_error,
2102	/req_all/true, /use_defarg/true);
2103	if (targs != error_mark_node)
2104	templates = tree_cons (targs, fns, templates);
2105	}
2106	else for (lkp_iterator iter (fns); iter; ++iter)
2107	{
2108	tree fn = *iter;
2109
2110	if (TREE_CODE (fn) == TEMPLATE_DECL)
2111	{
2112	tree decl_arg_types;
2113	tree fn_arg_types;
2114	tree insttype;
2115
2116	/ In case of explicit specialization, we need to check if*
2117	the number of template headers appearing in the specialization
2118	is correct. This is usually done in check_explicit_specialization,
2119	but the check done there cannot be exhaustive when specializing
2120	member functions. Consider the following code:
2121
2122	template <> void A<int>::f(int);
2123	template <> template <> void A<int>::f(int);
2124
2125	Assuming that A<int> is not itself an explicit specialization
2126	already, the first line specializes "f" which is a non-template
2127	member function, whilst the second line specializes "f" which
2128	is a template member function. So both lines are syntactically
2129	correct, and check_explicit_specialization does not reject
2130	them.
2131
2132	Here, we can do better, as we are matching the specialization
2133	against the declarations. We count the number of template
2134	headers, and we check if they match TEMPLATE_COUNT + 1
2135	(TEMPLATE_COUNT is the number of qualifying template classes,
2136	plus there must be another header for the member template
2137	itself).
2138
2139	Notice that if header_count is zero, this is not a
2140	specialization but rather a template instantiation, so there
2141	is no check we can perform here. /*
2142	if (header_count && header_count != template_count + `1`)
2143	continue;
2144
2145	/ Check that the number of template arguments at the*
2146	innermost level for DECL is the same as for FN. /*
2147	if (current_binding_level->kind == sk_template_parms
2148	&& !current_binding_level->explicit_spec_p
2149	&& (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
2150	!= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2151	(current_template_parms))))
2152	continue;
2153
2154	/ DECL might be a specialization of FN. /
2155	decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
2156	fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
2157
2158	/ For a non-static member function, we need to make sure*
2159	that the const qualification is the same. Since
2160	get_bindings does not try to merge the "this" parameter,
2161	we must do the comparison explicitly. /*
2162	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
2163	&& !same_type_p (TREE_VALUE (fn_arg_types),
2164	TREE_VALUE (decl_arg_types)))
2165	continue;
2166
2167	/ Skip the "this" parameter and, for constructors of*
2168	classes with virtual bases, the VTT parameter. A
2169	full specialization of a constructor will have a VTT
2170	parameter, but a template never will. /*
2171	decl_arg_types
2172	= skip_artificial_parms_for (decl, decl_arg_types);
2173	fn_arg_types
2174	= skip_artificial_parms_for (fn, fn_arg_types);
2175
2176	/ Function templates cannot be specializations; there are*
2177	no partial specializations of functions. Therefore, if
2178	the type of DECL does not match FN, there is no
2179	match.
2180
2181	Note that it should never be the case that we have both
2182	candidates added here, and for regular member functions
2183	below. /*
2184	if (tsk == tsk_template)
2185	{
2186	if (compparms (fn_arg_types, decl_arg_types))
2187	candidates = tree_cons (NULL_TREE, fn, candidates);
2188	continue;
2189	}
2190
2191	/ See whether this function might be a specialization of this*
2192	template. Suppress access control because we might be trying
2193	to make this specialization a friend, and we have already done
2194	access control for the declaration of the specialization. /*
2195	push_deferring_access_checks (dk_no_check);
2196	targs = get_bindings (fn, decl, explicit_targs, /check_ret=/true);
2197	pop_deferring_access_checks ();
2198
2199	if (!targs)
2200	/ We cannot deduce template arguments that when used to*
2201	specialize TMPL will produce DECL. /*
2202	continue;
2203
2204	/ Remove, from the set of candidates, all those functions*
2205	whose constraints are not satisfied. /*
2206	if (flag_concepts && !constraints_satisfied_p (fn, targs))
2207	continue;
2208
2209	// Then, try to form the new function type.
2210	insttype = tsubst (TREE_TYPE (fn), targs, tf_fndecl_type, NULL_TREE);
2211	if (insttype == error_mark_node)
2212	continue;
2213	fn_arg_types
2214	= skip_artificial_parms_for (fn, TYPE_ARG_TYPES (insttype));
2215	if (!compparms (fn_arg_types, decl_arg_types))
2216	continue;
2217
2218	/ Save this template, and the arguments deduced. /
2219	templates = tree_cons (targs, fn, templates);
2220	}
2221	else if (need_member_template)
2222	/ FN is an ordinary member function, and we need a*
2223	specialization of a member template. /*
2224	;
2225	else if (TREE_CODE (fn) != FUNCTION_DECL)
2226	/ We can get IDENTIFIER_NODEs here in certain erroneous*
2227	cases. /*
2228	;
2229	else if (!DECL_FUNCTION_MEMBER_P (fn))
2230	/ This is just an ordinary non-member function. Nothing can*
2231	be a specialization of that. /*
2232	;
2233	else if (DECL_ARTIFICIAL (fn))
2234	/ Cannot specialize functions that are created implicitly. /
2235	;
2236	else
2237	{
2238	tree decl_arg_types;
2239
2240	/ This is an ordinary member function. However, since*
2241	we're here, we can assume its enclosing class is a
2242	template class. For example,
2243
2244	template <typename T> struct S { void f(); };
2245	template <> void S<int>::f() {}
2246
2247	Here, S<int>::f is a non-template, but S<int> is a
2248	template class. If FN has the same type as DECL, we
2249	might be in business. /*
2250
2251	if (!DECL_TEMPLATE_INFO (fn))
2252	/ Its enclosing class is an explicit specialization*
2253	of a template class. This is not a candidate. /*
2254	continue;
2255
2256	if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
2257	TREE_TYPE (TREE_TYPE (fn))))
2258	/ The return types differ. /
2259	continue;
2260
2261	/ Adjust the type of DECL in case FN is a static member. /
2262	decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
2263	if (DECL_STATIC_FUNCTION_P (fn)
2264	&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2265	decl_arg_types = TREE_CHAIN (decl_arg_types);
2266
2267	if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2268	decl_arg_types))
2269	continue;
2270
2271	// If the deduced arguments do not satisfy the constraints,
2272	// this is not a candidate.
2273	if (flag_concepts && !constraints_satisfied_p (fn))
2274	continue;
2275
2276	// Add the candidate.
2277	candidates = tree_cons (NULL_TREE, fn, candidates);
2278	}
2279	}
2280
2281	if (templates && TREE_CHAIN (templates))
2282	{
2283	/ We have:*
2284
2285	[temp.expl.spec]
2286
2287	It is possible for a specialization with a given function
2288	signature to be instantiated from more than one function
2289	template. In such cases, explicit specification of the
2290	template arguments must be used to uniquely identify the
2291	function template specialization being specialized.
2292
2293	Note that here, there's no suggestion that we're supposed to
2294	determine which of the candidate templates is most
2295	specialized. However, we, also have:
2296
2297	[temp.func.order]
2298
2299	Partial ordering of overloaded function template
2300	declarations is used in the following contexts to select
2301	the function template to which a function template
2302	specialization refers:
2303
2304	-- when an explicit specialization refers to a function
2305	template.
2306
2307	So, we do use the partial ordering rules, at least for now.
2308	This extension can only serve to make invalid programs valid,
2309	so it's safe. And, there is strong anecdotal evidence that
2310	the committee intended the partial ordering rules to apply;
2311	the EDG front end has that behavior, and John Spicer claims
2312	that the committee simply forgot to delete the wording in
2313	[temp.expl.spec]. /*
2314	tree tmpl = most_specialized_instantiation (templates);
2315	if (tmpl != error_mark_node)
2316	{
2317	templates = tmpl;
2318	TREE_CHAIN (templates) = NULL_TREE;
2319	}
2320	}
2321
2322	// Concepts allows multiple declarations of member functions
2323	// with the same signature. Like above, we need to rely on
2324	// on the partial ordering of those candidates to determine which
2325	// is the best.
2326	if (flag_concepts && candidates && TREE_CHAIN (candidates))
2327	{
2328	if (tree cand = most_constrained_function (candidates))
2329	{
2330	candidates = cand;
2331	TREE_CHAIN (cand) = NULL_TREE;
2332	}
2333	}
2334
2335	if (templates == NULL_TREE && candidates == NULL_TREE)
2336	{
2337	error ("template-id %qD for %q+D does not match any template "
2338	"declaration", template_id, decl);
2339	if (header_count && header_count != template_count + `1`)
2340	inform (input_location, "saw %d %<template<>%>, need %d for "
2341	"specializing a member function template",
2342	header_count, template_count + `1`);
2343	else
2344	print_candidates (orig_fns);
2345	return error_mark_node;
2346	}
2347	else if ((templates && TREE_CHAIN (templates))
2348	\|\| (candidates && TREE_CHAIN (candidates))
2349	\|\| (templates && candidates))
2350	{
2351	error ("ambiguous template specialization %qD for %q+D",
2352	template_id, decl);
2353	candidates = chainon (candidates, templates);
2354	print_candidates (candidates);
2355	return error_mark_node;
2356	}
2357
2358	/ We have one, and exactly one, match. /
2359	if (candidates)
2360	{
2361	tree fn = TREE_VALUE (candidates);
2362	*targs_out = copy_node (DECL_TI_ARGS (fn));
2363
2364	// Propagate the candidate's constraints to the declaration.
2365	set_constraints (decl, get_constraints (fn));
2366
2367	/ DECL is a re-declaration or partial instantiation of a template*
2368	function. /*
2369	if (TREE_CODE (fn) == TEMPLATE_DECL)
2370	return fn;
2371	/ It was a specialization of an ordinary member function in a*
2372	template class. /*
2373	return DECL_TI_TEMPLATE (fn);
2374	}
2375
2376	/ It was a specialization of a template. /
2377	targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
2378	if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
2379	{
2380	*targs_out = copy_node (targs);
2381	SET_TMPL_ARGS_LEVEL (*targs_out,
2382	TMPL_ARGS_DEPTH (*targs_out),
2383	TREE_PURPOSE (templates));
2384	}
2385	else
2386	*targs_out = TREE_PURPOSE (templates);
2387	return TREE_VALUE (templates);
2388	}
2389
2390	/ Returns a chain of parameter types, exactly like the SPEC_TYPES,*
2391	but with the default argument values filled in from those in the
2392	TMPL_TYPES. /*
2393
2394	static tree
2395	copy_default_args_to_explicit_spec_1 (tree spec_types,
2396	tree tmpl_types)
2397	{
2398	tree new_spec_types;
2399
2400	if (!spec_types)
2401	return NULL_TREE;
2402
2403	if (spec_types == void_list_node)
2404	return void_list_node;
2405
2406	/ Substitute into the rest of the list. /
2407	new_spec_types =
2408	copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
2409	TREE_CHAIN (tmpl_types));
2410
2411	/ Add the default argument for this parameter. /
2412	return hash_tree_cons (TREE_PURPOSE (tmpl_types),
2413	TREE_VALUE (spec_types),
2414	new_spec_types);
2415	}
2416
2417	/ DECL is an explicit specialization. Replicate default arguments*
2418	from the template it specializes. (That way, code like:
2419
2420	template <class T> void f(T = 3);
2421	template <> void f(double);
2422	void g () { f (); }
2423
2424	works, as required.) An alternative approach would be to look up
2425	the correct default arguments at the call-site, but this approach
2426	is consistent with how implicit instantiations are handled. /*
2427
2428	static void
2429	copy_default_args_to_explicit_spec (tree decl)
2430	{
2431	tree tmpl;
2432	tree spec_types;
2433	tree tmpl_types;
2434	tree new_spec_types;
2435	tree old_type;
2436	tree new_type;
2437	tree t;
2438	tree object_type = NULL_TREE;
2439	tree in_charge = NULL_TREE;
2440	tree vtt = NULL_TREE;
2441
2442	/ See if there's anything we need to do. /
2443	tmpl = DECL_TI_TEMPLATE (decl);
2444	tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
2445	for (t = tmpl_types; t; t = TREE_CHAIN (t))
2446	if (TREE_PURPOSE (t))
2447	break;
2448	if (!t)
2449	return;
2450
2451	old_type = TREE_TYPE (decl);
2452	spec_types = TYPE_ARG_TYPES (old_type);
2453
2454	if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2455	{
2456	/ Remove the this pointer, but remember the object's type for*
2457	CV quals. /*
2458	object_type = TREE_TYPE (TREE_VALUE (spec_types));
2459	spec_types = TREE_CHAIN (spec_types);
2460	tmpl_types = TREE_CHAIN (tmpl_types);
2461
2462	if (DECL_HAS_IN_CHARGE_PARM_P (decl))
2463	{
2464	/ DECL may contain more parameters than TMPL due to the extra*
2465	in-charge parameter in constructors and destructors. /*
2466	in_charge = spec_types;
2467	spec_types = TREE_CHAIN (spec_types);
2468	}
2469	if (DECL_HAS_VTT_PARM_P (decl))
2470	{
2471	vtt = spec_types;
2472	spec_types = TREE_CHAIN (spec_types);
2473	}
2474	}
2475
2476	/ Compute the merged default arguments. /
2477	new_spec_types =
2478	copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
2479
2480	/ Compute the new FUNCTION_TYPE. /
2481	if (object_type)
2482	{
2483	if (vtt)
2484	new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
2485	TREE_VALUE (vtt),
2486	new_spec_types);
2487
2488	if (in_charge)
2489	/ Put the in-charge parameter back. /
2490	new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
2491	TREE_VALUE (in_charge),
2492	new_spec_types);
2493
2494	new_type = build_method_type_directly (object_type,
2495	TREE_TYPE (old_type),
2496	new_spec_types);
2497	}
2498	else
2499	new_type = build_function_type (TREE_TYPE (old_type),
2500	new_spec_types);
2501	new_type = cp_build_type_attribute_variant (new_type,
2502	TYPE_ATTRIBUTES (old_type));
2503	new_type = build_exception_variant (new_type,
2504	TYPE_RAISES_EXCEPTIONS (old_type));
2505
2506	if (TYPE_HAS_LATE_RETURN_TYPE (old_type))
2507	TYPE_HAS_LATE_RETURN_TYPE (new_type) = `1`;
2508
2509	TREE_TYPE (decl) = new_type;
2510	}
2511
2512	/ Return the number of template headers we expect to see for a definition*
2513	or specialization of CTYPE or one of its non-template members. /*
2514
2515	int
2516	num_template_headers_for_class (tree ctype)
2517	{
2518	int num_templates = `0`;
2519
2520	while (ctype && CLASS_TYPE_P (ctype))
2521	{
2522	/ You're supposed to have one `template <...>' for every*
2523	template class, but you don't need one for a full
2524	specialization. For example:
2525
2526	template <class T> struct S{};
2527	template <> struct S<int> { void f(); };
2528	void S<int>::f () {}
2529
2530	is correct; there shouldn't be a `template <>' for the
2531	definition of `S<int>::f'. /*
2532	if (!CLASSTYPE_TEMPLATE_INFO (ctype))
2533	/ If CTYPE does not have template information of any*
2534	kind, then it is not a template, nor is it nested
2535	within a template. /*
2536	break;
2537	if (explicit_class_specialization_p (ctype))
2538	break;
2539	if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype)))
2540	++num_templates;
2541
2542	ctype = TYPE_CONTEXT (ctype);
2543	}
2544
2545	return num_templates;
2546	}
2547
2548	/ Do a simple sanity check on the template headers that precede the*
2549	variable declaration DECL. /*
2550
2551	void
2552	check_template_variable (tree decl)
2553	{
2554	tree ctx = CP_DECL_CONTEXT (decl);
2555	int wanted = num_template_headers_for_class (ctx);
2556	if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
2557	&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
2558	{
2559	if (cxx_dialect < cxx14)
2560	pedwarn (DECL_SOURCE_LOCATION (decl), `0`,
2561	"variable templates only available with "
2562	"-std=c++14 or -std=gnu++14");
2563
2564	// Namespace-scope variable templates should have a template header.
2565	++wanted;
2566	}
2567	if (template_header_count > wanted)
2568	{
2569	bool warned = pedwarn (DECL_SOURCE_LOCATION (decl), `0`,
2570	"too many template headers for %qD "
2571	"(should be %d)",
2572	decl, wanted);
2573	if (warned && CLASS_TYPE_P (ctx)
2574	&& CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx))
2575	inform (DECL_SOURCE_LOCATION (decl),
2576	"members of an explicitly specialized class are defined "
2577	"without a template header");
2578	}
2579	}
2580
2581	/ An explicit specialization whose declarator-id or class-head-name is not*
2582	qualified shall be declared in the nearest enclosing namespace of the
2583	template, or, if the namespace is inline (7.3.1), any namespace from its
2584	enclosing namespace set.
2585
2586	If the name declared in the explicit instantiation is an unqualified name,
2587	the explicit instantiation shall appear in the namespace where its template
2588	is declared or, if that namespace is inline (7.3.1), any namespace from its
2589	enclosing namespace set. /*
2590
2591	void
2592	check_unqualified_spec_or_inst (tree t, location_t loc)
2593	{
2594	tree tmpl = most_general_template (t);
2595	if (DECL_NAMESPACE_SCOPE_P (tmpl)
2596	&& !is_nested_namespace (current_namespace,
2597	CP_DECL_CONTEXT (tmpl), true))
2598	{
2599	if (processing_specialization)
2600	permerror (loc, "explicit specialization of %qD outside its "
2601	"namespace must use a nested-name-specifier", tmpl);
2602	else if (processing_explicit_instantiation
2603	&& cxx_dialect >= cxx11)
2604	/ This was allowed in C++98, so only pedwarn. /
2605	pedwarn (loc, OPT_Wpedantic, "explicit instantiation of %qD "
2606	"outside its namespace must use a nested-name-"
2607	"specifier", tmpl);
2608	}
2609	}
2610
2611	/ Check to see if the function just declared, as indicated in*
2612	DECLARATOR, and in DECL, is a specialization of a function
2613	template. We may also discover that the declaration is an explicit
2614	instantiation at this point.
2615
2616	Returns DECL, or an equivalent declaration that should be used
2617	instead if all goes well. Issues an error message if something is
2618	amiss. Returns error_mark_node if the error is not easily
2619	recoverable.
2620
2621	FLAGS is a bitmask consisting of the following flags:
2622
2623	2: The function has a definition.
2624	4: The function is a friend.
2625
2626	The TEMPLATE_COUNT is the number of references to qualifying
2627	template classes that appeared in the name of the function. For
2628	example, in
2629
2630	template <class T> struct S { void f(); };
2631	void S<int>::f();
2632
2633	the TEMPLATE_COUNT would be 1. However, explicitly specialized
2634	classes are not counted in the TEMPLATE_COUNT, so that in
2635
2636	template <class T> struct S {};
2637	template <> struct S<int> { void f(); }
2638	template <> void S<int>::f();
2639
2640	the TEMPLATE_COUNT would be 0. (Note that this declaration is
2641	invalid; there should be no template <>.)
2642
2643	If the function is a specialization, it is marked as such via
2644	DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2645	is set up correctly, and it is added to the list of specializations
2646	for that template. /*
2647
2648	tree
2649	check_explicit_specialization (tree declarator,
2650	tree decl,
2651	int template_count,
2652	int flags)
2653	{
2654	int have_def = flags & `2`;
2655	int is_friend = flags & `4`;
2656	bool is_concept = flags & `8`;
2657	int specialization = `0`;
2658	int explicit_instantiation = `0`;
2659	int member_specialization = `0`;
2660	tree ctype = DECL_CLASS_CONTEXT (decl);
2661	tree dname = DECL_NAME (decl);
2662	tmpl_spec_kind tsk;
2663
2664	if (is_friend)
2665	{
2666	if (!processing_specialization)
2667	tsk = tsk_none;
2668	else
2669	tsk = tsk_excessive_parms;
2670	}
2671	else
2672	tsk = current_tmpl_spec_kind (template_count);
2673
2674	switch (tsk)
2675	{
2676	case tsk_none:
2677	if (processing_specialization && !VAR_P (decl))
2678	{
2679	specialization = `1`;
2680	SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2681	}
2682	else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2683	{
2684	if (is_friend)
2685	/ This could be something like:*
2686
2687	template <class T> void f(T);
2688	class S { friend void f<>(int); } /*
2689	specialization = `1`;
2690	else
2691	{
2692	/ This case handles bogus declarations like template <>*
2693	template <class T> void f<int>(); /*
2694
2695	error ("template-id %qD in declaration of primary template",
2696	declarator);
2697	return decl;
2698	}
2699	}
2700	break;
2701
2702	case tsk_invalid_member_spec:
2703	/ The error has already been reported in*
2704	check_specialization_scope. /*
2705	return error_mark_node;
2706
2707	case tsk_invalid_expl_inst:
2708	error ("template parameter list used in explicit instantiation");
2709
2710	/ Fall through. /
2711
2712	case tsk_expl_inst:
2713	if (have_def)
2714	error ("definition provided for explicit instantiation");
2715
2716	explicit_instantiation = `1`;
2717	break;
2718
2719	case tsk_excessive_parms:
2720	case tsk_insufficient_parms:
2721	if (tsk == tsk_excessive_parms)
2722	error ("too many template parameter lists in declaration of %qD",
2723	decl);
2724	else if (template_header_count)
2725	error("too few template parameter lists in declaration of %qD", decl);
2726	else
2727	error("explicit specialization of %qD must be introduced by "
2728	"%<template <>%>", decl);
2729
2730	/ Fall through. /
2731	case tsk_expl_spec:
2732	if (is_concept)
2733	error ("explicit specialization declared %<concept%>");
2734
2735	if (VAR_P (decl) && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2736	/ In cases like template<> constexpr bool v = true;*
2737	We'll give an error in check_template_variable. /*
2738	break;
2739
2740	SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2741	if (ctype)
2742	member_specialization = `1`;
2743	else
2744	specialization = `1`;
2745	break;
2746
2747	case tsk_template:
2748	if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2749	{
2750	/ This case handles bogus declarations like template <>*
2751	template <class T> void f<int>(); /*
2752
2753	if (!uses_template_parms (declarator))
2754	error ("template-id %qD in declaration of primary template",
2755	declarator);
2756	else if (variable_template_p (TREE_OPERAND (declarator, `0`)))
2757	{
2758	/ Partial specialization of variable template. /
2759	SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2760	specialization = `1`;
2761	goto ok;
2762	}
2763	else if (cxx_dialect < cxx14)
2764	error ("non-type partial specialization %qD "
2765	"is not allowed", declarator);
2766	else
2767	error ("non-class, non-variable partial specialization %qD "
2768	"is not allowed", declarator);
2769	return decl;
2770	ok:;
2771	}
2772
2773	if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2774	/ This is a specialization of a member template, without*
2775	specialization the containing class. Something like:
2776
2777	template <class T> struct S {
2778	template <class U> void f (U);
2779	};
2780	template <> template <class U> void S<int>::f(U) {}
2781
2782	That's a specialization -- but of the entire template. /*
2783	specialization = `1`;
2784	break;
2785
2786	default:
2787	gcc_unreachable ();
2788	}
2789
2790	if ((specialization \|\| member_specialization)
2791	/ This doesn't apply to variable templates. /
2792	&& (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE
2793	\|\| TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE))
2794	{
2795	tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2796	for (; t; t = TREE_CHAIN (t))
2797	if (TREE_PURPOSE (t))
2798	{
2799	permerror (input_location,
2800	"default argument specified in explicit specialization");
2801	break;
2802	}
2803	}
2804
2805	if (specialization \|\| member_specialization \|\| explicit_instantiation)
2806	{
2807	tree tmpl = NULL_TREE;
2808	tree targs = NULL_TREE;
2809	bool was_template_id = (TREE_CODE (declarator) == TEMPLATE_ID_EXPR);
2810
2811	/ Make sure that the declarator is a TEMPLATE_ID_EXPR. /
2812	if (!was_template_id)
2813	{
2814	tree fns;
2815
2816	gcc_assert (identifier_p (declarator));
2817	if (ctype)
2818	fns = dname;
2819	else
2820	{
2821	/ If there is no class context, the explicit instantiation*
2822	must be at namespace scope. /*
2823	gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2824
2825	/ Find the namespace binding, using the declaration*
2826	context. /*
2827	fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2828	false, true);
2829	if (fns == error_mark_node)
2830	/ If lookup fails, look for a friend declaration so we can*
2831	give a better diagnostic. /*
2832	fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2833	/type/false, /complain/true,
2834	/hidden/true);
2835
2836	if (fns == error_mark_node \|\| !is_overloaded_fn (fns))
2837	{
2838	error ("%qD is not a template function", dname);
2839	fns = error_mark_node;
2840	}
2841	}
2842
2843	declarator = lookup_template_function (fns, NULL_TREE);
2844	}
2845
2846	if (declarator == error_mark_node)
2847	return error_mark_node;
2848
2849	if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2850	{
2851	if (!explicit_instantiation)
2852	/ A specialization in class scope. This is invalid,*
2853	but the error will already have been flagged by
2854	check_specialization_scope. /*
2855	return error_mark_node;
2856	else
2857	{
2858	/ It's not valid to write an explicit instantiation in*
2859	class scope, e.g.:
2860
2861	class C { template void f(); }
2862
2863	This case is caught by the parser. However, on
2864	something like:
2865
2866	template class C { void f(); };
2867
2868	(which is invalid) we can get here. The error will be
2869	issued later. /*
2870	;
2871	}
2872
2873	return decl;
2874	}
2875	else if (ctype != NULL_TREE
2876	&& (identifier_p (TREE_OPERAND (declarator, `0`))))
2877	{
2878	// We'll match variable templates in start_decl.
2879	if (VAR_P (decl))
2880	return decl;
2881
2882	/ Find the list of functions in ctype that have the same*
2883	name as the declared function. /*
2884	tree name = TREE_OPERAND (declarator, `0`);
2885
2886	if (constructor_name_p (name, ctype))
2887	{
2888	if (DECL_CONSTRUCTOR_P (decl)
2889	? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
2890	: !CLASSTYPE_DESTRUCTOR (ctype))
2891	{
2892	/ From [temp.expl.spec]:*
2893
2894	If such an explicit specialization for the member
2895	of a class template names an implicitly-declared
2896	special member function (clause _special_), the
2897	program is ill-formed.
2898
2899	Similar language is found in [temp.explicit]. /*
2900	error ("specialization of implicitly-declared special member function");
2901	return error_mark_node;
2902	}
2903
2904	name = DECL_NAME (decl);
2905	}
2906
2907	/ For a type-conversion operator, We might be looking for*
2908	`operator int' which will be a specialization of
2909	`operator T'. Grab all the conversion operators, and
2910	then select from them. /*
2911	tree fns = get_class_binding (ctype, IDENTIFIER_CONV_OP_P (name)
2912	? conv_op_identifier : name);
2913
2914	if (fns == NULL_TREE)
2915	{
2916	error ("no member function %qD declared in %qT", name, ctype);
2917	return error_mark_node;
2918	}
2919	else
2920	TREE_OPERAND (declarator, `0`) = fns;
2921	}
2922
2923	/ Figure out what exactly is being specialized at this point.*
2924	Note that for an explicit instantiation, even one for a
2925	member function, we cannot tell a priori whether the
2926	instantiation is for a member template, or just a member
2927	function of a template class. Even if a member template is
2928	being instantiated, the member template arguments may be
2929	elided if they can be deduced from the rest of the
2930	declaration. /*
2931	tmpl = determine_specialization (declarator, decl,
2932	&targs,
2933	member_specialization,
2934	template_count,
2935	tsk);
2936
2937	if (!tmpl \|\| tmpl == error_mark_node)
2938	/ We couldn't figure out what this declaration was*
2939	specializing. /*
2940	return error_mark_node;
2941	else
2942	{
2943	if (TREE_CODE (decl) == FUNCTION_DECL
2944	&& DECL_HIDDEN_FRIEND_P (tmpl))
2945	{
2946	if (pedwarn (DECL_SOURCE_LOCATION (decl), `0`,
2947	"friend declaration %qD is not visible to "
2948	"explicit specialization", tmpl))
2949	inform (DECL_SOURCE_LOCATION (tmpl),
2950	"friend declaration here");
2951	}
2952	else if (!ctype && !is_friend
2953	&& CP_DECL_CONTEXT (decl) == current_namespace)
2954	check_unqualified_spec_or_inst (tmpl, DECL_SOURCE_LOCATION (decl));
2955
2956	tree gen_tmpl = most_general_template (tmpl);
2957
2958	if (explicit_instantiation)
2959	{
2960	/ We don't set DECL_EXPLICIT_INSTANTIATION here; that*
2961	is done by do_decl_instantiation later. /*
2962
2963	int arg_depth = TMPL_ARGS_DEPTH (targs);
2964	int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2965
2966	if (arg_depth > parm_depth)
2967	{
2968	/ If TMPL is not the most general template (for*
2969	example, if TMPL is a friend template that is
2970	injected into namespace scope), then there will
2971	be too many levels of TARGS. Remove some of them
2972	here. /*
2973	int i;
2974	tree new_targs;
2975
2976	new_targs = make_tree_vec (parm_depth);
2977	for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2978	TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2979	= TREE_VEC_ELT (targs, i);
2980	targs = new_targs;
2981	}
2982
2983	return instantiate_template (tmpl, targs, tf_error);
2984	}
2985
2986	/ If we thought that the DECL was a member function, but it*
2987	turns out to be specializing a static member function,
2988	make DECL a static member function as well. /*
2989	if (DECL_FUNCTION_TEMPLATE_P (tmpl)
2990	&& DECL_STATIC_FUNCTION_P (tmpl)
2991	&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2992	revert_static_member_fn (decl);
2993
2994	/ If this is a specialization of a member template of a*
2995	template class, we want to return the TEMPLATE_DECL, not
2996	the specialization of it. /*
2997	if (tsk == tsk_template && !was_template_id)
2998	{
2999	tree result = DECL_TEMPLATE_RESULT (tmpl);
3000	SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3001	DECL_INITIAL (result) = NULL_TREE;
3002	if (have_def)
3003	{
3004	tree parm;
3005	DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
3006	DECL_SOURCE_LOCATION (result)
3007	= DECL_SOURCE_LOCATION (decl);
3008	/ We want to use the argument list specified in the*
3009	definition, not in the original declaration. /*
3010	DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
3011	for (parm = DECL_ARGUMENTS (result); parm;
3012	parm = DECL_CHAIN (parm))
3013	DECL_CONTEXT (parm) = result;
3014	}
3015	return register_specialization (tmpl, gen_tmpl, targs,
3016	is_friend, `0`);
3017	}
3018
3019	/ Set up the DECL_TEMPLATE_INFO for DECL. /
3020	DECL_TEMPLATE_INFO (decl) = build_template_info (tmpl, targs);
3021
3022	if (was_template_id)
3023	TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl)) = true;
3024
3025	/ Inherit default function arguments from the template*
3026	DECL is specializing. /*
3027	if (DECL_FUNCTION_TEMPLATE_P (tmpl))
3028	copy_default_args_to_explicit_spec (decl);
3029
3030	/ This specialization has the same protection as the*
3031	template it specializes. /*
3032	TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
3033	TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
3034
3035	/ 7.1.1-1 [dcl.stc]*
3036
3037	A storage-class-specifier shall not be specified in an
3038	explicit specialization...
3039
3040	The parser rejects these, so unless action is taken here,
3041	explicit function specializations will always appear with
3042	global linkage.
3043
3044	The action recommended by the C++ CWG in response to C++
3045	defect report 605 is to make the storage class and linkage
3046	of the explicit specialization match the templated function:
3047
3048	http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3049	*/
3050	if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
3051	{
3052	tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
3053	gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
3054
3055	/ A concept cannot be specialized. /
3056	if (DECL_DECLARED_CONCEPT_P (tmpl_func))
3057	{
3058	error ("explicit specialization of function concept %qD",
3059	gen_tmpl);
3060	return error_mark_node;
3061	}
3062
3063	/ This specialization has the same linkage and visibility as*
3064	the function template it specializes. /*
3065	TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
3066	if (! TREE_PUBLIC (decl))
3067	{
3068	DECL_INTERFACE_KNOWN (decl) = `1`;
3069	DECL_NOT_REALLY_EXTERN (decl) = `1`;
3070	}
3071	DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
3072	if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
3073	{
3074	DECL_VISIBILITY_SPECIFIED (decl) = `1`;
3075	DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
3076	}
3077	}
3078
3079	/ If DECL is a friend declaration, declared using an*
3080	unqualified name, the namespace associated with DECL may
3081	have been set incorrectly. For example, in:
3082
3083	template <typename T> void f(T);
3084	namespace N {
3085	struct S { friend void f<int>(int); }
3086	}
3087
3088	we will have set the DECL_CONTEXT for the friend
3089	declaration to N, rather than to the global namespace. /*
3090	if (DECL_NAMESPACE_SCOPE_P (decl))
3091	DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
3092
3093	if (is_friend && !have_def)
3094	/ This is not really a declaration of a specialization.*
3095	It's just the name of an instantiation. But, it's not
3096	a request for an instantiation, either. /*
3097	SET_DECL_IMPLICIT_INSTANTIATION (decl);
3098	else if (TREE_CODE (decl) == FUNCTION_DECL)
3099	/ A specialization is not necessarily COMDAT. /
3100	DECL_COMDAT (decl) = (TREE_PUBLIC (decl)
3101	&& DECL_DECLARED_INLINE_P (decl));
3102	else if (VAR_P (decl))
3103	DECL_COMDAT (decl) = false;
3104
3105	/ If this is a full specialization, register it so that we can find*
3106	it again. Partial specializations will be registered in
3107	process_partial_specialization. /*
3108	if (!processing_template_decl)
3109	decl = register_specialization (decl, gen_tmpl, targs,
3110	is_friend, `0`);
3111
3112	/ A 'structor should already have clones. /
3113	gcc_assert (decl == error_mark_node
3114	\|\| variable_template_p (tmpl)
3115	\|\| !(DECL_CONSTRUCTOR_P (decl)
3116	\|\| DECL_DESTRUCTOR_P (decl))
3117	\|\| DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)));
3118	}
3119	}
3120
3121	return decl;
3122	}
3123
3124	/ Returns 1 iff PARMS1 and PARMS2 are identical sets of template*
3125	parameters. These are represented in the same format used for
3126	DECL_TEMPLATE_PARMS. /*
3127
3128	int
3129	comp_template_parms (const_tree parms1, const_tree parms2)
3130	{
3131	const_tree p1;
3132	const_tree p2;
3133
3134	if (parms1 == parms2)
3135	return `1`;
3136
3137	for (p1 = parms1, p2 = parms2;
3138	p1 != NULL_TREE && p2 != NULL_TREE;
3139	p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
3140	{
3141	tree t1 = TREE_VALUE (p1);
3142	tree t2 = TREE_VALUE (p2);
3143	int i;
3144
3145	gcc_assert (TREE_CODE (t1) == TREE_VEC);
3146	gcc_assert (TREE_CODE (t2) == TREE_VEC);
3147
3148	if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
3149	return `0`;
3150
3151	for (i = `0`; i < TREE_VEC_LENGTH (t2); ++i)
3152	{
3153	tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
3154	tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
3155
3156	/ If either of the template parameters are invalid, assume*
3157	they match for the sake of error recovery. /*
3158	if (error_operand_p (parm1) \|\| error_operand_p (parm2))
3159	return `1`;
3160
3161	if (TREE_CODE (parm1) != TREE_CODE (parm2))
3162	return `0`;
3163
3164	if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
3165	&& (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
3166	== TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
3167	continue;
3168	else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
3169	return `0`;
3170	}
3171	}
3172
3173	if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
3174	/ One set of parameters has more parameters lists than the*
3175	other. /*
3176	return `0`;
3177
3178	return `1`;
3179	}
3180
3181	/ Determine whether PARM is a parameter pack. /
3182
3183	bool
3184	template_parameter_pack_p (const_tree parm)
3185	{
3186	/ Determine if we have a non-type template parameter pack. /
3187	if (TREE_CODE (parm) == PARM_DECL)
3188	return (DECL_TEMPLATE_PARM_P (parm)
3189	&& TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
3190	if (TREE_CODE (parm) == TEMPLATE_PARM_INDEX)
3191	return TEMPLATE_PARM_PARAMETER_PACK (parm);
3192
3193	/ If this is a list of template parameters, we could get a*
3194	TYPE_DECL or a TEMPLATE_DECL. /*
3195	if (TREE_CODE (parm) == TYPE_DECL \|\| TREE_CODE (parm) == TEMPLATE_DECL)
3196	parm = TREE_TYPE (parm);
3197
3198	/ Otherwise it must be a type template parameter. /
3199	return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
3200	\|\| TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
3201	&& TEMPLATE_TYPE_PARAMETER_PACK (parm));
3202	}
3203
3204	/ Determine if T is a function parameter pack. /
3205
3206	bool
3207	function_parameter_pack_p (const_tree t)
3208	{
3209	if (t && TREE_CODE (t) == PARM_DECL)
3210	return DECL_PACK_P (t);
3211	return false;
3212	}
3213
3214	/ Return the function template declaration of PRIMARY_FUNC_TMPL_INST.*
3215	PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. /*
3216
3217	tree
3218	get_function_template_decl (const_tree primary_func_tmpl_inst)
3219	{
3220	if (! primary_func_tmpl_inst
3221	\|\| TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
3222	\|\| ! primary_template_specialization_p (primary_func_tmpl_inst))
3223	return NULL;
3224
3225	return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
3226	}
3227
3228	/ Return true iff the function parameter PARAM_DECL was expanded*
3229	from the function parameter pack PACK. /*
3230
3231	bool
3232	function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
3233	{
3234	if (DECL_ARTIFICIAL (param_decl)
3235	\|\| !function_parameter_pack_p (pack))
3236	return false;
3237
3238	/ The parameter pack and its pack arguments have the same*
3239	DECL_PARM_INDEX. /*
3240	return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
3241	}
3242
3243	/ Determine whether ARGS describes a variadic template args list,*
3244	i.e., one that is terminated by a template argument pack. /*
3245
3246	static bool
3247	template_args_variadic_p (tree args)
3248	{
3249	int nargs;
3250	tree last_parm;
3251
3252	if (args == NULL_TREE)
3253	return false;
3254
3255	args = INNERMOST_TEMPLATE_ARGS (args);
3256	nargs = TREE_VEC_LENGTH (args);
3257
3258	if (nargs == `0`)
3259	return false;
3260
3261	last_parm = TREE_VEC_ELT (args, nargs - `1`);
3262
3263	return ARGUMENT_PACK_P (last_parm);
3264	}
3265
3266	/ Generate a new name for the parameter pack name NAME (an*
3267	IDENTIFIER_NODE) that incorporates its /*
3268
3269	static tree
3270	make_ith_pack_parameter_name (tree name, int i)
3271	{
3272	/ Munge the name to include the parameter index. /
3273	#define NUMBUF_LEN 128
3274	char numbuf[NUMBUF_LEN];
3275	char* newname;
3276	int newname_len;
3277
3278	if (name == NULL_TREE)
3279	return name;
3280	snprintf (numbuf, NUMBUF_LEN, "%i", i);
3281	newname_len = IDENTIFIER_LENGTH (name)
3282	+ strlen (numbuf) + `2`;
3283	newname = (char*)alloca (newname_len);
3284	snprintf (newname, newname_len,
3285	"%s#%i", IDENTIFIER_POINTER (name), i);
3286	return get_identifier (newname);
3287	}
3288
3289	/ Return true if T is a primary function, class or alias template*
3290	specialization, not including the template pattern. /*
3291
3292	bool
3293	primary_template_specialization_p (const_tree t)
3294	{
3295	if (!t)
3296	return false;
3297
3298	if (TREE_CODE (t) == FUNCTION_DECL \|\| VAR_P (t))
3299	return (DECL_LANG_SPECIFIC (t)
3300	&& DECL_USE_TEMPLATE (t)
3301	&& DECL_TEMPLATE_INFO (t)
3302	&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)));
3303	else if (CLASS_TYPE_P (t) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
3304	return (CLASSTYPE_TEMPLATE_INFO (t)
3305	&& CLASSTYPE_USE_TEMPLATE (t)
3306	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
3307	else if (alias_template_specialization_p (t))
3308	return true;
3309	return false;
3310	}
3311
3312	/ Return true if PARM is a template template parameter. /
3313
3314	bool
3315	template_template_parameter_p (const_tree parm)
3316	{
3317	return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
3318	}
3319
3320	/ Return true iff PARM is a DECL representing a type template*
3321	parameter. /*
3322
3323	bool
3324	template_type_parameter_p (const_tree parm)
3325	{
3326	return (parm
3327	&& (TREE_CODE (parm) == TYPE_DECL
3328	\|\| TREE_CODE (parm) == TEMPLATE_DECL)
3329	&& DECL_TEMPLATE_PARM_P (parm));
3330	}
3331
3332	/ Return the template parameters of T if T is a*
3333	primary template instantiation, NULL otherwise. /*
3334
3335	tree
3336	get_primary_template_innermost_parameters (const_tree t)
3337	{
3338	tree parms = NULL, template_info = NULL;
3339
3340	if ((template_info = get_template_info (t))
3341	&& primary_template_specialization_p (t))
3342	parms = INNERMOST_TEMPLATE_PARMS
3343	(DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
3344
3345	return parms;
3346	}
3347
3348	/ Return the template parameters of the LEVELth level from the full list*
3349	of template parameters PARMS. /*
3350
3351	tree
3352	get_template_parms_at_level (tree parms, int level)
3353	{
3354	tree p;
3355	if (!parms
3356	\|\| TREE_CODE (parms) != TREE_LIST
3357	\|\| level > TMPL_PARMS_DEPTH (parms))
3358	return NULL_TREE;
3359
3360	for (p = parms; p; p = TREE_CHAIN (p))
3361	if (TMPL_PARMS_DEPTH (p) == level)
3362	return p;
3363
3364	return NULL_TREE;
3365	}
3366
3367	/ Returns the template arguments of T if T is a template instantiation,*
3368	NULL otherwise. /*
3369
3370	tree
3371	get_template_innermost_arguments (const_tree t)
3372	{
3373	tree args = NULL, template_info = NULL;
3374
3375	if ((template_info = get_template_info (t))
3376	&& TI_ARGS (template_info))
3377	args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
3378
3379	return args;
3380	}
3381
3382	/ Return the argument pack elements of T if T is a template argument pack,*
3383	NULL otherwise. /*
3384
3385	tree
3386	get_template_argument_pack_elems (const_tree t)
3387	{
3388	if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
3389	&& TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
3390	return NULL;
3391
3392	return ARGUMENT_PACK_ARGS (t);
3393	}
3394
3395	/ True iff FN is a function representing a built-in variadic parameter*
3396	pack. /*
3397
3398	bool
3399	builtin_pack_fn_p (tree fn)
3400	{
3401	if (!fn
3402	\|\| TREE_CODE (fn) != FUNCTION_DECL
3403	\|\| !DECL_IS_BUILTIN (fn))
3404	return false;
3405
3406	if (id_equal (DECL_NAME (fn), "__integer_pack"))
3407	return true;
3408
3409	return false;
3410	}
3411
3412	/ True iff CALL is a call to a function representing a built-in variadic*
3413	parameter pack. /*
3414
3415	static bool
3416	builtin_pack_call_p (tree call)
3417	{
3418	if (TREE_CODE (call) != CALL_EXPR)
3419	return false;
3420	return builtin_pack_fn_p (CALL_EXPR_FN (call));
3421	}
3422
3423	/ Return a TREE_VEC for the expansion of __integer_pack(HI). /
3424
3425	static tree
3426	expand_integer_pack (tree call, tree args, tsubst_flags_t complain,
3427	tree in_decl)
3428	{
3429	tree ohi = CALL_EXPR_ARG (call, `0`);
3430	tree hi = tsubst_copy_and_build (ohi, args, complain, in_decl,
3431	false/fn/, true/int_cst/);
3432
3433	if (value_dependent_expression_p (hi))
3434	{
3435	if (hi != ohi)
3436	{
3437	call = copy_node (call);
3438	CALL_EXPR_ARG (call, `0`) = hi;
3439	}
3440	tree ex = make_pack_expansion (call, complain);
3441	tree vec = make_tree_vec (`1`);
3442	TREE_VEC_ELT (vec, `0`) = ex;
3443	return vec;
3444	}
3445	else
3446	{
3447	hi = cxx_constant_value (hi);
3448	int len = valid_constant_size_p (hi) ? tree_to_shwi (hi) : -`1`;
3449
3450	/ Calculate the largest value of len that won't make the size of the vec*
3451	overflow an int. The compiler will exceed resource limits long before
3452	this, but it seems a decent place to diagnose. /*
3453	int max = ((INT_MAX - sizeof (tree_vec)) / sizeof (tree)) + `1`;
3454
3455	if (len < `0` \|\| len > max)
3456	{
3457	if ((complain & tf_error)
3458	&& hi != error_mark_node)
3459	error ("argument to __integer_pack must be between 0 and %d", max);
3460	return error_mark_node;
3461	}
3462
3463	tree vec = make_tree_vec (len);
3464
3465	for (int i = `0`; i < len; ++i)
3466	TREE_VEC_ELT (vec, i) = size_int (i);
3467
3468	return vec;
3469	}
3470	}
3471
3472	/ Return a TREE_VEC for the expansion of built-in template parameter pack*
3473	CALL. /*
3474
3475	static tree
3476	expand_builtin_pack_call (tree call, tree args, tsubst_flags_t complain,
3477	tree in_decl)
3478	{
3479	if (!builtin_pack_call_p (call))
3480	return NULL_TREE;
3481
3482	tree fn = CALL_EXPR_FN (call);
3483
3484	if (id_equal (DECL_NAME (fn), "__integer_pack"))
3485	return expand_integer_pack (call, args, complain, in_decl);
3486
3487	return NULL_TREE;
3488	}
3489
3490	/ Structure used to track the progress of find_parameter_packs_r. /
3491	struct find_parameter_pack_data
3492	{
3493	/ TREE_LIST that will contain all of the parameter packs found by*
3494	the traversal. /*
3495	tree* parameter_packs;
3496
3497	/ Set of AST nodes that have been visited by the traversal. /
3498	hash_set<tree> *visited;
3499
3500	/ True iff we're making a type pack expansion. /
3501	bool type_pack_expansion_p;
3502	};
3503
3504	/ Identifies all of the argument packs that occur in a template*
3505	argument and appends them to the TREE_LIST inside DATA, which is a
3506	find_parameter_pack_data structure. This is a subroutine of
3507	make_pack_expansion and uses_parameter_packs. /*
3508	static tree
3509	find_parameter_packs_r (tree tp, int* walk_subtrees, void** data)
3510	{
3511	tree t = *tp;
3512	struct find_parameter_pack_data* ppd =
3513	(struct find_parameter_pack_data*)data;
3514	bool parameter_pack_p = false;
3515
3516	/ Handle type aliases/typedefs. /
3517	if (TYPE_ALIAS_P (t))
3518	{
3519	if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
3520	cp_walk_tree (&TI_ARGS (tinfo),
3521	&find_parameter_packs_r,
3522	ppd, ppd->visited);
3523	*walk_subtrees = `0`;
3524	return NULL_TREE;
3525	}
3526
3527	/ Identify whether this is a parameter pack or not. /
3528	switch (TREE_CODE (t))
3529	{
3530	case TEMPLATE_PARM_INDEX:
3531	if (TEMPLATE_PARM_PARAMETER_PACK (t))
3532	parameter_pack_p = true;
3533	break;
3534
3535	case TEMPLATE_TYPE_PARM:
3536	t = TYPE_MAIN_VARIANT (t);
3537	/ FALLTHRU /
3538	case TEMPLATE_TEMPLATE_PARM:
3539	/ If the placeholder appears in the decl-specifier-seq of a function*
3540	parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3541	is a pack expansion, the invented template parameter is a template
3542	parameter pack. /*
3543	if (ppd->type_pack_expansion_p && is_auto (t))
3544	TEMPLATE_TYPE_PARAMETER_PACK (t) = true;
3545	if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3546	parameter_pack_p = true;
3547	break;
3548
3549	case FIELD_DECL:
3550	case PARM_DECL:
3551	if (DECL_PACK_P (t))
3552	{
3553	/ We don't want to walk into the type of a PARM_DECL,*
3554	because we don't want to see the type parameter pack. /*
3555	*walk_subtrees = `0`;
3556	parameter_pack_p = true;
3557	}
3558	break;
3559
3560	/ Look through a lambda capture proxy to the field pack. /
3561	case VAR_DECL:
3562	if (DECL_HAS_VALUE_EXPR_P (t))
3563	{
3564	tree v = DECL_VALUE_EXPR (t);
3565	cp_walk_tree (&v,
3566	&find_parameter_packs_r,
3567	ppd, ppd->visited);
3568	*walk_subtrees = `0`;
3569	}
3570	else if (variable_template_specialization_p (t))
3571	{
3572	cp_walk_tree (&DECL_TI_ARGS (t),
3573	find_parameter_packs_r,
3574	ppd, ppd->visited);
3575	*walk_subtrees = `0`;
3576	}
3577	break;
3578
3579	case CALL_EXPR:
3580	if (builtin_pack_call_p (t))
3581	parameter_pack_p = true;
3582	break;
3583
3584	case BASES:
3585	parameter_pack_p = true;
3586	break;
3587	default:
3588	/ Not a parameter pack. /
3589	break;
3590	}
3591
3592	if (parameter_pack_p)
3593	{
3594	/ Add this parameter pack to the list. /
3595	ppd->parameter_packs = tree_cons (NULL_TREE, t, ppd->parameter_packs);
3596	}
3597
3598	if (TYPE_P (t))
3599	cp_walk_tree (&TYPE_CONTEXT (t),
3600	&find_parameter_packs_r, ppd, ppd->visited);
3601
3602	/ This switch statement will return immediately if we don't find a*
3603	parameter pack. /*
3604	switch (TREE_CODE (t))
3605	{
3606	case TEMPLATE_PARM_INDEX:
3607	return NULL_TREE;
3608
3609	case BOUND_TEMPLATE_TEMPLATE_PARM:
3610	/ Check the template itself. /
3611	cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
3612	&find_parameter_packs_r, ppd, ppd->visited);
3613	/ Check the template arguments. /
3614	cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
3615	ppd->visited);
3616	*walk_subtrees = `0`;
3617	return NULL_TREE;
3618
3619	case TEMPLATE_TYPE_PARM:
3620	case TEMPLATE_TEMPLATE_PARM:
3621	return NULL_TREE;
3622
3623	case PARM_DECL:
3624	return NULL_TREE;
3625
3626	case DECL_EXPR:
3627	/ Ignore the declaration of a capture proxy for a parameter pack. /
3628	if (is_capture_proxy (DECL_EXPR_DECL (t)))
3629	*walk_subtrees = `0`;
3630	return NULL_TREE;
3631
3632	case RECORD_TYPE:
3633	if (TYPE_PTRMEMFUNC_P (t))
3634	return NULL_TREE;
3635	/ Fall through. /
3636
3637	case UNION_TYPE:
3638	case ENUMERAL_TYPE:
3639	if (TYPE_TEMPLATE_INFO (t))
3640	cp_walk_tree (&TYPE_TI_ARGS (t),
3641	&find_parameter_packs_r, ppd, ppd->visited);
3642
3643	*walk_subtrees = `0`;
3644	return NULL_TREE;
3645
3646	case TEMPLATE_DECL:
3647	if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t))
3648	return NULL_TREE;
3649	gcc_fallthrough();
3650
3651	case CONSTRUCTOR:
3652	cp_walk_tree (&TREE_TYPE (t),
3653	&find_parameter_packs_r, ppd, ppd->visited);
3654	return NULL_TREE;
3655
3656	case TYPENAME_TYPE:
3657	cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
3658	ppd, ppd->visited);
3659	*walk_subtrees = `0`;
3660	return NULL_TREE;
3661
3662	case TYPE_PACK_EXPANSION:
3663	case EXPR_PACK_EXPANSION:
3664	*walk_subtrees = `0`;
3665	return NULL_TREE;
3666
3667	case INTEGER_TYPE:
3668	cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
3669	ppd, ppd->visited);
3670	*walk_subtrees = `0`;
3671	return NULL_TREE;
3672
3673	case IDENTIFIER_NODE:
3674	cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
3675	ppd->visited);
3676	*walk_subtrees = `0`;
3677	return NULL_TREE;
3678
3679	case LAMBDA_EXPR:
3680	{
3681	tree fn = lambda_function (t);
3682	cp_walk_tree (&DECL_SAVED_TREE (fn), &find_parameter_packs_r, ppd,
3683	ppd->visited);
3684	*walk_subtrees = `0`;
3685	return NULL_TREE;
3686	}
3687
3688	case DECLTYPE_TYPE:
3689	{
3690	/ When traversing a DECLTYPE_TYPE_EXPR, we need to set*
3691	type_pack_expansion_p to false so that any placeholders
3692	within the expression don't get marked as parameter packs. /*
3693	bool type_pack_expansion_p = ppd->type_pack_expansion_p;
3694	ppd->type_pack_expansion_p = false;
3695	cp_walk_tree (&DECLTYPE_TYPE_EXPR (t), &find_parameter_packs_r,
3696	ppd, ppd->visited);
3697	ppd->type_pack_expansion_p = type_pack_expansion_p;
3698	*walk_subtrees = `0`;
3699	return NULL_TREE;
3700	}
3701
3702	default:
3703	return NULL_TREE;
3704	}
3705
3706	return NULL_TREE;
3707	}
3708
3709	/ Determines if the expression or type T uses any parameter packs. /
3710	bool
3711	uses_parameter_packs (tree t)
3712	{
3713	tree parameter_packs = NULL_TREE;
3714	struct find_parameter_pack_data ppd;
3715	ppd.parameter_packs = &parameter_packs;
3716	ppd.visited = new hash_set<tree>;
3717	ppd.type_pack_expansion_p = false;
3718	cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3719	delete ppd.visited;
3720	return parameter_packs != NULL_TREE;
3721	}
3722
3723	/ Turn ARG, which may be an expression, type, or a TREE_LIST*
3724	representation a base-class initializer into a parameter pack
3725	expansion. If all goes well, the resulting node will be an
3726	EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3727	respectively. /*
3728	tree
3729	make_pack_expansion (tree arg, tsubst_flags_t complain)
3730	{
3731	tree result;
3732	tree parameter_packs = NULL_TREE;
3733	bool for_types = false;
3734	struct find_parameter_pack_data ppd;
3735
3736	if (!arg \|\| arg == error_mark_node)
3737	return arg;
3738
3739	if (TREE_CODE (arg) == TREE_LIST && TREE_PURPOSE (arg))
3740	{
3741	/ A TREE_LIST with a non-null TREE_PURPOSE is for a base*
3742	class initializer. In this case, the TREE_PURPOSE will be a
3743	_TYPE node (representing the base class expansion we're
3744	initializing) and the TREE_VALUE will be a TREE_LIST
3745	containing the initialization arguments.
3746
3747	The resulting expansion looks somewhat different from most
3748	expansions. Rather than returning just one _EXPANSION, we
3749	return a TREE_LIST whose TREE_PURPOSE is a
3750	TYPE_PACK_EXPANSION containing the bases that will be
3751	initialized. The TREE_VALUE will be identical to the
3752	original TREE_VALUE, which is a list of arguments that will
3753	be passed to each base. We do not introduce any new pack
3754	expansion nodes into the TREE_VALUE (although it is possible
3755	that some already exist), because the TREE_PURPOSE and
3756	TREE_VALUE all need to be expanded together with the same
3757	_EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3758	resulting TREE_PURPOSE will mention the parameter packs in
3759	both the bases and the arguments to the bases. /*
3760	tree purpose;
3761	tree value;
3762	tree parameter_packs = NULL_TREE;
3763
3764	/ Determine which parameter packs will be used by the base*
3765	class expansion. /*
3766	ppd.visited = new hash_set<tree>;
3767	ppd.parameter_packs = &parameter_packs;
3768	ppd.type_pack_expansion_p = true;
3769	gcc_assert (TYPE_P (TREE_PURPOSE (arg)));
3770	cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
3771	&ppd, ppd.visited);
3772
3773	if (parameter_packs == NULL_TREE)
3774	{
3775	if (complain & tf_error)
3776	error ("base initializer expansion %qT contains no parameter packs",
3777	arg);
3778	delete ppd.visited;
3779	return error_mark_node;
3780	}
3781
3782	if (TREE_VALUE (arg) != void_type_node)
3783	{
3784	/ Collect the sets of parameter packs used in each of the*
3785	initialization arguments. /*
3786	for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
3787	{
3788	/ Determine which parameter packs will be expanded in this*
3789	argument. /*
3790	cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
3791	&ppd, ppd.visited);
3792	}
3793	}
3794
3795	delete ppd.visited;
3796
3797	/ Create the pack expansion type for the base type. /
3798	purpose = cxx_make_type (TYPE_PACK_EXPANSION);
3799	SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
3800	PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
3801	PACK_EXPANSION_LOCAL_P (purpose) = at_function_scope_p ();
3802
3803	/ Just use structural equality for these TYPE_PACK_EXPANSIONS;*
3804	they will rarely be compared to anything. /*
3805	SET_TYPE_STRUCTURAL_EQUALITY (purpose);
3806
3807	return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
3808	}
3809
3810	if (TYPE_P (arg) \|\| TREE_CODE (arg) == TEMPLATE_DECL)
3811	for_types = true;
3812
3813	/ Build the PACK_EXPANSION_* node. /
3814	result = for_types
3815	? cxx_make_type (TYPE_PACK_EXPANSION)
3816	: make_node (EXPR_PACK_EXPANSION);
3817	SET_PACK_EXPANSION_PATTERN (result, arg);
3818	if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
3819	{
3820	/ Propagate type and const-expression information. /
3821	TREE_TYPE (result) = TREE_TYPE (arg);
3822	TREE_CONSTANT (result) = TREE_CONSTANT (arg);
3823	/ Mark this read now, since the expansion might be length 0. /
3824	mark_exp_read (arg);
3825	}
3826	else
3827	/ Just use structural equality for these TYPE_PACK_EXPANSIONS;*
3828	they will rarely be compared to anything. /*
3829	SET_TYPE_STRUCTURAL_EQUALITY (result);
3830
3831	/ Determine which parameter packs will be expanded. /
3832	ppd.parameter_packs = &parameter_packs;
3833	ppd.visited = new hash_set<tree>;
3834	ppd.type_pack_expansion_p = TYPE_P (arg);
3835	cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
3836	delete ppd.visited;
3837
3838	/ Make sure we found some parameter packs. /
3839	if (parameter_packs == NULL_TREE)
3840	{
3841	if (complain & tf_error)
3842	{
3843	if (TYPE_P (arg))
3844	error ("expansion pattern %qT contains no argument packs", arg);
3845	else
3846	error ("expansion pattern %qE contains no argument packs", arg);
3847	}
3848	return error_mark_node;
3849	}
3850	PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
3851
3852	PACK_EXPANSION_LOCAL_P (result) = at_function_scope_p ();
3853
3854	return result;
3855	}
3856
3857	/ Checks T for any "bare" parameter packs, which have not yet been*
3858	expanded, and issues an error if any are found. This operation can
3859	only be done on full expressions or types (e.g., an expression
3860	statement, "if" condition, etc.), because we could have expressions like:
3861
3862	foo(f(g(h(args)))...)
3863
3864	where "args" is a parameter pack. check_for_bare_parameter_packs
3865	should not be called for the subexpressions args, h(args),
3866	g(h(args)), or f(g(h(args))), because we would produce erroneous
3867	error messages.
3868
3869	Returns TRUE and emits an error if there were bare parameter packs,
3870	returns FALSE otherwise. /*
3871	bool
3872	check_for_bare_parameter_packs (tree t)
3873	{
3874	tree parameter_packs = NULL_TREE;
3875	struct find_parameter_pack_data ppd;
3876
3877	if (!processing_template_decl \|\| !t \|\| t == error_mark_node)
3878	return false;
3879
3880	/ A lambda might use a parameter pack from the containing context. /
3881	if (current_function_decl && LAMBDA_FUNCTION_P (current_function_decl))
3882	return false;
3883
3884	if (TREE_CODE (t) == TYPE_DECL)
3885	t = TREE_TYPE (t);
3886
3887	ppd.parameter_packs = &parameter_packs;
3888	ppd.visited = new hash_set<tree>;
3889	ppd.type_pack_expansion_p = false;
3890	cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3891	delete ppd.visited;
3892
3893	if (parameter_packs)
3894	{
3895	location_t loc = EXPR_LOC_OR_LOC (t, input_location);
3896	error_at (loc, "parameter packs not expanded with %<...%>:");
3897	while (parameter_packs)
3898	{
3899	tree pack = TREE_VALUE (parameter_packs);
3900	tree name = NULL_TREE;
3901
3902	if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
3903	\|\| TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
3904	name = TYPE_NAME (pack);
3905	else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
3906	name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
3907	else if (TREE_CODE (pack) == CALL_EXPR)
3908	name = DECL_NAME (CALL_EXPR_FN (pack));
3909	else
3910	name = DECL_NAME (pack);
3911
3912	if (name)
3913	inform (loc, " %qD", name);
3914	else
3915	inform (loc, " <anonymous>");
3916
3917	parameter_packs = TREE_CHAIN (parameter_packs);
3918	}
3919
3920	return true;
3921	}
3922
3923	return false;
3924	}
3925
3926	/ Expand any parameter packs that occur in the template arguments in*
3927	ARGS. /*
3928	tree
3929	expand_template_argument_pack (tree args)
3930	{
3931	if (args == error_mark_node)
3932	return error_mark_node;
3933
3934	tree result_args = NULL_TREE;
3935	int in_arg, out_arg = `0`, nargs = args ? TREE_VEC_LENGTH (args) : `0`;
3936	int num_result_args = -`1`;
3937	int non_default_args_count = -`1`;
3938
3939	/ First, determine if we need to expand anything, and the number of*
3940	slots we'll need. /*
3941	for (in_arg = `0`; in_arg < nargs; ++in_arg)
3942	{
3943	tree arg = TREE_VEC_ELT (args, in_arg);
3944	if (arg == NULL_TREE)
3945	return args;
3946	if (ARGUMENT_PACK_P (arg))
3947	{
3948	int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
3949	if (num_result_args < `0`)
3950	num_result_args = in_arg + num_packed;
3951	else
3952	num_result_args += num_packed;
3953	}
3954	else
3955	{
3956	if (num_result_args >= `0`)
3957	num_result_args++;
3958	}
3959	}
3960
3961	/ If no expansion is necessary, we're done. /
3962	if (num_result_args < `0`)
3963	return args;
3964
3965	/ Expand arguments. /
3966	result_args = make_tree_vec (num_result_args);
3967	if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args))
3968	non_default_args_count =
3969	GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
3970	for (in_arg = `0`; in_arg < nargs; ++in_arg)
3971	{
3972	tree arg = TREE_VEC_ELT (args, in_arg);
3973	if (ARGUMENT_PACK_P (arg))
3974	{
3975	tree packed = ARGUMENT_PACK_ARGS (arg);
3976	int i, num_packed = TREE_VEC_LENGTH (packed);
3977	for (i = `0`; i < num_packed; ++i, ++out_arg)
3978	TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
3979	if (non_default_args_count > `0`)
3980	non_default_args_count += num_packed - `1`;
3981	}
3982	else
3983	{
3984	TREE_VEC_ELT (result_args, out_arg) = arg;
3985	++out_arg;
3986	}
3987	}
3988	if (non_default_args_count >= `0`)
3989	SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args, non_default_args_count);
3990	return result_args;
3991	}
3992
3993	/ Checks if DECL shadows a template parameter.*
3994
3995	[temp.local]: A template-parameter shall not be redeclared within its
3996	scope (including nested scopes).
3997
3998	Emits an error and returns TRUE if the DECL shadows a parameter,
3999	returns FALSE otherwise. /*
4000
4001	bool
4002	check_template_shadow (tree decl)
4003	{
4004	tree olddecl;
4005
4006	/ If we're not in a template, we can't possibly shadow a template*
4007	parameter. /*
4008	if (!current_template_parms)
4009	return true;
4010
4011	/ Figure out what we're shadowing. /
4012	decl = OVL_FIRST (decl);
4013	olddecl = innermost_non_namespace_value (DECL_NAME (decl));
4014
4015	/ If there's no previous binding for this name, we're not shadowing*
4016	anything, let alone a template parameter. /*
4017	if (!olddecl)
4018	return true;
4019
4020	/ If we're not shadowing a template parameter, we're done. Note*
4021	that OLDDECL might be an OVERLOAD (or perhaps even an
4022	ERROR_MARK), so we can't just blithely assume it to be a _DECL
4023	node. /*
4024	if (!DECL_P (olddecl) \|\| !DECL_TEMPLATE_PARM_P (olddecl))
4025	return true;
4026
4027	/ We check for decl != olddecl to avoid bogus errors for using a*
4028	name inside a class. We check TPFI to avoid duplicate errors for
4029	inline member templates. /*
4030	if (decl == olddecl
4031	\|\| (DECL_TEMPLATE_PARM_P (decl)
4032	&& TEMPLATE_PARMS_FOR_INLINE (current_template_parms)))
4033	return true;
4034
4035	/ Don't complain about the injected class name, as we've already*
4036	complained about the class itself. /*
4037	if (DECL_SELF_REFERENCE_P (decl))
4038	return false;
4039
4040	if (DECL_TEMPLATE_PARM_P (decl))
4041	error ("declaration of template parameter %q+D shadows "
4042	"template parameter", decl);
4043	else
4044	error ("declaration of %q+#D shadows template parameter", decl);
4045	inform (DECL_SOURCE_LOCATION (olddecl),
4046	"template parameter %qD declared here", olddecl);
4047	return false;
4048	}
4049
4050	/ Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,*
4051	ORIG_LEVEL, DECL, and TYPE. /*
4052
4053	static tree
4054	build_template_parm_index (int index,
4055	int level,
4056	int orig_level,
4057	tree decl,
4058	tree type)
4059	{
4060	tree t = make_node (TEMPLATE_PARM_INDEX);
4061	TEMPLATE_PARM_IDX (t) = index;
4062	TEMPLATE_PARM_LEVEL (t) = level;
4063	TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
4064	TEMPLATE_PARM_DECL (t) = decl;
4065	TREE_TYPE (t) = type;
4066	TREE_CONSTANT (t) = TREE_CONSTANT (decl);
4067	TREE_READONLY (t) = TREE_READONLY (decl);
4068
4069	return t;
4070	}
4071
4072	/ Find the canonical type parameter for the given template type*
4073	parameter. Returns the canonical type parameter, which may be TYPE
4074	if no such parameter existed. /*
4075
4076	static tree
4077	canonical_type_parameter (tree type)
4078	{
4079	tree list;
4080	int idx = TEMPLATE_TYPE_IDX (type);
4081	if (!canonical_template_parms)
4082	vec_alloc (canonical_template_parms, idx + `1`);
4083
4084	if (canonical_template_parms->length () <= (unsigned) idx)
4085	vec_safe_grow_cleared (canonical_template_parms, idx + `1`);
4086
4087	list = (*canonical_template_parms)[idx];
4088	while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
4089	list = TREE_CHAIN (list);
4090
4091	if (list)
4092	return TREE_VALUE (

Browse the source code of gcc/cp/pt.c