OSDN Git Service

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