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
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 3, or (at your option)
11any later version.
12
13GCC is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along 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. */
47typedef 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. */
52struct GTY ((chain_next ("%h.next"))) pending_template {
53 struct pending_template *next;
54 struct tinst_level *tinst;
55};
56
57static GTY(()) struct pending_template *pending_templates;
58static GTY(()) struct pending_template *last_pending_template;
59
60int processing_template_parmlist;
61static int template_header_count;
62
63static GTY(()) tree saved_trees;
64static vec<int> inline_parm_levels;
65
66static GTY(()) struct tinst_level *current_tinst_level;
67
68static 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. */
73static tree cur_stmt_expr;
74
75// -------------------------------------------------------------------------- //
76// Local Specialization Stack
77//
78// Implementation of the RAII helper for creating new local
79// specializations.
80local_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
89local_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. */
96static bool excessive_deduction_depth;
97
98struct GTY((for_user)) spec_entry
99{
100 tree tmpl;
101 tree args;
102 tree spec;
103};
104
105struct 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
111static GTY (()) hash_table<spec_hasher> *decl_specializations;
112
113static 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. */
119static 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
130enum template_base_result {
131 tbr_incomplete_type,
132 tbr_ambiguous_baseclass,
133 tbr_success
134};
135
136static void push_access_scope (tree);
137static void pop_access_scope (tree);
138static bool resolve_overloaded_unification (tree, tree, tree, tree,
139 unification_kind_t, int,
140 bool);
141static int try_one_overload (tree, tree, tree, tree, tree,
142 unification_kind_t, int, bool, bool);
143static int unify (tree, tree, tree, tree, int, bool);
144static void add_pending_template (tree);
145static tree reopen_tinst_level (struct tinst_level *);
146static tree tsubst_initializer_list (tree, tree);
147static tree get_partial_spec_bindings (tree, tree, tree);
148static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
149 bool, bool);
150static tree coerce_innermost_template_parms (tree, tree, tree, tsubst_flags_t,
151 bool, bool);
152static void tsubst_enum (tree, tree, tree);
153static tree add_to_template_args (tree, tree);
154static tree add_outermost_template_args (tree, tree);
155static bool check_instantiated_args (tree, tree, tsubst_flags_t);
156static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
157 tree);
158static 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);
162static void note_template_header (int);
163static tree convert_nontype_argument_function (tree, tree, tsubst_flags_t);
164static tree convert_nontype_argument (tree, tree, tsubst_flags_t);
165static tree convert_template_argument (tree, tree, tree,
166 tsubst_flags_t, int, tree);
167static tree for_each_template_parm (tree, tree_fn_t, void*,
168 hash_set<tree> *, bool, tree_fn_t = NULL);
169static tree expand_template_argument_pack (tree);
170static tree build_template_parm_index (int, int, int, tree, tree);
171static bool inline_needs_template_parms (tree, bool);
172static void push_inline_template_parms_recursive (tree, int);
173static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
174static int mark_template_parm (tree, void *);
175static int template_parm_this_level_p (tree, void *);
176static tree tsubst_friend_function (tree, tree);
177static tree tsubst_friend_class (tree, tree);
178static int can_complete_type_without_circularity (tree);
179static tree get_bindings (tree, tree, tree, bool);
180static int template_decl_level (tree);
181static int check_cv_quals_for_unify (int, tree, tree);
182static void template_parm_level_and_index (tree, int*, int*);
183static int unify_pack_expansion (tree, tree, tree,
184 tree, unification_kind_t, bool, bool);
185static tree copy_template_args (tree);
186static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
187static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
188static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
189static tree most_specialized_partial_spec (tree, tsubst_flags_t);
190static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
191static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree);
192static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
193static bool check_specialization_scope (void);
194static tree process_partial_specialization (tree);
195static void set_current_access_from_decl (tree);
196static enum template_base_result get_template_base (tree, tree, tree, tree,
197 bool , tree *);
198static tree try_class_unification (tree, tree, tree, tree, bool);
199static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
200 tree, tree);
201static bool template_template_parm_bindings_ok_p (tree, tree);
202static void tsubst_default_arguments (tree, tsubst_flags_t);
203static tree for_each_template_parm_r (tree *, int *, void *);
204static tree copy_default_args_to_explicit_spec_1 (tree, tree);
205static void copy_default_args_to_explicit_spec (tree);
206static bool invalid_nontype_parm_type_p (tree, tsubst_flags_t);
207static bool dependent_template_arg_p (tree);
208static bool any_template_arguments_need_structural_equality_p (tree);
209static bool dependent_type_p_r (tree);
210static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
211static tree tsubst_decl (tree, tree, tsubst_flags_t);
212static void perform_typedefs_access_check (tree tmpl, tree targs);
213static void append_type_to_template_for_access_check_1 (tree, tree, tree,
214 location_t);
215static tree listify (tree);
216static tree listify_autos (tree, tree);
217static tree tsubst_template_parm (tree, tree, tsubst_flags_t);
218static tree instantiate_alias_template (tree, tree, tsubst_flags_t);
219static bool complex_alias_template_p (const_tree tmpl);
220static tree tsubst_attributes (tree, tree, tsubst_flags_t, tree);
221static tree canonicalize_expr_argument (tree, tsubst_flags_t);
222static tree make_argument_pack (tree);
223static 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
230static void
231push_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
254static void
255pop_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
274tree
275finish_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
319tree
320build_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
330tree
331get_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
374int
375template_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
401static bool
402inline_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
416static void
417push_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
464void
465maybe_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
501void
502maybe_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
522static tree
523add_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
552static tree
553add_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
579tree
580get_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
611static tree
612strip_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
642void
643begin_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
675static bool
676check_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
714bool
715begin_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
725void
726end_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
735void
736reset_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
745static void
746note_template_header (int specialization)
747{
748 processing_specialization = specialization;
749 template_header_count++;
750}
751
752/* We're beginning an explicit instantiation. */
753
754void
755begin_explicit_instantiation (void)
756{
757 gcc_assert (!processing_explicit_instantiation);
758 processing_explicit_instantiation = true;
759}
760
761
762void
763end_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
774static bool
775check_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
809static void
810check_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.
826static tree
827maybe_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
923tree
924maybe_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
1102static inline bool
1103optimize_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
1134static void
1135verify_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
1172static tree
1173retrieve_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
1250tree
1251retrieve_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
1262int
1263is_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
1293bool
1294is_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
1480static tree
1481register_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
1649int comparing_specializations;
1650
1651bool
1652spec_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
1678static hashval_t
1679hash_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
1688hashval_t
1689spec_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
1697hashval_t
1698iterative_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
1870bool
1871reregister_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
1895void
1896register_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
1905bool
1906explicit_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
1923static void
1924print_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
1951void
1952print_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. */
1961static tree
1962get_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. */
1979static tree
1980most_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
2029static tree
2030determine_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
2394static tree
2395copy_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
2428static void
2429copy_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
2515int
2516num_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
2551void
2552check_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
2591void
2592check_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
2648tree
2649check_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
3128int
3129comp_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
3183bool
3184template_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
3206bool
3207function_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
3217tree
3218get_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
3231bool
3232function_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
3246static bool
3247template_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
3269static tree
3270make_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
3292bool
3293primary_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
3314bool
3315template_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
3323bool
3324template_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
3335tree
3336get_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
3351tree
3352get_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
3370tree
3371get_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
3385tree
3386get_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
3398bool
3399builtin_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
3415static bool
3416builtin_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
3425static tree
3426expand_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
3475static tree
3476expand_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. */
3491struct 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. */
3508static tree
3509find_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. */
3710bool
3711uses_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. */
3728tree
3729make_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. */
3871bool
3872check_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. */
3928tree
3929expand_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
4001bool
4002check_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
4053static tree
4054build_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
4076static tree
4077canonical_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 (