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  Free Software Foundation, Inc.
   4    Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
   5    Rewritten by Jason Merrill (jason@cygnus.com).
   6
   7 This file is part of GNU CC.
   8
   9 GNU CC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GNU CC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU CC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  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 "obstack.h"
  32
  33 #include "tree.h"
  34 #include "flags.h"
  35 #include "cp-tree.h"
  36 #include "decl.h"
  37 #include "parse.h"
  38 #include "lex.h"
  39 #include "output.h"
  40 #include "except.h"
  41 #include "toplev.h"
  42 #include "rtl.h"
  43 #include "ggc.h"
  44 #include "timevar.h"
  45
  46 /* The type of functions taking a tree, and some additional data, and
  47    returning an int.  */
  48 typedef int (*tree_fn_t) PARAMS ((tree, void*));
  49
  50 extern struct obstack permanent_obstack;
  51
  52 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
  53    instantiations have been deferred, either because their definitions
  54    were not yet available, or because we were putting off doing the
  55    work.  The TREE_PURPOSE of each entry is a SRCLOC indicating where
  56    the instantiate request occurred; the TREE_VALUE is a either a DECL
  57    (for a function or static data member), or a TYPE (for a class)
  58    indicating what we are hoping to instantiate.  */
  59 static tree pending_templates;
  60 static tree *template_tail = &pending_templates;
  61
  62 static tree maybe_templates;
  63 static tree *maybe_template_tail = &maybe_templates;
  64
  65 int processing_template_parmlist;
  66 static int template_header_count;
  67
  68 static tree saved_trees;
  69 static varray_type inline_parm_levels;
  70 static size_t inline_parm_levels_used;
  71
  72 static tree current_tinst_level;
  73
  74 /* A map from local variable declarations in the body of the template
  75    presently being instantiated to the corresponding instantiated
  76    local variables.  */
  77 static htab_t local_specializations;
  78
  79 #define obstack_chunk_alloc xmalloc
  80 #define obstack_chunk_free free
  81
  82 #define UNIFY_ALLOW_NONE 0
  83 #define UNIFY_ALLOW_MORE_CV_QUAL 1
  84 #define UNIFY_ALLOW_LESS_CV_QUAL 2
  85 #define UNIFY_ALLOW_DERIVED 4
  86 #define UNIFY_ALLOW_INTEGER 8
  87 #define UNIFY_ALLOW_OUTER_LEVEL 16
  88 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
  89 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
  90
  91 #define GTB_VIA_VIRTUAL 1 /* The base class we are examining is
  92                              virtual, or a base class of a virtual
  93                              base.  */
  94 #define GTB_IGNORE_TYPE 2 /* We don't need to try to unify the current
  95                              type with the desired type.  */
  96
  97 static int resolve_overloaded_unification PARAMS ((tree, tree, tree, tree,
  98                                                  unification_kind_t, int));
  99 static int try_one_overload PARAMS ((tree, tree, tree, tree, tree,
 100                                    unification_kind_t, int));
 101 static int unify PARAMS ((tree, tree, tree, tree, int));
 102 static void add_pending_template PARAMS ((tree));
 103 static int push_tinst_level PARAMS ((tree));
 104 static void reopen_tinst_level PARAMS ((tree));
 105 static tree classtype_mangled_name PARAMS ((tree));
 106 static char *mangle_class_name_for_template PARAMS ((const char *, tree, tree));
 107 static tree tsubst_initializer_list PARAMS ((tree, tree));
 108 static int list_eq PARAMS ((tree, tree));
 109 static tree get_class_bindings PARAMS ((tree, tree, tree));
 110 static tree coerce_template_parms PARAMS ((tree, tree, tree, int, int));
 111 static void tsubst_enum PARAMS ((tree, tree, tree));
 112 static tree add_to_template_args PARAMS ((tree, tree));
 113 static tree add_outermost_template_args PARAMS ((tree, tree));
 114 static int maybe_adjust_types_for_deduction PARAMS ((unification_kind_t, tree*,
 115                                                     tree*));
 116 static int  type_unification_real PARAMS ((tree, tree, tree, tree,
 117                                          int, unification_kind_t, int, int));
 118 static void note_template_header PARAMS ((int));
 119 static tree maybe_fold_nontype_arg PARAMS ((tree));
 120 static tree convert_nontype_argument PARAMS ((tree, tree));
 121 static tree convert_template_argument PARAMS ((tree, tree, tree, int,
 122                                               int , tree));
 123 static tree get_bindings_overload PARAMS ((tree, tree, tree));
 124 static int for_each_template_parm PARAMS ((tree, tree_fn_t, void*));
 125 static tree build_template_parm_index PARAMS ((int, int, int, tree, tree));
 126 static int inline_needs_template_parms PARAMS ((tree));
 127 static void push_inline_template_parms_recursive PARAMS ((tree, int));
 128 static tree retrieve_specialization PARAMS ((tree, tree));
 129 static tree retrieve_local_specialization PARAMS ((tree));
 130 static tree register_specialization PARAMS ((tree, tree, tree));
 131 static void register_local_specialization PARAMS ((tree, tree));
 132 static int unregister_specialization PARAMS ((tree, tree));
 133 static tree reduce_template_parm_level PARAMS ((tree, tree, int));
 134 static tree build_template_decl PARAMS ((tree, tree));
 135 static int mark_template_parm PARAMS ((tree, void *));
 136 static tree tsubst_friend_function PARAMS ((tree, tree));
 137 static tree tsubst_friend_class PARAMS ((tree, tree));
 138 static tree get_bindings_real PARAMS ((tree, tree, tree, int, int, int));
 139 static int template_decl_level PARAMS ((tree));
 140 static tree maybe_get_template_decl_from_type_decl PARAMS ((tree));
 141 static int check_cv_quals_for_unify PARAMS ((int, tree, tree));
 142 static tree tsubst_template_arg_vector PARAMS ((tree, tree, int));
 143 static tree tsubst_template_parms PARAMS ((tree, tree, int));
 144 static void regenerate_decl_from_template PARAMS ((tree, tree));
 145 static tree most_specialized PARAMS ((tree, tree, tree));
 146 static tree most_specialized_class PARAMS ((tree, tree));
 147 static void set_mangled_name_for_template_decl PARAMS ((tree));
 148 static int template_class_depth_real PARAMS ((tree, int));
 149 static tree tsubst_aggr_type PARAMS ((tree, tree, int, tree, int));
 150 static tree tsubst_decl PARAMS ((tree, tree, tree));
 151 static tree tsubst_arg_types PARAMS ((tree, tree, int, tree));
 152 static tree tsubst_function_type PARAMS ((tree, tree, int, tree));
 153 static void check_specialization_scope PARAMS ((void));
 154 static tree process_partial_specialization PARAMS ((tree));
 155 static void set_current_access_from_decl PARAMS ((tree));
 156 static void check_default_tmpl_args PARAMS ((tree, tree, int, int));
 157 static tree tsubst_call_declarator_parms PARAMS ((tree, tree, int, tree));
 158 static tree get_template_base_recursive PARAMS ((tree, tree,
 159                                                tree, tree, tree, int));
 160 static tree get_template_base PARAMS ((tree, tree, tree, tree));
 161 static int verify_class_unification PARAMS ((tree, tree, tree));
 162 static tree try_class_unification PARAMS ((tree, tree, tree, tree));
 163 static int coerce_template_template_parms PARAMS ((tree, tree, int,
 164                                                  tree, tree));
 165 static tree determine_specialization PARAMS ((tree, tree, tree *, int));
 166 static int template_args_equal PARAMS ((tree, tree));
 167 static void tsubst_default_arguments PARAMS ((tree));
 168 static tree for_each_template_parm_r PARAMS ((tree *, int *, void *));
 169 static tree instantiate_clone PARAMS ((tree, tree));
 170 static tree copy_default_args_to_explicit_spec_1 PARAMS ((tree, tree));
 171 static void copy_default_args_to_explicit_spec PARAMS ((tree));
 172 static int invalid_nontype_parm_type_p PARAMS ((tree, int));
 173
 174 /* Called once to initialize pt.c.  */
 175
 176 void
 177 init_pt ()
 178 {
 179   ggc_add_tree_root (&pending_templates, 1);
 180   ggc_add_tree_root (&maybe_templates, 1);
 181   ggc_add_tree_root (&saved_trees, 1);
 182   ggc_add_tree_root (&current_tinst_level, 1);
 183 }
 184
 185 /* Do any processing required when DECL (a member template declaration
 186    using TEMPLATE_PARAMETERS as its innermost parameter list) is
 187    finished.  Returns the TEMPLATE_DECL corresponding to DECL, unless
 188    it is a specialization, in which case the DECL itself is returned.  */
 189
 190 tree
 191 finish_member_template_decl (decl)
 192   tree decl;
 193 {
 194   if (decl == NULL_TREE || decl == void_type_node)
 195     return NULL_TREE;
 196   else if (decl == error_mark_node)
 197     /* By returning NULL_TREE, the parser will just ignore this
 198        declaration.  We have already issued the error.  */
 199     return NULL_TREE;
 200   else if (TREE_CODE (decl) == TREE_LIST)
 201     {
 202       /* Assume that the class is the only declspec.  */
 203       decl = TREE_VALUE (decl);
 204       if (IS_AGGR_TYPE (decl) && CLASSTYPE_TEMPLATE_INFO (decl)
 205           && ! CLASSTYPE_TEMPLATE_SPECIALIZATION (decl))
 206         {
 207           tree tmpl = CLASSTYPE_TI_TEMPLATE (decl);
 208           check_member_template (tmpl);
 209           return tmpl;
 210         }
 211       return NULL_TREE;
 212     }
 213   else if (TREE_CODE (decl) == FIELD_DECL)
 214     cp_error ("data member `%D' cannot be a member template", decl);
 215   else if (DECL_TEMPLATE_INFO (decl))
 216     {
 217       if (!DECL_TEMPLATE_SPECIALIZATION (decl))
 218         {
 219           check_member_template (DECL_TI_TEMPLATE (decl));
 220           return DECL_TI_TEMPLATE (decl);
 221         }
 222       else
 223         return decl;
 224     }
 225   else
 226     cp_error ("invalid member template declaration `%D'", decl);
 227
 228   return error_mark_node;
 229 }
 230
 231 /* Returns the template nesting level of the indicated class TYPE.
 232
 233    For example, in:
 234      template <class T>
 235      struct A
 236      {
 237        template <class U>
 238        struct B {};
 239      };
 240
 241    A<T>::B<U> has depth two, while A<T> has depth one.
 242    Both A<T>::B<int> and A<int>::B<U> have depth one, if
 243    COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
 244    specializations.
 245
 246    This function is guaranteed to return 0 if passed NULL_TREE so
 247    that, for example, `template_class_depth (current_class_type)' is
 248    always safe.  */
 249
 250 static int
 251 template_class_depth_real (type, count_specializations)
 252      tree type;
 253      int count_specializations;
 254 {
 255   int depth;
 256
 257   for (depth = 0;
 258        type && TREE_CODE (type) != NAMESPACE_DECL;
 259        type = (TREE_CODE (type) == FUNCTION_DECL)
 260          ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
 261     {
 262       if (TREE_CODE (type) != FUNCTION_DECL)
 263         {
 264           if (CLASSTYPE_TEMPLATE_INFO (type)
 265               && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
 266               && ((count_specializations
 267                    && CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
 268                   || uses_template_parms (CLASSTYPE_TI_ARGS (type))))
 269             ++depth;
 270         }
 271       else
 272         {
 273           if (DECL_TEMPLATE_INFO (type)
 274               && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
 275               && ((count_specializations
 276                    && DECL_TEMPLATE_SPECIALIZATION (type))
 277                   || uses_template_parms (DECL_TI_ARGS (type))))
 278             ++depth;
 279         }
 280     }
 281
 282   return depth;
 283 }
 284
 285 /* Returns the template nesting level of the indicated class TYPE.
 286    Like template_class_depth_real, but instantiations do not count in
 287    the depth.  */
 288
 289 int
 290 template_class_depth (type)
 291      tree type;
 292 {
 293   return template_class_depth_real (type, /*count_specializations=*/0);
 294 }
 295
 296 /* Returns 1 if processing DECL as part of do_pending_inlines
 297    needs us to push template parms.  */
 298
 299 static int
 300 inline_needs_template_parms (decl)
 301      tree decl;
 302 {
 303   if (! DECL_TEMPLATE_INFO (decl))
 304     return 0;
 305
 306   return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
 307           > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
 308 }
 309
 310 /* Subroutine of maybe_begin_member_template_processing.
 311    Push the template parms in PARMS, starting from LEVELS steps into the
 312    chain, and ending at the beginning, since template parms are listed
 313    innermost first.  */
 314
 315 static void
 316 push_inline_template_parms_recursive (parmlist, levels)
 317      tree parmlist;
 318      int levels;
 319 {
 320   tree parms = TREE_VALUE (parmlist);
 321   int i;
 322
 323   if (levels > 1)
 324     push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
 325
 326   ++processing_template_decl;
 327   current_template_parms
 328     = tree_cons (size_int (processing_template_decl),
 329                  parms, current_template_parms);
 330   TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
 331
 332   pushlevel (0);
 333   for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
 334     {
 335       tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
 336       my_friendly_assert (DECL_P (parm), 0);
 337
 338       switch (TREE_CODE (parm))
 339         {
 340         case TYPE_DECL:
 341         case TEMPLATE_DECL:
 342           pushdecl (parm);
 343           break;
 344
 345         case PARM_DECL:
 346           {
 347             /* Make a CONST_DECL as is done in process_template_parm.
 348                It is ugly that we recreate this here; the original
 349                version built in process_template_parm is no longer
 350                available.  */
 351             tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
 352                                     TREE_TYPE (parm));
 353             DECL_ARTIFICIAL (decl) = 1;
 354             DECL_INITIAL (decl) = DECL_INITIAL (parm);
 355             SET_DECL_TEMPLATE_PARM_P (decl);
 356             pushdecl (decl);
 357           }
 358           break;
 359
 360         default:
 361           my_friendly_abort (0);
 362         }
 363     }
 364 }
 365
 366 /* Restore the template parameter context for a member template or
 367    a friend template defined in a class definition.  */
 368
 369 void
 370 maybe_begin_member_template_processing (decl)
 371      tree decl;
 372 {
 373   tree parms;
 374   int levels = 0;
 375
 376   if (inline_needs_template_parms (decl))
 377     {
 378       parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
 379       levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
 380
 381       if (DECL_TEMPLATE_SPECIALIZATION (decl))
 382         {
 383           --levels;
 384           parms = TREE_CHAIN (parms);
 385         }
 386
 387       push_inline_template_parms_recursive (parms, levels);
 388     }
 389
 390   /* Remember how many levels of template parameters we pushed so that
 391      we can pop them later.  */
 392   if (!inline_parm_levels)
 393     VARRAY_INT_INIT (inline_parm_levels, 4, "inline_parm_levels");
 394   if (inline_parm_levels_used == inline_parm_levels->num_elements)
 395     VARRAY_GROW (inline_parm_levels, 2 * inline_parm_levels_used);
 396   VARRAY_INT (inline_parm_levels, inline_parm_levels_used) = levels;
 397   ++inline_parm_levels_used;
 398 }
 399
 400 /* Undo the effects of begin_member_template_processing. */
 401
 402 void
 403 maybe_end_member_template_processing ()
 404 {
 405   int i;
 406
 407   if (!inline_parm_levels_used)
 408     return;
 409
 410   --inline_parm_levels_used;
 411   for (i = 0;
 412        i < VARRAY_INT (inline_parm_levels, inline_parm_levels_used);
 413        ++i)
 414     {
 415       --processing_template_decl;
 416       current_template_parms = TREE_CHAIN (current_template_parms);
 417       poplevel (0, 0, 0);
 418     }
 419 }
 420
 421 /* Returns non-zero iff T is a member template function.  We must be
 422    careful as in
 423
 424      template <class T> class C { void f(); }
 425
 426    Here, f is a template function, and a member, but not a member
 427    template.  This function does not concern itself with the origin of
 428    T, only its present state.  So if we have
 429
 430      template <class T> class C { template <class U> void f(U); }
 431
 432    then neither C<int>::f<char> nor C<T>::f<double> is considered
 433    to be a member template.  But, `template <class U> void
 434    C<int>::f(U)' is considered a member template.  */
 435
 436 int
 437 is_member_template (t)
 438      tree t;
 439 {
 440   if (!DECL_FUNCTION_TEMPLATE_P (t))
 441     /* Anything that isn't a function or a template function is
 442        certainly not a member template.  */
 443     return 0;
 444
 445   /* A local class can't have member templates.  */
 446   if (decl_function_context (t))
 447     return 0;
 448
 449   return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t))
 450           /* If there are more levels of template parameters than
 451              there are template classes surrounding the declaration,
 452              then we have a member template.  */
 453           && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) >
 454               template_class_depth (DECL_CONTEXT (t))));
 455 }
 456
 457 #if 0 /* UNUSED */
 458 /* Returns non-zero iff T is a member template class.  See
 459    is_member_template for a description of what precisely constitutes
 460    a member template.  */
 461
 462 int
 463 is_member_template_class (t)
 464      tree t;
 465 {
 466   if (!DECL_CLASS_TEMPLATE_P (t))
 467     /* Anything that isn't a class template, is certainly not a member
 468        template.  */
 469     return 0;
 470
 471   if (!DECL_CLASS_SCOPE_P (t))
 472     /* Anything whose context isn't a class type is surely not a
 473        member template.  */
 474     return 0;
 475
 476   /* If there are more levels of template parameters than there are
 477      template classes surrounding the declaration, then we have a
 478      member template.  */
 479   return  (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) >
 480            template_class_depth (DECL_CONTEXT (t)));
 481 }
 482 #endif
 483
 484 /* Return a new template argument vector which contains all of ARGS,
 485    but has as its innermost set of arguments the EXTRA_ARGS.  */
 486
 487 static tree
 488 add_to_template_args (args, extra_args)
 489      tree args;
 490      tree extra_args;
 491 {
 492   tree new_args;
 493   int extra_depth;
 494   int i;
 495   int j;
 496
 497   extra_depth = TMPL_ARGS_DEPTH (extra_args);
 498   new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
 499
 500   for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
 501     SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
 502
 503   for (j = 1; j <= extra_depth; ++j, ++i)
 504     SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
 505
 506   return new_args;
 507 }
 508
 509 /* Like add_to_template_args, but only the outermost ARGS are added to
 510    the EXTRA_ARGS.  In particular, all but TMPL_ARGS_DEPTH
 511    (EXTRA_ARGS) levels are added.  This function is used to combine
 512    the template arguments from a partial instantiation with the
 513    template arguments used to attain the full instantiation from the
 514    partial instantiation.  */
 515
 516 static tree
 517 add_outermost_template_args (args, extra_args)
 518      tree args;
 519      tree extra_args;
 520 {
 521   tree new_args;
 522
 523   /* If there are more levels of EXTRA_ARGS than there are ARGS,
 524      something very fishy is going on.  */
 525   my_friendly_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args),
 526                       0);
 527
 528   /* If *all* the new arguments will be the EXTRA_ARGS, just return
 529      them.  */
 530   if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
 531     return extra_args;
 532
 533   /* For the moment, we make ARGS look like it contains fewer levels.  */
 534   TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
 535
 536   new_args = add_to_template_args (args, extra_args);
 537
 538   /* Now, we restore ARGS to its full dimensions.  */
 539   TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
 540
 541   return new_args;
 542 }
 543
 544 /* Return the N levels of innermost template arguments from the ARGS.  */
 545
 546 tree
 547 get_innermost_template_args (args, n)
 548      tree args;
 549      int n;
 550 {
 551   tree new_args;
 552   int extra_levels;
 553   int i;
 554
 555   my_friendly_assert (n >= 0, 20000603);
 556
 557   /* If N is 1, just return the innermost set of template arguments.  */
 558   if (n == 1)
 559     return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
 560
 561   /* If we're not removing anything, just return the arguments we were
 562      given.  */
 563   extra_levels = TMPL_ARGS_DEPTH (args) - n;
 564   my_friendly_assert (extra_levels >= 0, 20000603);
 565   if (extra_levels == 0)
 566     return args;
 567
 568   /* Make a new set of arguments, not containing the outer arguments.  */
 569   new_args = make_tree_vec (n);
 570   for (i = 1; i <= n; ++i)
 571     SET_TMPL_ARGS_LEVEL (new_args, i,
 572                          TMPL_ARGS_LEVEL (args, i + extra_levels));
 573
 574   return new_args;
 575 }
 576
 577 /* We've got a template header coming up; push to a new level for storing
 578    the parms.  */
 579
 580 void
 581 begin_template_parm_list ()
 582 {
 583   /* We use a non-tag-transparent scope here, which causes pushtag to
 584      put tags in this scope, rather than in the enclosing class or
 585      namespace scope.  This is the right thing, since we want
 586      TEMPLATE_DECLS, and not TYPE_DECLS for template classes.  For a
 587      global template class, push_template_decl handles putting the
 588      TEMPLATE_DECL into top-level scope.  For a nested template class,
 589      e.g.:
 590
 591        template <class T> struct S1 {
 592          template <class T> struct S2 {};
 593        };
 594
 595      pushtag contains special code to call pushdecl_with_scope on the
 596      TEMPLATE_DECL for S2.  */
 597   begin_scope (sk_template_parms);
 598   ++processing_template_decl;
 599   ++processing_template_parmlist;
 600   note_template_header (0);
 601 }
 602
 603 /* This routine is called when a specialization is declared.  If it is
 604    illegal to declare a specialization here, an error is reported.  */
 605
 606 static void
 607 check_specialization_scope ()
 608 {
 609   tree scope = current_scope ();
 610
 611   /* [temp.expl.spec]
 612
 613      An explicit specialization shall be declared in the namespace of
 614      which the template is a member, or, for member templates, in the
 615      namespace of which the enclosing class or enclosing class
 616      template is a member.  An explicit specialization of a member
 617      function, member class or static data member of a class template
 618      shall be declared in the namespace of which the class template
 619      is a member.  */
 620   if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
 621     cp_error ("explicit specialization in non-namespace scope `%D'",
 622               scope);
 623
 624   /* [temp.expl.spec]
 625
 626      In an explicit specialization declaration for a member of a class
 627      template or a member template that appears in namespace scope,
 628      the member template and some of its enclosing class templates may
 629      remain unspecialized, except that the declaration shall not
 630      explicitly specialize a class member template if its enclosing
 631      class templates are not explicitly specialized as well.  */
 632   if (current_template_parms)
 633     cp_error ("enclosing class templates are not explicitly specialized");
 634 }
 635
 636 /* We've just seen template <>. */
 637
 638 void
 639 begin_specialization ()
 640 {
 641   begin_scope (sk_template_spec);
 642   note_template_header (1);
 643   check_specialization_scope ();
 644 }
 645
 646 /* Called at then end of processing a declaration preceded by
 647    template<>.  */
 648
 649 void
 650 end_specialization ()
 651 {
 652   finish_scope ();
 653   reset_specialization ();
 654 }
 655
 656 /* Any template <>'s that we have seen thus far are not referring to a
 657    function specialization. */
 658
 659 void
 660 reset_specialization ()
 661 {
 662   processing_specialization = 0;
 663   template_header_count = 0;
 664 }
 665
 666 /* We've just seen a template header.  If SPECIALIZATION is non-zero,
 667    it was of the form template <>.  */
 668
 669 static void
 670 note_template_header (specialization)
 671      int specialization;
 672 {
 673   processing_specialization = specialization;
 674   template_header_count++;
 675 }
 676
 677 /* We're beginning an explicit instantiation.  */
 678
 679 void
 680 begin_explicit_instantiation ()
 681 {
 682   ++processing_explicit_instantiation;
 683 }
 684
 685
 686 void
 687 end_explicit_instantiation ()
 688 {
 689   my_friendly_assert(processing_explicit_instantiation > 0, 0);
 690   --processing_explicit_instantiation;
 691 }
 692
 693 /* The TYPE is being declared.  If it is a template type, that means it
 694    is a partial specialization.  Do appropriate error-checking.  */
 695
 696 void
 697 maybe_process_partial_specialization (type)
 698      tree type;
 699 {
 700   if (IS_AGGR_TYPE (type) && CLASSTYPE_USE_TEMPLATE (type))
 701     {
 702       if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
 703           && !COMPLETE_TYPE_P (type))
 704         {
 705           if (current_namespace
 706               != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
 707             {
 708               cp_pedwarn ("specializing `%#T' in different namespace", type);
 709               cp_pedwarn_at ("  from definition of `%#D'",
 710                              CLASSTYPE_TI_TEMPLATE (type));
 711             }
 712           SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
 713           if (processing_template_decl)
 714             push_template_decl (TYPE_MAIN_DECL (type));
 715         }
 716       else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
 717         cp_error ("specialization of `%T' after instantiation", type);
 718     }
 719   else if (processing_specialization)
 720     cp_error ("explicit specialization of non-template `%T'", type);
 721 }
 722
 723 /* Retrieve the specialization (in the sense of [temp.spec] - a
 724    specialization is either an instantiation or an explicit
 725    specialization) of TMPL for the given template ARGS.  If there is
 726    no such specialization, return NULL_TREE.  The ARGS are a vector of
 727    arguments, or a vector of vectors of arguments, in the case of
 728    templates with more than one level of parameters.  */
 729
 730 static tree
 731 retrieve_specialization (tmpl, args)
 732      tree tmpl;
 733      tree args;
 734 {
 735   tree s;
 736
 737   my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
 738
 739   /* There should be as many levels of arguments as there are
 740      levels of parameters.  */
 741   my_friendly_assert (TMPL_ARGS_DEPTH (args)
 742                       == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)),
 743                       0);
 744
 745   for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
 746        s != NULL_TREE;
 747        s = TREE_CHAIN (s))
 748     if (comp_template_args (TREE_PURPOSE (s), args))
 749       return TREE_VALUE (s);
 750
 751   return NULL_TREE;
 752 }
 753
 754 /* Like retrieve_specialization, but for local declarations.  */
 755
 756 static tree
 757 retrieve_local_specialization (tmpl)
 758      tree tmpl;
 759 {
 760   return (tree) htab_find (local_specializations, tmpl);
 761 }
 762
 763 /* Returns non-zero iff DECL is a specialization of TMPL.  */
 764
 765 int
 766 is_specialization_of (decl, tmpl)
 767      tree decl;
 768      tree tmpl;
 769 {
 770   tree t;
 771
 772   if (TREE_CODE (decl) == FUNCTION_DECL)
 773     {
 774       for (t = decl;
 775            t != NULL_TREE;
 776            t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
 777         if (t == tmpl)
 778           return 1;
 779     }
 780   else
 781     {
 782       my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 0);
 783
 784       for (t = TREE_TYPE (decl);
 785            t != NULL_TREE;
 786            t = CLASSTYPE_USE_TEMPLATE (t)
 787              ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
 788         if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
 789           return 1;
 790     }
 791
 792   return 0;
 793 }
 794
 795 /* Register the specialization SPEC as a specialization of TMPL with
 796    the indicated ARGS.  Returns SPEC, or an equivalent prior
 797    declaration, if available.  */
 798
 799 static tree
 800 register_specialization (spec, tmpl, args)
 801      tree spec;
 802      tree tmpl;
 803      tree args;
 804 {
 805   tree s;
 806
 807   my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
 808
 809   if (TREE_CODE (spec) == FUNCTION_DECL
 810       && uses_template_parms (DECL_TI_ARGS (spec)))
 811     /* This is the FUNCTION_DECL for a partial instantiation.  Don't
 812        register it; we want the corresponding TEMPLATE_DECL instead.
 813        We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
 814        the more obvious `uses_template_parms (spec)' to avoid problems
 815        with default function arguments.  In particular, given
 816        something like this:
 817
 818           template <class T> void f(T t1, T t = T())
 819
 820        the default argument expression is not substituted for in an
 821        instantiation unless and until it is actually needed.  */
 822     return spec;
 823
 824   /* There should be as many levels of arguments as there are
 825      levels of parameters.  */
 826   my_friendly_assert (TMPL_ARGS_DEPTH (args)
 827                       == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)),
 828                       0);
 829
 830   for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
 831        s != NULL_TREE;
 832        s = TREE_CHAIN (s))
 833     {
 834       tree fn = TREE_VALUE (s);
 835
 836       /* We can sometimes try to re-register a specialization that we've
 837          already got.  In particular, regenerate_decl_from_template
 838          calls duplicate_decls which will update the specialization
 839          list.  But, we'll still get called again here anyhow.  It's
 840          more convenient to simply allow this than to try to prevent it.  */
 841       if (fn == spec)
 842         return spec;
 843       else if (comp_template_args (TREE_PURPOSE (s), args))
 844         {
 845           if (DECL_TEMPLATE_SPECIALIZATION (spec))
 846             {
 847               if (DECL_TEMPLATE_INSTANTIATION (fn))
 848                 {
 849                   if (TREE_USED (fn)
 850                       || DECL_EXPLICIT_INSTANTIATION (fn))
 851                     {
 852                       cp_error ("specialization of %D after instantiation",
 853                                 fn);
 854                       return spec;
 855                     }
 856                   else
 857                     {
 858                       /* This situation should occur only if the first
 859                          specialization is an implicit instantiation,
 860                          the second is an explicit specialization, and
 861                          the implicit instantiation has not yet been
 862                          used.  That situation can occur if we have
 863                          implicitly instantiated a member function and
 864                          then specialized it later.
 865
 866                          We can also wind up here if a friend
 867                          declaration that looked like an instantiation
 868                          turns out to be a specialization:
 869
 870                            template <class T> void foo(T);
 871                            class S { friend void foo<>(int) };
 872                            template <> void foo(int);
 873
 874                          We transform the existing DECL in place so that
 875                          any pointers to it become pointers to the
 876                          updated declaration.
 877
 878                          If there was a definition for the template, but
 879                          not for the specialization, we want this to
 880                          look as if there is no definition, and vice
 881                          versa.  */
 882                       DECL_INITIAL (fn) = NULL_TREE;
 883                       duplicate_decls (spec, fn);
 884
 885                       return fn;
 886                     }
 887                 }
 888               else if (DECL_TEMPLATE_SPECIALIZATION (fn))
 889                 {
 890                   duplicate_decls (spec, fn);
 891                   return fn;
 892                 }
 893             }
 894         }
 895       }
 896
 897   DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
 898      = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
 899
 900   return spec;
 901 }
 902
 903 /* Unregister the specialization SPEC as a specialization of TMPL.
 904    Returns nonzero if the SPEC was listed as a specialization of
 905    TMPL.  */
 906
 907 static int
 908 unregister_specialization (spec, tmpl)
 909      tree spec;
 910      tree tmpl;
 911 {
 912   tree* s;
 913
 914   for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
 915        *s != NULL_TREE;
 916        s = &TREE_CHAIN (*s))
 917     if (TREE_VALUE (*s) == spec)
 918       {
 919         *s = TREE_CHAIN (*s);
 920         return 1;
 921       }
 922
 923   return 0;
 924 }
 925
 926 /* Like register_specialization, but for local declarations.  We are
 927    registering SPEC, an instantiation of TMPL.  */
 928
 929 static void
 930 register_local_specialization (spec, tmpl)
 931      tree spec;
 932      tree tmpl;
 933 {
 934   void **slot;
 935
 936   slot = htab_find_slot (local_specializations, tmpl, INSERT);
 937   *slot = spec;
 938 }
 939
 940 /* Print the list of candidate FNS in an error message.  */
 941
 942 void
 943 print_candidates (fns)
 944      tree fns;
 945 {
 946   tree fn;
 947
 948   const char *str = "candidates are:";
 949
 950   for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
 951     {
 952       tree f;
 953
 954       for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
 955         cp_error_at ("%s %+#D", str, OVL_CURRENT (f));
 956       str = "               ";
 957     }
 958 }
 959
 960 /* Returns the template (one of the functions given by TEMPLATE_ID)
 961    which can be specialized to match the indicated DECL with the
 962    explicit template args given in TEMPLATE_ID.  The DECL may be
 963    NULL_TREE if none is available.  In that case, the functions in
 964    TEMPLATE_ID are non-members.
 965
 966    If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a
 967    specialization of a member template.
 968
 969    The template args (those explicitly specified and those deduced)
 970    are output in a newly created vector *TARGS_OUT.
 971
 972    If it is impossible to determine the result, an error message is
 973    issued.  The error_mark_node is returned to indicate failure.  */
 974
 975 static tree
 976 determine_specialization (template_id, decl, targs_out,
 977                           need_member_template)
 978      tree template_id;
 979      tree decl;
 980      tree* targs_out;
 981      int need_member_template;
 982 {
 983   tree fns;
 984   tree targs;
 985   tree explicit_targs;
 986   tree candidates = NULL_TREE;
 987   tree templates = NULL_TREE;
 988
 989   *targs_out = NULL_TREE;
 990
 991   if (template_id == error_mark_node)
 992     return error_mark_node;
 993
 994   fns = TREE_OPERAND (template_id, 0);
 995   explicit_targs = TREE_OPERAND (template_id, 1);
 996
 997   if (fns == error_mark_node)
 998     return error_mark_node;
 999
1000   /* Check for baselinks. */
1001   if (BASELINK_P (fns))
1002     fns = TREE_VALUE (fns);
1003
1004   if (!is_overloaded_fn (fns))
1005     {
1006       cp_error ("`%D' is not a function template", fns);
1007       return error_mark_node;
1008     }
1009
1010   for (; fns; fns = OVL_NEXT (fns))
1011     {
1012       tree tmpl;
1013
1014       tree fn = OVL_CURRENT (fns);
1015
1016       if (TREE_CODE (fn) == TEMPLATE_DECL)
1017         /* DECL might be a specialization of FN.  */
1018         tmpl = fn;
1019       else if (need_member_template)
1020         /* FN is an ordinary member function, and we need a
1021            specialization of a member template.  */
1022         continue;
1023       else if (TREE_CODE (fn) != FUNCTION_DECL)
1024         /* We can get IDENTIFIER_NODEs here in certain erroneous
1025            cases.  */
1026         continue;
1027       else if (!DECL_FUNCTION_MEMBER_P (fn))
1028         /* This is just an ordinary non-member function.  Nothing can
1029            be a specialization of that.  */
1030         continue;
1031       else
1032         {
1033           tree decl_arg_types;
1034
1035           /* This is an ordinary member function.  However, since
1036              we're here, we can assume it's enclosing class is a
1037              template class.  For example,
1038
1039                template <typename T> struct S { void f(); };
1040                template <> void S<int>::f() {}
1041
1042              Here, S<int>::f is a non-template, but S<int> is a
1043              template class.  If FN has the same type as DECL, we
1044              might be in business.  */
1045           if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1046                             TREE_TYPE (TREE_TYPE (fn))))
1047             /* The return types differ.  */
1048             continue;
1049
1050           /* Adjust the type of DECL in case FN is a static member.  */
1051           decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1052           if (DECL_STATIC_FUNCTION_P (fn)
1053               && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1054             decl_arg_types = TREE_CHAIN (decl_arg_types);
1055
1056           if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1057                          decl_arg_types))
1058             /* They match!  */
1059             candidates = tree_cons (NULL_TREE, fn, candidates);
1060
1061           continue;
1062         }
1063
1064       /* See whether this function might be a specialization of this
1065          template.  */
1066       targs = get_bindings (tmpl, decl, explicit_targs);
1067
1068       if (!targs)
1069         /* We cannot deduce template arguments that when used to
1070            specialize TMPL will produce DECL.  */
1071         continue;
1072
1073       /* Save this template, and the arguments deduced.  */
1074       templates = tree_cons (targs, tmpl, templates);
1075     }
1076
1077   if (templates && TREE_CHAIN (templates))
1078     {
1079       /* We have:
1080
1081            [temp.expl.spec]
1082
1083            It is possible for a specialization with a given function
1084            signature to be instantiated from more than one function
1085            template.  In such cases, explicit specification of the
1086            template arguments must be used to uniquely identify the
1087            function template specialization being specialized.
1088
1089          Note that here, there's no suggestion that we're supposed to
1090          determine which of the candidate templates is most
1091          specialized.  However, we, also have:
1092
1093            [temp.func.order]
1094
1095            Partial ordering of overloaded function template
1096            declarations is used in the following contexts to select
1097            the function template to which a function template
1098            specialization refers:
1099
1100            -- when an explicit specialization refers to a function
1101               template.
1102
1103          So, we do use the partial ordering rules, at least for now.
1104          This extension can only serve to make illegal programs legal,
1105          so it's safe.  And, there is strong anecdotal evidence that
1106          the committee intended the partial ordering rules to apply;
1107          the EDG front-end has that behavior, and John Spicer claims
1108          that the committee simply forgot to delete the wording in
1109          [temp.expl.spec].  */
1110      tree tmpl = most_specialized (templates, decl, explicit_targs);
1111      if (tmpl && tmpl != error_mark_node)
1112        {
1113          targs = get_bindings (tmpl, decl, explicit_targs);
1114          templates = tree_cons (targs, tmpl, NULL_TREE);
1115        }
1116     }
1117
1118   if (templates == NULL_TREE && candidates == NULL_TREE)
1119     {
1120       cp_error_at ("template-id `%D' for `%+D' does not match any template declaration",
1121                    template_id, decl);
1122       return error_mark_node;
1123     }
1124   else if ((templates && TREE_CHAIN (templates))
1125            || (candidates && TREE_CHAIN (candidates))
1126            || (templates && candidates))
1127     {
1128       cp_error_at ("ambiguous template specialization `%D' for `%+D'",
1129                    template_id, decl);
1130       chainon (candidates, templates);
1131       print_candidates (candidates);
1132       return error_mark_node;
1133     }
1134
1135   /* We have one, and exactly one, match. */
1136   if (candidates)
1137     {
1138       /* It was a specialization of an ordinary member function in a
1139          template class.  */
1140       *targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates)));
1141       return DECL_TI_TEMPLATE (TREE_VALUE (candidates));
1142     }
1143
1144   /* It was a specialization of a template.  */
1145   targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1146   if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1147     {
1148       *targs_out = copy_node (targs);
1149       SET_TMPL_ARGS_LEVEL (*targs_out,
1150                            TMPL_ARGS_DEPTH (*targs_out),
1151                            TREE_PURPOSE (templates));
1152     }
1153   else
1154     *targs_out = TREE_PURPOSE (templates);
1155   return TREE_VALUE (templates);
1156 }
1157
1158 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1159    but with the default argument values filled in from those in the
1160    TMPL_TYPES.  */
1161
1162 static tree
1163 copy_default_args_to_explicit_spec_1 (spec_types,
1164                                       tmpl_types)
1165      tree spec_types;
1166      tree tmpl_types;
1167 {
1168   tree new_spec_types;
1169
1170   if (!spec_types)
1171     return NULL_TREE;
1172
1173   if (spec_types == void_list_node)
1174     return void_list_node;
1175
1176   /* Substitute into the rest of the list.  */
1177   new_spec_types =
1178     copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1179                                           TREE_CHAIN (tmpl_types));
1180
1181   /* Add the default argument for this parameter.  */
1182   return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1183                          TREE_VALUE (spec_types),
1184                          new_spec_types);
1185 }
1186
1187 /* DECL is an explicit specialization.  Replicate default arguments
1188    from the template it specializes.  (That way, code like:
1189
1190      template <class T> void f(T = 3);
1191      template <> void f(double);
1192      void g () { f (); }
1193
1194    works, as required.)  An alternative approach would be to look up
1195    the correct default arguments at the call-site, but this approach
1196    is consistent with how implicit instantiations are handled.  */
1197
1198 static void
1199 copy_default_args_to_explicit_spec (decl)
1200      tree decl;
1201 {
1202   tree tmpl;
1203   tree spec_types;
1204   tree tmpl_types;
1205   tree new_spec_types;
1206   tree old_type;
1207   tree new_type;
1208   tree t;
1209   tree object_type = NULL_TREE;
1210   tree in_charge = NULL_TREE;
1211
1212   /* See if there's anything we need to do.  */
1213   tmpl = DECL_TI_TEMPLATE (decl);
1214   tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1215   for (t = tmpl_types; t; t = TREE_CHAIN (t))
1216     if (TREE_PURPOSE (t))
1217       break;
1218   if (!t)
1219     return;
1220
1221   old_type = TREE_TYPE (decl);
1222   spec_types = TYPE_ARG_TYPES (old_type);
1223
1224   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1225     {
1226       /* Remove the this pointer, but remember the object's type for
1227          CV quals.  */
1228       object_type = TREE_TYPE (TREE_VALUE (spec_types));
1229       spec_types = TREE_CHAIN (spec_types);
1230       tmpl_types = TREE_CHAIN (tmpl_types);
1231
1232       if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1233         {
1234           /* DECL may contain more parameters than TMPL due to the extra
1235              in-charge parameter in constructors and destructors.  */
1236           in_charge = spec_types;
1237           spec_types = TREE_CHAIN (spec_types);
1238         }
1239     }
1240
1241   /* Compute the merged default arguments.  */
1242   new_spec_types =
1243     copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1244
1245   /* Compute the new FUNCTION_TYPE.  */
1246   if (object_type)
1247     {
1248       if (in_charge)
1249         /* Put the in-charge parameter back.  */
1250         new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1251                                          TREE_VALUE (in_charge),
1252                                          new_spec_types);
1253
1254       new_type = build_cplus_method_type (object_type,
1255                                           TREE_TYPE (old_type),
1256                                           new_spec_types);
1257     }
1258   else
1259     new_type = build_function_type (TREE_TYPE (old_type),
1260                                     new_spec_types);
1261   new_type = build_type_attribute_variant (new_type,
1262                                            TYPE_ATTRIBUTES (old_type));
1263   new_type = build_exception_variant (new_type,
1264                                       TYPE_RAISES_EXCEPTIONS (old_type));
1265   TREE_TYPE (decl) = new_type;
1266 }
1267
1268 /* Check to see if the function just declared, as indicated in
1269    DECLARATOR, and in DECL, is a specialization of a function
1270    template.  We may also discover that the declaration is an explicit
1271    instantiation at this point.
1272
1273    Returns DECL, or an equivalent declaration that should be used
1274    instead if all goes well.  Issues an error message if something is
1275    amiss.  Returns error_mark_node if the error is not easily
1276    recoverable.
1277
1278    FLAGS is a bitmask consisting of the following flags:
1279
1280    2: The function has a definition.
1281    4: The function is a friend.
1282
1283    The TEMPLATE_COUNT is the number of references to qualifying
1284    template classes that appeared in the name of the function.  For
1285    example, in
1286
1287      template <class T> struct S { void f(); };
1288      void S<int>::f();
1289
1290    the TEMPLATE_COUNT would be 1.  However, explicitly specialized
1291    classes are not counted in the TEMPLATE_COUNT, so that in
1292
1293      template <class T> struct S {};
1294      template <> struct S<int> { void f(); }
1295      template <> void S<int>::f();
1296
1297    the TEMPLATE_COUNT would be 0.  (Note that this declaration is
1298    illegal; there should be no template <>.)
1299
1300    If the function is a specialization, it is marked as such via
1301    DECL_TEMPLATE_SPECIALIZATION.  Furthermore, its DECL_TEMPLATE_INFO
1302    is set up correctly, and it is added to the list of specializations
1303    for that template.  */
1304
1305 tree
1306 check_explicit_specialization (declarator, decl, template_count, flags)
1307      tree declarator;
1308      tree decl;
1309      int template_count;
1310      int flags;
1311 {
1312   int have_def = flags & 2;
1313   int is_friend = flags & 4;
1314   int specialization = 0;
1315   int explicit_instantiation = 0;
1316   int member_specialization = 0;
1317   tree ctype = DECL_CLASS_CONTEXT (decl);
1318   tree dname = DECL_NAME (decl);
1319   tmpl_spec_kind tsk;
1320
1321   tsk = current_tmpl_spec_kind (template_count);
1322
1323   switch (tsk)
1324     {
1325     case tsk_none:
1326       if (processing_specialization)
1327         {
1328           specialization = 1;
1329           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1330         }
1331       else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1332         {
1333           if (is_friend)
1334             /* This could be something like:
1335
1336                template <class T> void f(T);
1337                class S { friend void f<>(int); }  */
1338             specialization = 1;
1339           else
1340             {
1341               /* This case handles bogus declarations like template <>
1342                  template <class T> void f<int>(); */
1343
1344               cp_error ("template-id `%D' in declaration of primary template",
1345                         declarator);
1346               return decl;
1347             }
1348         }
1349       break;
1350
1351     case tsk_invalid_member_spec:
1352       /* The error has already been reported in
1353          check_specialization_scope.  */
1354       return error_mark_node;
1355
1356     case tsk_invalid_expl_inst:
1357       cp_error ("template parameter list used in explicit instantiation");
1358
1359       /* Fall through.  */
1360
1361     case tsk_expl_inst:
1362       if (have_def)
1363         cp_error ("definition provided for explicit instantiation");
1364
1365       explicit_instantiation = 1;
1366       break;
1367
1368     case tsk_excessive_parms:
1369       cp_error ("too many template parameter lists in declaration of `%D'",
1370                 decl);
1371       return error_mark_node;
1372
1373       /* Fall through.  */
1374     case tsk_expl_spec:
1375       SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1376       if (ctype)
1377         member_specialization = 1;
1378       else
1379         specialization = 1;
1380       break;
1381
1382     case tsk_insufficient_parms:
1383       if (template_header_count)
1384         {
1385           cp_error("too few template parameter lists in declaration of `%D'",
1386                    decl);
1387           return decl;
1388         }
1389       else if (ctype != NULL_TREE
1390                && !TYPE_BEING_DEFINED (ctype)
1391                && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype)
1392                && !is_friend)
1393         {
1394           /* For backwards compatibility, we accept:
1395
1396                template <class T> struct S { void f(); };
1397                void S<int>::f() {} // Missing template <>
1398
1399              That used to be legal C++.  */
1400           if (pedantic)
1401             cp_pedwarn
1402               ("explicit specialization not preceded by `template <>'");
1403           specialization = 1;
1404           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1405         }
1406       break;
1407
1408     case tsk_template:
1409       if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1410         {
1411           /* This case handles bogus declarations like template <>
1412              template <class T> void f<int>(); */
1413
1414           if (uses_template_parms (declarator))
1415             cp_error ("partial specialization `%D' of function template",
1416                       declarator);
1417           else
1418             cp_error ("template-id `%D' in declaration of primary template",
1419                       declarator);
1420           return decl;
1421         }
1422
1423       if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1424         /* This is a specialization of a member template, without
1425            specialization the containing class.  Something like:
1426
1427              template <class T> struct S {
1428                template <class U> void f (U);
1429              };
1430              template <> template <class U> void S<int>::f(U) {}
1431
1432            That's a specialization -- but of the entire template.  */
1433         specialization = 1;
1434       break;
1435
1436     default:
1437       my_friendly_abort (20000309);
1438     }
1439
1440   if (specialization || member_specialization)
1441     {
1442       tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1443       for (; t; t = TREE_CHAIN (t))
1444         if (TREE_PURPOSE (t))
1445           {
1446             cp_pedwarn
1447               ("default argument specified in explicit specialization");
1448             break;
1449           }
1450       if (current_lang_name == lang_name_c)
1451         cp_error ("template specialization with C linkage");
1452     }
1453
1454   if (specialization || member_specialization || explicit_instantiation)
1455     {
1456       tree tmpl = NULL_TREE;
1457       tree targs = NULL_TREE;
1458
1459       /* Make sure that the declarator is a TEMPLATE_ID_EXPR.  */
1460       if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1461         {
1462           tree fns;
1463
1464           my_friendly_assert (TREE_CODE (declarator) == IDENTIFIER_NODE,
1465                               0);
1466           if (!ctype)
1467             fns = IDENTIFIER_NAMESPACE_VALUE (dname);
1468           else
1469             fns = dname;
1470
1471           declarator =
1472             lookup_template_function (fns, NULL_TREE);
1473         }
1474
1475       if (declarator == error_mark_node)
1476         return error_mark_node;
1477
1478       if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1479         {
1480           if (!explicit_instantiation)
1481             /* A specialization in class scope.  This is illegal,
1482                but the error will already have been flagged by
1483                check_specialization_scope.  */
1484             return error_mark_node;
1485           else
1486             {
1487               /* It's not legal to write an explicit instantiation in
1488                  class scope, e.g.:
1489
1490                    class C { template void f(); }
1491
1492                    This case is caught by the parser.  However, on
1493                    something like:
1494
1495                    template class C { void f(); };
1496
1497                    (which is illegal) we can get here.  The error will be
1498                    issued later.  */
1499               ;
1500             }
1501
1502           return decl;
1503         }
1504       else if (TREE_CODE (TREE_OPERAND (declarator, 0)) == LOOKUP_EXPR)
1505         {
1506           /* A friend declaration.  We can't do much, because we don't
1507              know what this resolves to, yet.  */
1508           my_friendly_assert (is_friend != 0, 0);
1509           my_friendly_assert (!explicit_instantiation, 0);
1510           SET_DECL_IMPLICIT_INSTANTIATION (decl);
1511           return decl;
1512         }
1513       else if (ctype != NULL_TREE
1514                && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
1515                    IDENTIFIER_NODE))
1516         {
1517           /* Find the list of functions in ctype that have the same
1518              name as the declared function.  */
1519           tree name = TREE_OPERAND (declarator, 0);
1520           tree fns = NULL_TREE;
1521           int idx;
1522
1523           if (name == constructor_name (ctype)
1524               || name == constructor_name_full (ctype))
1525             {
1526               int is_constructor = DECL_CONSTRUCTOR_P (decl);
1527
1528               if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
1529                   : !TYPE_HAS_DESTRUCTOR (ctype))
1530                 {
1531                   /* From [temp.expl.spec]:
1532
1533                      If such an explicit specialization for the member
1534                      of a class template names an implicitly-declared
1535                      special member function (clause _special_), the
1536                      program is ill-formed.
1537
1538                      Similar language is found in [temp.explicit].  */
1539                   cp_error ("specialization of implicitly-declared special member function");
1540                   return error_mark_node;
1541                 }
1542
1543               name = is_constructor ? ctor_identifier : dtor_identifier;
1544             }
1545
1546           if (!DECL_CONV_FN_P (decl))
1547             {
1548               idx = lookup_fnfields_1 (ctype, name);
1549               if (idx >= 0)
1550                 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), idx);
1551             }
1552           else
1553             {
1554               tree methods;
1555
1556               /* For a type-conversion operator, we cannot do a
1557                  name-based lookup.  We might be looking for `operator
1558                  int' which will be a specialization of `operator T'.
1559                  So, we find *all* the conversion operators, and then
1560                  select from them.  */
1561               fns = NULL_TREE;
1562
1563               methods = CLASSTYPE_METHOD_VEC (ctype);
1564               if (methods)
1565                 for (idx = 2; idx < TREE_VEC_LENGTH (methods); ++idx)
1566                   {
1567                     tree ovl = TREE_VEC_ELT (methods, idx);
1568
1569                     if (!ovl || !DECL_CONV_FN_P (OVL_CURRENT (ovl)))
1570                       /* There are no more conversion functions.  */
1571                       break;
1572
1573                     /* Glue all these conversion functions together
1574                        with those we already have.  */
1575                     for (; ovl; ovl = OVL_NEXT (ovl))
1576                       fns = ovl_cons (OVL_CURRENT (ovl), fns);
1577                   }
1578             }
1579
1580           if (fns == NULL_TREE)
1581             {
1582               cp_error ("no member function `%D' declared in `%T'",
1583                         name, ctype);
1584               return error_mark_node;
1585             }
1586           else
1587             TREE_OPERAND (declarator, 0) = fns;
1588         }
1589
1590       /* Figure out what exactly is being specialized at this point.
1591          Note that for an explicit instantiation, even one for a
1592          member function, we cannot tell apriori whether the
1593          instantiation is for a member template, or just a member
1594          function of a template class.  Even if a member template is
1595          being instantiated, the member template arguments may be
1596          elided if they can be deduced from the rest of the
1597          declaration.  */
1598       tmpl = determine_specialization (declarator, decl,
1599                                        &targs,
1600                                        member_specialization);
1601
1602       if (!tmpl || tmpl == error_mark_node)
1603         /* We couldn't figure out what this declaration was
1604            specializing.  */
1605         return error_mark_node;
1606       else
1607         {
1608           tree gen_tmpl = most_general_template (tmpl);
1609
1610           if (explicit_instantiation)
1611             {
1612               /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1613                  is done by do_decl_instantiation later.  */
1614
1615               int arg_depth = TMPL_ARGS_DEPTH (targs);
1616               int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
1617
1618               if (arg_depth > parm_depth)
1619                 {
1620                   /* If TMPL is not the most general template (for
1621                      example, if TMPL is a friend template that is
1622                      injected into namespace scope), then there will
1623                      be too many levels of TARGS.  Remove some of them
1624                      here.  */
1625                   int i;
1626                   tree new_targs;
1627
1628                   new_targs = make_tree_vec (parm_depth);
1629                   for (i = arg_depth - parm_depth; i < arg_depth; ++i)
1630                     TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
1631                       = TREE_VEC_ELT (targs, i);
1632                   targs = new_targs;
1633                 }
1634
1635               return instantiate_template (tmpl, targs);
1636             }
1637
1638           /* If this is a specialization of a member template of a
1639              template class.  In we want to return the TEMPLATE_DECL,
1640              not the specialization of it.  */
1641           if (tsk == tsk_template)
1642             {
1643               SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
1644               DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
1645               return tmpl;
1646             }
1647
1648           /* If we thought that the DECL was a member function, but it
1649              turns out to be specializing a static member function,
1650              make DECL a static member function as well.  */
1651           if (DECL_STATIC_FUNCTION_P (tmpl)
1652               && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1653             {
1654               revert_static_member_fn (decl);
1655               last_function_parms = TREE_CHAIN (last_function_parms);
1656             }
1657
1658           /* Set up the DECL_TEMPLATE_INFO for DECL.  */
1659           DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
1660
1661           /* Inherit default function arguments from the template
1662              DECL is specializing.  */
1663           copy_default_args_to_explicit_spec (decl);
1664
1665           /* Mangle the function name appropriately.  Note that we do
1666              not mangle specializations of non-template member
1667              functions of template classes, e.g. with
1668
1669                template <class T> struct S { void f(); }
1670
1671              and given the specialization
1672
1673                template <> void S<int>::f() {}
1674
1675              we do not mangle S<int>::f() here.  That's because it's
1676              just an ordinary member function and doesn't need special
1677              treatment.  We do this here so that the ordinary,
1678              non-template, name-mangling algorithm will not be used
1679              later.  */
1680           if ((is_member_template (tmpl) || ctype == NULL_TREE)
1681               && name_mangling_version >= 1)
1682             set_mangled_name_for_template_decl (decl);
1683
1684           if (is_friend && !have_def)
1685             /* This is not really a declaration of a specialization.
1686                It's just the name of an instantiation.  But, it's not
1687                a request for an instantiation, either.  */
1688             SET_DECL_IMPLICIT_INSTANTIATION (decl);
1689           else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
1690             /* This is indeed a specialization.  In case of constructors
1691                and destructors, we need in-charge and not-in-charge
1692                versions in V3 ABI.  */
1693             clone_function_decl (decl, /*update_method_vec_p=*/0);
1694
1695           /* Register this specialization so that we can find it
1696              again.  */
1697           decl = register_specialization (decl, gen_tmpl, targs);
1698         }
1699     }
1700
1701   return decl;
1702 }
1703
1704 /* TYPE is being declared.  Verify that the use of template headers
1705    and such is reasonable.  Issue error messages if not.  */
1706
1707 void
1708 maybe_check_template_type (type)
1709      tree type;
1710 {
1711   if (template_header_count)
1712     {
1713       /* We are in the scope of some `template <...>' header.  */
1714
1715       int context_depth
1716         = template_class_depth_real (TYPE_CONTEXT (type),
1717                                      /*count_specializations=*/1);
1718
1719       if (template_header_count <= context_depth)
1720         /* This is OK; the template headers are for the context.  We
1721            are actually too lenient here; like
1722            check_explicit_specialization we should consider the number
1723            of template types included in the actual declaration.  For
1724            example,
1725
1726              template <class T> struct S {
1727                template <class U> template <class V>
1728                struct I {};
1729              };
1730
1731            is illegal, but:
1732
1733              template <class T> struct S {
1734                template <class U> struct I;
1735              };
1736
1737              template <class T> template <class U.
1738              struct S<T>::I {};
1739
1740            is not.  */
1741         ;
1742       else if (template_header_count > context_depth + 1)
1743         /* There are two many template parameter lists.  */
1744         cp_error ("too many template parameter lists in declaration of `%T'", type);
1745     }
1746 }
1747
1748 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1749    parameters.  These are represented in the same format used for
1750    DECL_TEMPLATE_PARMS.  */
1751
1752 int comp_template_parms (parms1, parms2)
1753      tree parms1;
1754      tree parms2;
1755 {
1756   tree p1;
1757   tree p2;
1758
1759   if (parms1 == parms2)
1760     return 1;
1761
1762   for (p1 = parms1, p2 = parms2;
1763        p1 != NULL_TREE && p2 != NULL_TREE;
1764        p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
1765     {
1766       tree t1 = TREE_VALUE (p1);
1767       tree t2 = TREE_VALUE (p2);
1768       int i;
1769
1770       my_friendly_assert (TREE_CODE (t1) == TREE_VEC, 0);
1771       my_friendly_assert (TREE_CODE (t2) == TREE_VEC, 0);
1772
1773       if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
1774         return 0;
1775
1776       for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
1777         {
1778           tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
1779           tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
1780
1781           if (TREE_CODE (parm1) != TREE_CODE (parm2))
1782             return 0;
1783
1784           if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
1785             continue;
1786           else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
1787             return 0;
1788         }
1789     }
1790
1791   if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
1792     /* One set of parameters has more parameters lists than the
1793        other.  */
1794     return 0;
1795
1796   return 1;
1797 }
1798
1799 /* Complain if DECL shadows a template parameter.
1800
1801    [temp.local]: A template-parameter shall not be redeclared within its
1802    scope (including nested scopes).  */
1803
1804 void
1805 check_template_shadow (decl)
1806      tree decl;
1807 {
1808   tree olddecl;
1809
1810   /* If we're not in a template, we can't possibly shadow a template
1811      parameter.  */
1812   if (!current_template_parms)
1813     return;
1814
1815   /* Figure out what we're shadowing.  */
1816   if (TREE_CODE (decl) == OVERLOAD)
1817     decl = OVL_CURRENT (decl);
1818   olddecl = IDENTIFIER_VALUE (DECL_NAME (decl));
1819
1820   /* If there's no previous binding for this name, we're not shadowing
1821      anything, let alone a template parameter.  */
1822   if (!olddecl)
1823     return;
1824
1825   /* If we're not shadowing a template parameter, we're done.  Note
1826      that OLDDECL might be an OVERLOAD (or perhaps even an
1827      ERROR_MARK), so we can't just blithely assume it to be a _DECL
1828      node.  */
1829   if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
1830     return;
1831
1832   /* We check for decl != olddecl to avoid bogus errors for using a
1833      name inside a class.  We check TPFI to avoid duplicate errors for
1834      inline member templates.  */
1835   if (decl == olddecl
1836       || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
1837     return;
1838
1839   cp_error_at ("declaration of `%#D'", decl);
1840   cp_error_at (" shadows template parm `%#D'", olddecl);
1841 }
1842
1843 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1844    ORIG_LEVEL, DECL, and TYPE.  */
1845
1846 static tree
1847 build_template_parm_index (index, level, orig_level, decl, type)
1848      int index;
1849      int level;
1850      int orig_level;
1851      tree decl;
1852      tree type;
1853 {
1854   tree t = make_node (TEMPLATE_PARM_INDEX);
1855   TEMPLATE_PARM_IDX (t) = index;
1856   TEMPLATE_PARM_LEVEL (t) = level;
1857   TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
1858   TEMPLATE_PARM_DECL (t) = decl;
1859   TREE_TYPE (t) = type;
1860
1861   return t;
1862 }
1863
1864 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1865    TEMPLATE_PARM_LEVEL has been decreased by LEVELS.  If such a
1866    TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1867    new one is created.  */
1868
1869 static tree
1870 reduce_template_parm_level (index, type, levels)
1871      tree index;
1872      tree type;
1873      int levels;
1874 {
1875   if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
1876       || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
1877           != TEMPLATE_PARM_LEVEL (index) - levels))
1878     {
1879       tree decl
1880         = build_decl (TREE_CODE (TEMPLATE_PARM_DECL (index)),
1881                       DECL_NAME (TEMPLATE_PARM_DECL (index)),
1882                       type);
1883       tree t
1884         = build_template_parm_index (TEMPLATE_PARM_IDX (index),
1885                                      TEMPLATE_PARM_LEVEL (index) - levels,
1886                                      TEMPLATE_PARM_ORIG_LEVEL (index),
1887                                      decl, type);
1888       TEMPLATE_PARM_DESCENDANTS (index) = t;
1889
1890       DECL_ARTIFICIAL (decl) = 1;
1891       SET_DECL_TEMPLATE_PARM_P (decl);
1892
1893       /* Template template parameters need this.  */
1894       DECL_TEMPLATE_PARMS (decl)
1895         = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
1896     }
1897
1898   return TEMPLATE_PARM_DESCENDANTS (index);
1899 }
1900
1901 /* Process information from new template parameter NEXT and append it to the
1902    LIST being built.  */
1903
1904 tree
1905 process_template_parm (list, next)
1906      tree list, next;
1907 {
1908   tree parm;
1909   tree decl = 0;
1910   tree defval;
1911   int is_type, idx;
1912
1913   parm = next;
1914   my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259);
1915   defval = TREE_PURPOSE (parm);
1916   parm = TREE_VALUE (parm);
1917   is_type = TREE_PURPOSE (parm) == class_type_node;
1918
1919   if (list)
1920     {
1921       tree p = TREE_VALUE (tree_last (list));
1922
1923       if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
1924         idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
1925       else
1926         idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
1927       ++idx;
1928     }
1929   else
1930     idx = 0;
1931
1932   if (!is_type)
1933     {
1934       my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260);
1935       /* is a const-param */
1936       parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm),
1937                              PARM, 0, NULL_TREE);
1938
1939       /* [temp.param]
1940
1941          The top-level cv-qualifiers on the template-parameter are
1942          ignored when determining its type.  */
1943       TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
1944
1945       /* A template parameter is not modifiable.  */
1946       TREE_READONLY (parm) = 1;
1947       if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
1948         TREE_TYPE (parm) = void_type_node;
1949       decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
1950       DECL_INITIAL (parm) = DECL_INITIAL (decl)
1951         = build_template_parm_index (idx, processing_template_decl,
1952                                      processing_template_decl,
1953                                      decl, TREE_TYPE (parm));
1954     }
1955   else
1956     {
1957       tree t;
1958       parm = TREE_VALUE (parm);
1959
1960       if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
1961         {
1962           t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
1963           /* This is for distinguishing between real templates and template
1964              template parameters */
1965           TREE_TYPE (parm) = t;
1966           TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
1967           decl = parm;
1968         }
1969       else
1970         {
1971           t = make_aggr_type (TEMPLATE_TYPE_PARM);
1972           /* parm is either IDENTIFIER_NODE or NULL_TREE */
1973           decl = build_decl (TYPE_DECL, parm, t);
1974         }
1975
1976       TYPE_NAME (t) = decl;
1977       TYPE_STUB_DECL (t) = decl;
1978       parm = decl;
1979       TEMPLATE_TYPE_PARM_INDEX (t)
1980         = build_template_parm_index (idx, processing_template_decl,
1981                                      processing_template_decl,
1982                                      decl, TREE_TYPE (parm));
1983     }
1984   DECL_ARTIFICIAL (decl) = 1;
1985   SET_DECL_TEMPLATE_PARM_P (decl);
1986   pushdecl (decl);
1987   parm = build_tree_list (defval, parm);
1988   return chainon (list, parm);
1989 }
1990
1991 /* The end of a template parameter list has been reached.  Process the
1992    tree list into a parameter vector, converting each parameter into a more
1993    useful form.  Type parameters are saved as IDENTIFIER_NODEs, and others
1994    as PARM_DECLs.  */
1995
1996 tree
1997 end_template_parm_list (parms)
1998      tree parms;
1999 {
2000   int nparms;
2001   tree parm;
2002   tree saved_parmlist = make_tree_vec (list_length (parms));
2003
2004   current_template_parms
2005     = tree_cons (size_int (processing_template_decl),
2006                  saved_parmlist, current_template_parms);
2007
2008   for (parm = parms, nparms = 0;
2009        parm;
2010        parm = TREE_CHAIN (parm), nparms++)
2011     TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2012
2013   --processing_template_parmlist;
2014
2015   return saved_parmlist;
2016 }
2017
2018 /* end_template_decl is called after a template declaration is seen.  */
2019
2020 void
2021 end_template_decl ()
2022 {
2023   reset_specialization ();
2024
2025   if (! processing_template_decl)
2026     return;
2027
2028   /* This matches the pushlevel in begin_template_parm_list.  */
2029   finish_scope ();
2030
2031   --processing_template_decl;
2032   current_template_parms = TREE_CHAIN (current_template_parms);
2033 }
2034
2035 /* Given a template argument vector containing the template PARMS.
2036    The innermost PARMS are given first.  */
2037
2038 tree
2039 current_template_args ()
2040 {
2041   tree header;
2042   tree args = NULL_TREE;
2043   int length = TMPL_PARMS_DEPTH (current_template_parms);
2044   int l = length;
2045
2046   /* If there is only one level of template parameters, we do not
2047      create a TREE_VEC of TREE_VECs.  Instead, we return a single
2048      TREE_VEC containing the arguments.  */
2049   if (length > 1)
2050     args = make_tree_vec (length);
2051
2052   for (header = current_template_parms; header; header = TREE_CHAIN (header))
2053     {
2054       tree a = copy_node (TREE_VALUE (header));
2055       int i;
2056
2057       TREE_TYPE (a) = NULL_TREE;
2058       for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2059         {
2060           tree t = TREE_VEC_ELT (a, i);
2061
2062           /* T will be a list if we are called from within a
2063              begin/end_template_parm_list pair, but a vector directly
2064              if within a begin/end_member_template_processing pair.  */
2065           if (TREE_CODE (t) == TREE_LIST)
2066             {
2067               t = TREE_VALUE (t);
2068
2069               if (TREE_CODE (t) == TYPE_DECL
2070                   || TREE_CODE (t) == TEMPLATE_DECL)
2071                 t = TREE_TYPE (t);
2072               else
2073                 t = DECL_INITIAL (t);
2074               TREE_VEC_ELT (a, i) = t;
2075             }
2076         }
2077
2078       if (length > 1)
2079         TREE_VEC_ELT (args, --l) = a;
2080       else
2081         args = a;
2082     }
2083
2084   return args;
2085 }
2086
2087 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2088    template PARMS.  Used by push_template_decl below.  */
2089
2090 static tree
2091 build_template_decl (decl, parms)
2092      tree decl;
2093      tree parms;
2094 {
2095   tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2096   DECL_TEMPLATE_PARMS (tmpl) = parms;
2097   DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2098   if (DECL_LANG_SPECIFIC (decl))
2099     {
2100       if (CAN_HAVE_FULL_LANG_DECL_P (decl))
2101         DECL_VIRTUAL_CONTEXT (tmpl) = DECL_VIRTUAL_CONTEXT (decl);
2102       DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2103       DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2104       DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2105       DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2106       if (DECL_OVERLOADED_OPERATOR_P (decl))
2107         SET_OVERLOADED_OPERATOR_CODE (tmpl,
2108                                       DECL_OVERLOADED_OPERATOR_P (decl));
2109     }
2110
2111   return tmpl;
2112 }
2113
2114 struct template_parm_data
2115 {
2116   /* The level of the template parameters we are currently
2117      processing.  */
2118   int level;
2119
2120   /* The index of the specialization argument we are currently
2121      processing.  */
2122   int current_arg;
2123
2124   /* An array whose size is the number of template parameters.  The
2125      elements are non-zero if the parameter has been used in any one
2126      of the arguments processed so far.  */
2127   int* parms;
2128
2129   /* An array whose size is the number of template arguments.  The
2130      elements are non-zero if the argument makes use of template
2131      parameters of this level.  */
2132   int* arg_uses_template_parms;
2133 };
2134
2135 /* Subroutine of push_template_decl used to see if each template
2136    parameter in a partial specialization is used in the explicit
2137    argument list.  If T is of the LEVEL given in DATA (which is
2138    treated as a template_parm_data*), then DATA->PARMS is marked
2139    appropriately.  */
2140
2141 static int
2142 mark_template_parm (t, data)
2143      tree t;
2144      void* data;
2145 {
2146   int level;
2147   int idx;
2148   struct template_parm_data* tpd = (struct template_parm_data*) data;
2149
2150   if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2151     {
2152       level = TEMPLATE_PARM_LEVEL (t);
2153       idx = TEMPLATE_PARM_IDX (t);
2154     }
2155   else
2156     {
2157       level = TEMPLATE_TYPE_LEVEL (t);
2158       idx = TEMPLATE_TYPE_IDX (t);
2159     }
2160
2161   if (level == tpd->level)
2162     {
2163       tpd->parms[idx] = 1;
2164       tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2165     }
2166
2167   /* Return zero so that for_each_template_parm will continue the
2168      traversal of the tree; we want to mark *every* template parm.  */
2169   return 0;
2170 }
2171
2172 /* Process the partial specialization DECL.  */
2173
2174 static tree
2175 process_partial_specialization (decl)
2176      tree decl;
2177 {
2178   tree type = TREE_TYPE (decl);
2179   tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2180   tree specargs = CLASSTYPE_TI_ARGS (type);
2181   tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2182   tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2183   tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2184   int nargs = TREE_VEC_LENGTH (inner_args);
2185   int ntparms = TREE_VEC_LENGTH (inner_parms);
2186   int  i;
2187   int did_error_intro = 0;
2188   struct template_parm_data tpd;
2189   struct template_parm_data tpd2;
2190
2191   /* We check that each of the template parameters given in the
2192      partial specialization is used in the argument list to the
2193      specialization.  For example:
2194
2195        template <class T> struct S;
2196        template <class T> struct S<T*>;
2197
2198      The second declaration is OK because `T*' uses the template
2199      parameter T, whereas
2200
2201        template <class T> struct S<int>;
2202
2203      is no good.  Even trickier is:
2204
2205        template <class T>
2206        struct S1
2207        {
2208           template <class U>
2209           struct S2;
2210           template <class U>
2211           struct S2<T>;
2212        };
2213
2214      The S2<T> declaration is actually illegal; it is a
2215      full-specialization.  Of course,
2216
2217           template <class U>
2218           struct S2<T (*)(U)>;
2219
2220      or some such would have been OK.  */
2221   tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2222   tpd.parms = alloca (sizeof (int) * ntparms);
2223   memset ((PTR) tpd.parms, 0, sizeof (int) * ntparms);
2224
2225   tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs);
2226   memset ((PTR) tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2227   for (i = 0; i < nargs; ++i)
2228     {
2229       tpd.current_arg = i;
2230       for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2231                               &mark_template_parm,
2232                               &tpd);
2233     }
2234   for (i = 0; i < ntparms; ++i)
2235     if (tpd.parms[i] == 0)
2236       {
2237         /* One of the template parms was not used in the
2238            specialization.  */
2239         if (!did_error_intro)
2240           {
2241             cp_error ("template parameters not used in partial specialization:");
2242             did_error_intro = 1;
2243           }
2244
2245         cp_error ("        `%D'",
2246                   TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2247       }
2248
2249   /* [temp.class.spec]
2250
2251      The argument list of the specialization shall not be identical to
2252      the implicit argument list of the primary template.  */
2253   if (comp_template_args
2254       (inner_args,
2255        INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2256                                                    (maintmpl)))))
2257     cp_error ("partial specialization `%T' does not specialize any template arguments", type);
2258
2259   /* [temp.class.spec]
2260
2261      A partially specialized non-type argument expression shall not
2262      involve template parameters of the partial specialization except
2263      when the argument expression is a simple identifier.
2264
2265      The type of a template parameter corresponding to a specialized
2266      non-type argument shall not be dependent on a parameter of the
2267      specialization.  */
2268   my_friendly_assert (nargs == DECL_NTPARMS (maintmpl), 0);
2269   tpd2.parms = 0;
2270   for (i = 0; i < nargs; ++i)
2271     {
2272       tree arg = TREE_VEC_ELT (inner_args, i);
2273       if (/* These first two lines are the `non-type' bit.  */
2274           !TYPE_P (arg)
2275           && TREE_CODE (arg) != TEMPLATE_DECL
2276           /* This next line is the `argument expression is not just a
2277              simple identifier' condition and also the `specialized
2278              non-type argument' bit.  */
2279           && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2280         {
2281           if (tpd.arg_uses_template_parms[i])
2282             cp_error ("template argument `%E' involves template parameter(s)", arg);
2283           else
2284             {
2285               /* Look at the corresponding template parameter,
2286                  marking which template parameters its type depends
2287                  upon.  */
2288               tree type =
2289                 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2290                                                      i)));
2291
2292               if (!tpd2.parms)
2293                 {
2294                   /* We haven't yet initialized TPD2.  Do so now.  */
2295                   tpd2.arg_uses_template_parms
2296                     =  (int*) alloca (sizeof (int) * nargs);
2297                   /* The number of parameters here is the number in the
2298                      main template, which, as checked in the assertion
2299                      above, is NARGS.  */
2300                   tpd2.parms = (int*) alloca (sizeof (int) * nargs);
2301                   tpd2.level =
2302                     TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2303                 }
2304
2305               /* Mark the template parameters.  But this time, we're
2306                  looking for the template parameters of the main
2307                  template, not in the specialization.  */
2308               tpd2.current_arg = i;
2309               tpd2.arg_uses_template_parms[i] = 0;
2310               memset ((PTR) tpd2.parms, 0, sizeof (int) * nargs);
2311               for_each_template_parm (type,
2312                                       &mark_template_parm,
2313                                       &tpd2);
2314
2315               if (tpd2.arg_uses_template_parms [i])
2316                 {
2317                   /* The type depended on some template parameters.
2318                      If they are fully specialized in the
2319                      specialization, that's OK.  */
2320                   int j;
2321                   for (j = 0; j < nargs; ++j)
2322                     if (tpd2.parms[j] != 0
2323                         && tpd.arg_uses_template_parms [j])
2324                       {
2325                         cp_error ("type `%T' of template argument `%E' depends on template parameter(s)",
2326                                   type,
2327                                   arg);
2328                         break;
2329                       }
2330                 }
2331             }
2332         }
2333     }
2334
2335   if (retrieve_specialization (maintmpl, specargs))
2336     /* We've already got this specialization.  */
2337     return decl;
2338
2339   DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2340     = tree_cons (inner_args, inner_parms,
2341                  DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2342   TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2343   return decl;
2344 }
2345
2346 /* Check that a template declaration's use of default arguments is not
2347    invalid.  Here, PARMS are the template parameters.  IS_PRIMARY is
2348    non-zero if DECL is the thing declared by a primary template.
2349    IS_PARTIAL is non-zero if DECL is a partial specialization.  */
2350
2351 static void
2352 check_default_tmpl_args (decl, parms, is_primary, is_partial)
2353      tree decl;
2354      tree parms;
2355      int is_primary;
2356      int is_partial;
2357 {
2358   const char *msg;
2359   int last_level_to_check;
2360   tree parm_level;
2361
2362   /* [temp.param]
2363
2364      A default template-argument shall not be specified in a
2365      function template declaration or a function template definition, nor
2366      in the template-parameter-list of the definition of a member of a
2367      class template.  */
2368
2369   if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2370     /* You can't have a function template declaration in a local
2371        scope, nor you can you define a member of a class template in a
2372        local scope.  */
2373     return;
2374
2375   if (current_class_type
2376       && !TYPE_BEING_DEFINED (current_class_type)
2377       && DECL_LANG_SPECIFIC (decl)
2378       /* If this is either a friend defined in the scope of the class
2379          or a member function.  */
2380       && ((DECL_CONTEXT (decl)
2381            && same_type_p (DECL_CONTEXT (decl), current_class_type))
2382           || (DECL_FRIEND_CONTEXT (decl)
2383               && same_type_p (DECL_FRIEND_CONTEXT (decl),
2384                               current_class_type)))
2385       /* And, if it was a member function, it really was defined in
2386          the scope of the class.  */
2387       && (!DECL_FUNCTION_MEMBER_P (decl) || DECL_INITIALIZED_IN_CLASS_P (decl)))
2388     /* We already checked these parameters when the template was
2389        declared, so there's no need to do it again now.  This function
2390        was defined in class scope, but we're processing it's body now
2391        that the class is complete.  */
2392     return;
2393
2394   /* [temp.param]
2395
2396      If a template-parameter has a default template-argument, all
2397      subsequent template-parameters shall have a default
2398      template-argument supplied.  */
2399   for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2400     {
2401       tree inner_parms = TREE_VALUE (parm_level);
2402       int ntparms = TREE_VEC_LENGTH (inner_parms);
2403       int seen_def_arg_p = 0;
2404       int i;
2405
2406       for (i = 0; i < ntparms; ++i)
2407         {
2408           tree parm = TREE_VEC_ELT (inner_parms, i);
2409           if (TREE_PURPOSE (parm))
2410             seen_def_arg_p = 1;
2411           else if (seen_def_arg_p)
2412             {
2413               cp_error ("no default argument for `%D'", TREE_VALUE (parm));
2414               /* For better subsequent error-recovery, we indicate that
2415                  there should have been a default argument.  */
2416               TREE_PURPOSE (parm) = error_mark_node;
2417             }
2418         }
2419     }
2420
2421   if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2422     /* For an ordinary class template, default template arguments are
2423        allowed at the innermost level, e.g.:
2424          template <class T = int>
2425          struct S {};
2426        but, in a partial specialization, they're not allowed even
2427        there, as we have in [temp.class.spec]:
2428
2429          The template parameter list of a specialization shall not
2430          contain default template argument values.
2431
2432        So, for a partial specialization, or for a function template,
2433        we look at all of them.  */
2434     ;
2435   else
2436     /* But, for a primary class template that is not a partial
2437        specialization we look at all template parameters except the
2438        innermost ones.  */
2439     parms = TREE_CHAIN (parms);
2440
2441   /* Figure out what error message to issue.  */
2442   if (TREE_CODE (decl) == FUNCTION_DECL)
2443     msg = "default argument for template parameter in function template `%D'";
2444   else if (is_partial)
2445     msg = "default argument in partial specialization `%D'";
2446   else
2447     msg = "default argument for template parameter for class enclosing `%D'";
2448
2449   if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2450     /* If we're inside a class definition, there's no need to
2451        examine the parameters to the class itself.  On the one
2452        hand, they will be checked when the class is defined, and,
2453        on the other, default arguments are legal in things like:
2454          template <class T = double>
2455          struct S { template <class U> void f(U); };
2456        Here the default argument for `S' has no bearing on the
2457        declaration of `f'.  */
2458     last_level_to_check = template_class_depth (current_class_type) + 1;
2459   else
2460     /* Check everything.  */
2461     last_level_to_check = 0;
2462
2463   for (parm_level = parms;
2464        parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2465        parm_level = TREE_CHAIN (parm_level))
2466     {
2467       tree inner_parms = TREE_VALUE (parm_level);
2468       int i;
2469       int ntparms;
2470
2471       ntparms = TREE_VEC_LENGTH (inner_parms);
2472       for (i = 0; i < ntparms; ++i)
2473         if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2474           {
2475             if (msg)
2476               {
2477                 cp_error (msg, decl);
2478                 msg = 0;
2479               }
2480
2481             /* Clear out the default argument so that we are not
2482                confused later.  */
2483             TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2484           }
2485
2486       /* At this point, if we're still interested in issuing messages,
2487          they must apply to classes surrounding the object declared.  */
2488       if (msg)
2489         msg = "default argument for template parameter for class enclosing `%D'";
2490     }
2491 }
2492
2493 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2494    parameters given by current_template_args, or reuses a
2495    previously existing one, if appropriate.  Returns the DECL, or an
2496    equivalent one, if it is replaced via a call to duplicate_decls.
2497
2498    If IS_FRIEND is non-zero, DECL is a friend declaration.  */
2499
2500 tree
2501 push_template_decl_real (decl, is_friend)
2502      tree decl;
2503      int is_friend;
2504 {
2505   tree tmpl;
2506   tree args;
2507   tree info;
2508   tree ctx;
2509   int primary;
2510   int is_partial;
2511   int new_template_p = 0;
2512
2513   /* See if this is a partial specialization.  */
2514   is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
2515                 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
2516                 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
2517
2518   is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl));
2519
2520   if (is_friend)
2521     /* For a friend, we want the context of the friend function, not
2522        the type of which it is a friend.  */
2523     ctx = DECL_CONTEXT (decl);
2524   else if (CP_DECL_CONTEXT (decl)
2525            && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
2526     /* In the case of a virtual function, we want the class in which
2527        it is defined.  */
2528     ctx = CP_DECL_CONTEXT (decl);
2529   else
2530     /* Otherwise, if we're currently defining some class, the DECL
2531        is assumed to be a member of the class.  */
2532     ctx = current_scope ();
2533
2534   if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
2535     ctx = NULL_TREE;
2536
2537   if (!DECL_CONTEXT (decl))
2538     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2539
2540   /* See if this is a primary template.  */
2541   primary = template_parm_scope_p ();
2542
2543   if (primary)
2544     {
2545       if (current_lang_name == lang_name_c)
2546         cp_error ("template with C linkage");
2547       else if (TREE_CODE (decl) == TYPE_DECL
2548                && ANON_AGGRNAME_P (DECL_NAME (decl)))
2549         cp_error ("template class without a name");
2550       else if ((DECL_IMPLICIT_TYPEDEF_P (decl)
2551                 && CLASS_TYPE_P (TREE_TYPE (decl)))
2552                || (TREE_CODE (decl) == VAR_DECL && ctx && CLASS_TYPE_P (ctx))
2553                || TREE_CODE (decl) == FUNCTION_DECL)
2554         /* OK */;
2555       else
2556         cp_error ("template declaration of `%#D'", decl);
2557     }
2558
2559   /* Check to see that the rules regarding the use of default
2560      arguments are not being violated.  */
2561   check_default_tmpl_args (decl, current_template_parms,
2562                            primary, is_partial);
2563
2564   if (is_partial)
2565     return process_partial_specialization (decl);
2566
2567   args = current_template_args ();
2568
2569   if (!ctx
2570       || TREE_CODE (ctx) == FUNCTION_DECL
2571       || TYPE_BEING_DEFINED (ctx)
2572       || (is_friend && !DECL_TEMPLATE_INFO (decl)))
2573     {
2574       if (DECL_LANG_SPECIFIC (decl)
2575           && DECL_TEMPLATE_INFO (decl)
2576           && DECL_TI_TEMPLATE (decl))
2577         tmpl = DECL_TI_TEMPLATE (decl);
2578       /* If DECL is a TYPE_DECL for a class-template, then there won't
2579          be DECL_LANG_SPECIFIC.  The information equivalent to
2580          DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead.  */
2581       else if (DECL_IMPLICIT_TYPEDEF_P (decl)
2582                && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2583                && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
2584         {
2585           /* Since a template declaration already existed for this
2586              class-type, we must be redeclaring it here.  Make sure
2587              that the redeclaration is legal.  */
2588           redeclare_class_template (TREE_TYPE (decl),
2589                                     current_template_parms);
2590           /* We don't need to create a new TEMPLATE_DECL; just use the
2591              one we already had.  */
2592           tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
2593         }
2594       else
2595         {
2596           tmpl = build_template_decl (decl, current_template_parms);
2597           new_template_p = 1;
2598
2599           if (DECL_LANG_SPECIFIC (decl)
2600               && DECL_TEMPLATE_SPECIALIZATION (decl))
2601             {
2602               /* A specialization of a member template of a template
2603                  class. */
2604               SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2605               DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
2606               DECL_TEMPLATE_INFO (decl) = NULL_TREE;
2607             }
2608         }
2609     }
2610   else
2611     {
2612       tree a, t, current, parms;
2613       int i;
2614
2615       if (TREE_CODE (decl) == TYPE_DECL)
2616         {
2617           if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
2618                || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2619               && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2620               && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
2621             tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
2622           else
2623             {
2624               cp_error ("`%D' does not declare a template type", decl);
2625               return decl;
2626             }
2627         }
2628       else if (! DECL_TEMPLATE_INFO (decl))
2629         {
2630           cp_error ("template definition of non-template `%#D'", decl);
2631           return decl;
2632         }
2633       else
2634         tmpl = DECL_TI_TEMPLATE (decl);
2635
2636       if (is_member_template (tmpl)
2637           && DECL_FUNCTION_TEMPLATE_P (tmpl)
2638           && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
2639           && DECL_TEMPLATE_SPECIALIZATION (decl))
2640         {
2641           tree new_tmpl;
2642
2643           /* The declaration is a specialization of a member
2644              template, declared outside the class.  Therefore, the
2645              innermost template arguments will be NULL, so we
2646              replace them with the arguments determined by the
2647              earlier call to check_explicit_specialization.  */
2648           args = DECL_TI_ARGS (decl);
2649
2650           new_tmpl
2651             = build_template_decl (decl, current_template_parms);
2652           DECL_TEMPLATE_RESULT (new_tmpl) = decl;
2653           TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
2654           DECL_TI_TEMPLATE (decl) = new_tmpl;
2655           SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
2656           DECL_TEMPLATE_INFO (new_tmpl)
2657             = tree_cons (tmpl, args, NULL_TREE);
2658
2659           register_specialization (new_tmpl,
2660                                    most_general_template (tmpl),
2661                                    args);
2662           return decl;
2663         }
2664
2665       /* Make sure the template headers we got make sense.  */
2666
2667       parms = DECL_TEMPLATE_PARMS (tmpl);
2668       i = TMPL_PARMS_DEPTH (parms);
2669       if (TMPL_ARGS_DEPTH (args) != i)
2670         {
2671           cp_error ("expected %d levels of template parms for `%#D', got %d",
2672                     i, decl, TMPL_ARGS_DEPTH (args));
2673         }
2674       else
2675         for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
2676           {
2677             a = TMPL_ARGS_LEVEL (args, i);
2678             t = INNERMOST_TEMPLATE_PARMS (parms);
2679
2680             if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
2681               {
2682                 if (current == decl)
2683                   cp_error ("got %d template parameters for `%#D'",
2684                             TREE_VEC_LENGTH (a), decl);
2685                 else
2686                   cp_error ("got %d template parameters for `%#T'",
2687                             TREE_VEC_LENGTH (a), current);
2688                 cp_error ("  but %d required", TREE_VEC_LENGTH (t));
2689               }
2690
2691             /* Perhaps we should also check that the parms are used in the
2692                appropriate qualifying scopes in the declarator?  */
2693
2694             if (current == decl)
2695               current = ctx;
2696             else
2697               current = TYPE_CONTEXT (current);
2698           }
2699     }
2700
2701   DECL_TEMPLATE_RESULT (tmpl) = decl;
2702   TREE_TYPE (tmpl) = TREE_TYPE (decl);
2703
2704   /* Push template declarations for global functions and types.  Note
2705      that we do not try to push a global template friend declared in a
2706      template class; such a thing may well depend on the template
2707      parameters of the class.  */
2708   if (new_template_p && !ctx
2709       && !(is_friend && template_class_depth (current_class_type) > 0))
2710     tmpl = pushdecl_namespace_level (tmpl);
2711
2712   if (primary)
2713     DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
2714
2715   info = tree_cons (tmpl, args, NULL_TREE);
2716
2717   if (DECL_IMPLICIT_TYPEDEF_P (decl))
2718     {
2719       SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
2720       if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
2721           && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE)
2722         DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
2723     }
2724   else if (DECL_LANG_SPECIFIC (decl))
2725     DECL_TEMPLATE_INFO (decl) = info;
2726
2727   return DECL_TEMPLATE_RESULT (tmpl);
2728 }
2729
2730 tree
2731 push_template_decl (decl)
2732      tree decl;
2733 {
2734   return push_template_decl_real (decl, 0);
2735 }
2736
2737 /* Called when a class template TYPE is redeclared with the indicated
2738    template PARMS, e.g.:
2739
2740      template <class T> struct S;
2741      template <class T> struct S {};  */
2742
2743 void
2744 redeclare_class_template (type, parms)
2745      tree type;
2746      tree parms;
2747 {
2748   tree tmpl;
2749   tree tmpl_parms;
2750   int i;
2751
2752   if (!TYPE_TEMPLATE_INFO (type))
2753     {
2754       cp_error ("`%T' is not a template type", type);
2755       return;
2756     }
2757
2758   tmpl = TYPE_TI_TEMPLATE (type);
2759   if (!PRIMARY_TEMPLATE_P (tmpl))
2760     /* The type is nested in some template class.  Nothing to worry
2761        about here; there are no new template parameters for the nested
2762        type.  */
2763     return;
2764
2765   parms = INNERMOST_TEMPLATE_PARMS (parms);
2766   tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
2767
2768   if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
2769     {
2770       cp_error_at ("previous declaration `%D'", tmpl);
2771       cp_error ("used %d template parameter%s instead of %d",
2772                 TREE_VEC_LENGTH (tmpl_parms),
2773                 TREE_VEC_LENGTH (tmpl_parms) == 1 ? "" : "s",
2774                 TREE_VEC_LENGTH (parms));
2775       return;
2776     }
2777
2778   for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
2779     {
2780       tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
2781       tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
2782       tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
2783       tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
2784
2785       if (TREE_CODE (tmpl_parm) != TREE_CODE (parm))
2786         {
2787           cp_error_at ("template parameter `%#D'", tmpl_parm);
2788           cp_error ("redeclared here as `%#D'", parm);
2789           return;
2790         }
2791
2792       if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
2793         {
2794           /* We have in [temp.param]:
2795
2796              A template-parameter may not be given default arguments
2797              by two different declarations in the same scope.  */
2798           cp_error ("redefinition of default argument for `%#D'", parm);
2799           cp_error_at ("  original definition appeared here", tmpl_parm);
2800           return;
2801         }
2802
2803       if (parm_default != NULL_TREE)
2804         /* Update the previous template parameters (which are the ones
2805            that will really count) with the new default value.  */
2806         TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
2807       else if (tmpl_default != NULL_TREE)
2808         /* Update the new parameters, too; they'll be used as the
2809            parameters for any members.  */
2810         TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
2811     }
2812 }
2813
2814 /* Attempt to convert the non-type template parameter EXPR to the
2815    indicated TYPE.  If the conversion is successful, return the
2816    converted value.  If the conversion is unsuccessful, return
2817    NULL_TREE if we issued an error message, or error_mark_node if we
2818    did not.  We issue error messages for out-and-out bad template
2819    parameters, but not simply because the conversion failed, since we
2820    might be just trying to do argument deduction.  By the time this
2821    function is called, neither TYPE nor EXPR may make use of template
2822    parameters.  */
2823
2824 static tree
2825 convert_nontype_argument (type, expr)
2826      tree type;
2827      tree expr;
2828 {
2829   tree expr_type = TREE_TYPE (expr);
2830
2831   /* A template-argument for a non-type, non-template
2832      template-parameter shall be one of:
2833
2834      --an integral constant-expression of integral or enumeration
2835      type; or
2836
2837      --the name of a non-type template-parameter; or
2838
2839      --the name of an object or function with external linkage,
2840      including function templates and function template-ids but
2841      excluding non-static class members, expressed as id-expression;
2842      or
2843
2844      --the address of an object or function with external linkage,
2845      including function templates and function template-ids but
2846      excluding non-static class members, expressed as & id-expression
2847      where the & is optional if the name refers to a function or
2848      array; or
2849
2850      --a pointer to member expressed as described in _expr.unary.op_.  */
2851
2852   /* An integral constant-expression can include const variables or
2853      enumerators.  Simplify things by folding them to their values,
2854      unless we're about to bind the declaration to a reference
2855      parameter.  */
2856   if (INTEGRAL_TYPE_P (expr_type)
2857       && TREE_CODE (type) != REFERENCE_TYPE)
2858     expr = decl_constant_value (expr);
2859
2860   if (is_overloaded_fn (expr))
2861     /* OK for now.  We'll check that it has external linkage later.
2862        Check this first since if expr_type is the unknown_type_node
2863        we would otherwise complain below.  */
2864     ;
2865   else if (TYPE_PTRMEM_P (expr_type)
2866            || TYPE_PTRMEMFUNC_P (expr_type))
2867     {
2868       if (TREE_CODE (expr) != PTRMEM_CST)
2869         goto bad_argument;
2870     }
2871   else if (TYPE_PTR_P (expr_type)
2872            || TYPE_PTRMEM_P (expr_type)
2873            || TREE_CODE (expr_type) == ARRAY_TYPE
2874            || TREE_CODE (type) == REFERENCE_TYPE
2875            /* If expr is the address of an overloaded function, we
2876               will get the unknown_type_node at this point.  */
2877            || expr_type == unknown_type_node)
2878     {
2879       tree referent;
2880       tree e = expr;
2881       STRIP_NOPS (e);
2882
2883       if (TREE_CODE (expr_type) == ARRAY_TYPE
2884           || (TREE_CODE (type) == REFERENCE_TYPE
2885               && TREE_CODE (e) != ADDR_EXPR))
2886         referent = e;
2887       else
2888         {
2889           if (TREE_CODE (e) != ADDR_EXPR)
2890             {
2891             bad_argument:
2892               cp_error ("`%E' is not a valid template argument", expr);
2893               if (TYPE_PTR_P (expr_type))
2894                 {
2895                   if (TREE_CODE (TREE_TYPE (expr_type)) == FUNCTION_TYPE)
2896                     cp_error ("it must be the address of a function with external linkage");
2897                   else
2898                     cp_error ("it must be the address of an object with external linkage");
2899                 }
2900               else if (TYPE_PTRMEM_P (expr_type)
2901                        || TYPE_PTRMEMFUNC_P (expr_type))
2902                 cp_error ("it must be a pointer-to-member of the form `&X::Y'");
2903
2904               return NULL_TREE;
2905             }
2906
2907           referent = TREE_OPERAND (e, 0);
2908           STRIP_NOPS (referent);
2909         }
2910
2911       if (TREE_CODE (referent) == STRING_CST)
2912         {
2913           cp_error ("string literal %E is not a valid template argument because it is the address of an object with static linkage",
2914                     referent);
2915           return NULL_TREE;
2916         }
2917
2918       if (is_overloaded_fn (referent))
2919         /* We'll check that it has external linkage later.  */
2920         ;
2921       else if (TREE_CODE (referent) != VAR_DECL)
2922         goto bad_argument;
2923       else if (!DECL_EXTERNAL_LINKAGE_P (referent))
2924         {
2925           cp_error ("address of non-extern `%E' cannot be used as template argument", referent);
2926           return error_mark_node;
2927         }
2928     }
2929   else if (INTEGRAL_TYPE_P (expr_type)
2930            || TYPE_PTRMEM_P (expr_type)
2931            || TYPE_PTRMEMFUNC_P (expr_type)
2932            /* The next two are g++ extensions.  */
2933            || TREE_CODE (expr_type) == REAL_TYPE
2934            || TREE_CODE (expr_type) == COMPLEX_TYPE)
2935     {
2936       if (! TREE_CONSTANT (expr))
2937         {
2938         non_constant:
2939           cp_error ("non-constant `%E' cannot be used as template argument",
2940                     expr);
2941           return NULL_TREE;
2942         }
2943     }
2944   else
2945     {
2946       cp_error ("object `%E' cannot be used as template argument", expr);
2947       return NULL_TREE;
2948     }
2949
2950   switch (TREE_CODE (type))
2951     {
2952     case INTEGER_TYPE:
2953     case BOOLEAN_TYPE:
2954     case ENUMERAL_TYPE:
2955       /* For a non-type template-parameter of integral or enumeration
2956          type, integral promotions (_conv.prom_) and integral
2957          conversions (_conv.integral_) are applied. */
2958       if (!INTEGRAL_TYPE_P (expr_type))
2959         return error_mark_node;
2960
2961       /* It's safe to call digest_init in this case; we know we're
2962          just converting one integral constant expression to another.  */
2963       expr = digest_init (type, expr, (tree*) 0);
2964
2965       if (TREE_CODE (expr) != INTEGER_CST)
2966         /* Curiously, some TREE_CONSTANT integral expressions do not
2967            simplify to integer constants.  For example, `3 % 0',
2968            remains a TRUNC_MOD_EXPR.  */
2969         goto non_constant;
2970
2971       return expr;
2972
2973     case REAL_TYPE:
2974     case COMPLEX_TYPE:
2975       /* These are g++ extensions.  */
2976       if (TREE_CODE (expr_type) != TREE_CODE (type))
2977         return error_mark_node;
2978
2979       expr = digest_init (type, expr, (tree*) 0);
2980
2981       if (TREE_CODE (expr) != REAL_CST)
2982         goto non_constant;
2983
2984       return expr;
2985
2986     case POINTER_TYPE:
2987       {
2988         tree type_pointed_to = TREE_TYPE (type);
2989
2990         if (TYPE_PTRMEM_P (type))
2991           {
2992             tree e;
2993
2994             /* For a non-type template-parameter of type pointer to data
2995                member, qualification conversions (_conv.qual_) are
2996                applied.  */
2997             e = perform_qualification_conversions (type, expr);
2998             if (TREE_CODE (e) == NOP_EXPR)
2999               /* The call to perform_qualification_conversions will
3000                  insert a NOP_EXPR over EXPR to do express conversion,
3001                  if necessary.  But, that will confuse us if we use
3002                  this (converted) template parameter to instantiate
3003                  another template; then the thing will not look like a
3004                  valid template argument.  So, just make a new
3005                  constant, of the appropriate type.  */
3006               e = make_ptrmem_cst (type, PTRMEM_CST_MEMBER (expr));
3007             return e;
3008           }
3009         else if (TREE_CODE (type_pointed_to) == FUNCTION_TYPE)
3010           {
3011             /* For a non-type template-parameter of type pointer to
3012                function, only the function-to-pointer conversion
3013                (_conv.func_) is applied.  If the template-argument
3014                represents a set of overloaded functions (or a pointer to
3015                such), the matching function is selected from the set
3016                (_over.over_).  */
3017             tree fns;
3018             tree fn;
3019
3020             if (TREE_CODE (expr) == ADDR_EXPR)
3021               fns = TREE_OPERAND (expr, 0);
3022             else
3023               fns = expr;
3024
3025             fn = instantiate_type (type_pointed_to, fns, itf_none);
3026
3027             if (fn == error_mark_node)
3028               return error_mark_node;
3029
3030             if (!DECL_EXTERNAL_LINKAGE_P (fn))
3031               {
3032                 if (really_overloaded_fn (fns))
3033                   return error_mark_node;
3034                 else
3035                   goto bad_argument;
3036               }
3037
3038             expr = build_unary_op (ADDR_EXPR, fn, 0);
3039
3040             my_friendly_assert (same_type_p (type, TREE_TYPE (expr)),
3041                                 0);
3042             return expr;
3043           }
3044         else
3045           {
3046             /* For a non-type template-parameter of type pointer to
3047                object, qualification conversions (_conv.qual_) and the
3048                array-to-pointer conversion (_conv.array_) are applied.
3049                [Note: In particular, neither the null pointer conversion
3050                (_conv.ptr_) nor the derived-to-base conversion
3051                (_conv.ptr_) are applied.  Although 0 is a valid
3052                template-argument for a non-type template-parameter of
3053                integral type, it is not a valid template-argument for a
3054                non-type template-parameter of pointer type.]
3055
3056                The call to decay_conversion performs the
3057                array-to-pointer conversion, if appropriate.  */
3058             expr = decay_conversion (expr);
3059
3060             if (expr == error_mark_node)
3061               return error_mark_node;
3062             else
3063               return perform_qualification_conversions (type, expr);
3064           }
3065       }
3066       break;
3067
3068     case REFERENCE_TYPE:
3069       {
3070         tree type_referred_to = TREE_TYPE (type);
3071
3072         /* If this expression already has reference type, get the
3073            underling object.  */
3074         if (TREE_CODE (expr_type) == REFERENCE_TYPE)
3075           {
3076             my_friendly_assert (TREE_CODE (expr) == ADDR_EXPR, 20000604);
3077             expr = TREE_OPERAND (expr, 0);
3078             expr_type = TREE_TYPE (expr);
3079           }
3080
3081         if (TREE_CODE (type_referred_to) == FUNCTION_TYPE)
3082           {
3083             /* For a non-type template-parameter of type reference to
3084                function, no conversions apply.  If the
3085                template-argument represents a set of overloaded
3086                functions, the matching function is selected from the
3087                set (_over.over_).  */
3088             tree fn;
3089
3090             fn = instantiate_type (type_referred_to, expr, itf_none);
3091
3092             if (fn == error_mark_node)
3093               return error_mark_node;
3094
3095             if (!DECL_EXTERNAL_LINKAGE_P (fn))
3096               {
3097                 if (really_overloaded_fn (expr))
3098                   /* Don't issue an error here; we might get a different
3099                      function if the overloading had worked out
3100                      differently.  */
3101                   return error_mark_node;
3102                 else
3103                   goto bad_argument;
3104               }
3105
3106             my_friendly_assert (same_type_p (type_referred_to,
3107                                              TREE_TYPE (fn)),
3108                                 0);
3109
3110             expr = fn;
3111           }
3112         else
3113           {
3114             /* For a non-type template-parameter of type reference to
3115                object, no conversions apply.  The type referred to by the
3116                reference may be more cv-qualified than the (otherwise
3117                identical) type of the template-argument.  The
3118                template-parameter is bound directly to the
3119                template-argument, which must be an lvalue.  */
3120             if (!same_type_p (TYPE_MAIN_VARIANT (expr_type),
3121                               TYPE_MAIN_VARIANT (type_referred_to))
3122                 || !at_least_as_qualified_p (type_referred_to,
3123                                              expr_type)
3124                 || !real_lvalue_p (expr))
3125               return error_mark_node;
3126           }
3127
3128         mark_addressable (expr);
3129         return build1 (ADDR_EXPR, type, expr);
3130       }
3131       break;
3132
3133     case RECORD_TYPE:
3134       {
3135         my_friendly_assert (TYPE_PTRMEMFUNC_P (type), 20010112);
3136
3137         /* For a non-type template-parameter of type pointer to member
3138            function, no conversions apply.  If the template-argument
3139            represents a set of overloaded member functions, the
3140            matching member function is selected from the set
3141            (_over.over_).  */
3142
3143         if (!TYPE_PTRMEMFUNC_P (expr_type) &&
3144             expr_type != unknown_type_node)
3145           return error_mark_node;
3146
3147         if (TREE_CODE (expr) == PTRMEM_CST)
3148           {
3149             /* A ptr-to-member constant.  */
3150             if (!same_type_p (type, expr_type))
3151               return error_mark_node;
3152             else
3153               return expr;
3154           }
3155
3156         if (TREE_CODE (expr) != ADDR_EXPR)
3157           return error_mark_node;
3158
3159         expr = instantiate_type (type, expr, itf_none);
3160
3161         if (expr == error_mark_node)
3162           return error_mark_node;
3163
3164         my_friendly_assert (same_type_p (type, TREE_TYPE (expr)),
3165                             0);
3166         return expr;
3167       }
3168       break;
3169
3170     default:
3171       /* All non-type parameters must have one of these types.  */
3172       my_friendly_abort (0);
3173       break;
3174     }
3175
3176   return error_mark_node;
3177 }
3178
3179 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3180    template template parameters.  Both PARM_PARMS and ARG_PARMS are
3181    vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3182    or PARM_DECL.
3183
3184    ARG_PARMS may contain more parameters than PARM_PARMS.  If this is
3185    the case, then extra parameters must have default arguments.
3186
3187    Consider the example:
3188      template <class T, class Allocator = allocator> class vector;
3189      template<template <class U> class TT> class C;
3190
3191    C<vector> is a valid instantiation.  PARM_PARMS for the above code
3192    contains a TYPE_DECL (for U),  ARG_PARMS contains two TYPE_DECLs (for
3193    T and Allocator) and OUTER_ARGS contains the argument that is used to
3194    substitute the TT parameter.  */
3195
3196 static int
3197 coerce_template_template_parms (parm_parms, arg_parms, complain,
3198                                 in_decl, outer_args)
3199      tree parm_parms, arg_parms;
3200      int complain;
3201      tree in_decl, outer_args;
3202 {
3203   int nparms, nargs, i;
3204   tree parm, arg;
3205
3206   my_friendly_assert (TREE_CODE (parm_parms) == TREE_VEC, 0);
3207   my_friendly_assert (TREE_CODE (arg_parms) == TREE_VEC, 0);
3208
3209   nparms = TREE_VEC_LENGTH (parm_parms);
3210   nargs = TREE_VEC_LENGTH (arg_parms);
3211
3212   /* The rule here is opposite of coerce_template_parms.  */
3213   if (nargs < nparms
3214       || (nargs > nparms
3215           && TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE))
3216     return 0;
3217
3218   for (i = 0; i < nparms; ++i)
3219     {
3220       parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3221       arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3222
3223       if (arg == NULL_TREE || arg == error_mark_node
3224           || parm == NULL_TREE || parm == error_mark_node)
3225         return 0;
3226
3227       if (TREE_CODE (arg) != TREE_CODE (parm))
3228         return 0;
3229
3230       switch (TREE_CODE (parm))
3231         {
3232         case TYPE_DECL:
3233           break;
3234
3235         case TEMPLATE_DECL:
3236           /* We encounter instantiations of templates like
3237                template <template <template <class> class> class TT>
3238                class C;  */
3239           {
3240             tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3241             tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3242
3243             if (!coerce_template_template_parms (parmparm, argparm,
3244                                                  complain, in_decl,
3245                                                  outer_args))
3246               return 0;
3247           }
3248           break;
3249
3250         case PARM_DECL:
3251           /* The tsubst call is used to handle cases such as
3252                template <class T, template <T> class TT> class D;
3253              i.e. the parameter list of TT depends on earlier parameters.  */
3254           if (!same_type_p (tsubst (TREE_TYPE (parm), outer_args,
3255                                     complain, in_decl),
3256                             TREE_TYPE (arg)))
3257             return 0;
3258           break;
3259
3260         default:
3261           my_friendly_abort (0);
3262         }
3263     }
3264   return 1;
3265 }
3266
3267 /* Convert the indicated template ARG as necessary to match the
3268    indicated template PARM.  Returns the converted ARG, or
3269    error_mark_node if the conversion was unsuccessful.  Error messages
3270    are issued if COMPLAIN is non-zero.  This conversion is for the Ith
3271    parameter in the parameter list.  ARGS is the full set of template
3272    arguments deduced so far.  */
3273
3274 static tree
3275 convert_template_argument (parm, arg, args, complain, i, in_decl)
3276      tree parm;
3277      tree arg;
3278      tree args;
3279      int complain;
3280      int i;
3281      tree in_decl;
3282 {
3283   tree val;
3284   tree inner_args;
3285   int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3286
3287   inner_args = INNERMOST_TEMPLATE_ARGS (args);
3288
3289   if (TREE_CODE (arg) == TREE_LIST
3290       && TREE_TYPE (arg) != NULL_TREE
3291       && TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE)
3292     {
3293       /* The template argument was the name of some
3294          member function.  That's usually
3295          illegal, but static members are OK.  In any
3296          case, grab the underlying fields/functions
3297          and issue an error later if required.  */
3298       arg = TREE_VALUE (arg);
3299       TREE_TYPE (arg) = unknown_type_node;
3300     }
3301
3302   requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3303   requires_type = (TREE_CODE (parm) == TYPE_DECL
3304                    || requires_tmpl_type);
3305
3306   /* Check if it is a class template.  If REQUIRES_TMPL_TYPE is true,
3307      we also accept implicitly created TYPE_DECL as a valid argument.
3308      This is necessary to handle the case where we pass a template name
3309      to a template template parameter in a scope where we've derived from
3310      in instantiation of that template, so the template name refers to that
3311      instantiation.  We really ought to handle this better.  */
3312   is_tmpl_type
3313     = ((TREE_CODE (arg) == TEMPLATE_DECL
3314         && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3315        || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3316        || (TREE_CODE (arg) == RECORD_TYPE
3317            && CLASSTYPE_TEMPLATE_INFO (arg)
3318            && TREE_CODE (TYPE_NAME (arg)) == TYPE_DECL
3319            && DECL_ARTIFICIAL (TYPE_NAME (arg))
3320            && requires_tmpl_type
3321            && is_base_of_enclosing_class (arg, current_class_type)));
3322   if (is_tmpl_type && TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
3323     arg = TYPE_STUB_DECL (arg);
3324   else if (is_tmpl_type && TREE_CODE (arg) == RECORD_TYPE)
3325     arg = CLASSTYPE_TI_TEMPLATE (arg);
3326
3327   is_type = TYPE_P (arg) || is_tmpl_type;
3328
3329   if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3330       && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3331     {
3332       cp_pedwarn ("to refer to a type member of a template parameter, use `typename %E'", arg);
3333
3334       arg = make_typename_type (TREE_OPERAND (arg, 0),
3335                                 TREE_OPERAND (arg, 1),
3336                                 complain);
3337       is_type = 1;
3338     }
3339   if (is_type != requires_type)
3340     {
3341       if (in_decl)
3342         {
3343           if (complain)
3344             {
3345               cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3346                         i + 1, in_decl);
3347               if (is_type)
3348                 cp_error ("  expected a constant of type `%T', got `%T'",
3349                           TREE_TYPE (parm),
3350                           (is_tmpl_type ? DECL_NAME (arg) : arg));
3351               else
3352                 cp_error ("  expected a type, got `%E'", arg);
3353             }
3354         }
3355       return error_mark_node;
3356     }
3357   if (is_tmpl_type ^ requires_tmpl_type)
3358     {
3359       if (in_decl && complain)
3360         {
3361           cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3362                     i + 1, in_decl);
3363           if (is_tmpl_type)
3364             cp_error ("  expected a type, got `%T'", DECL_NAME (arg));
3365           else
3366             cp_error ("  expected a class template, got `%T'", arg);
3367         }
3368       return error_mark_node;
3369     }
3370
3371   if (is_type)
3372     {
3373       if (requires_tmpl_type)
3374         {
3375           tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3376           tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3377
3378           if (coerce_template_template_parms (parmparm, argparm, complain,
3379                                               in_decl, inner_args))
3380             {
3381               val = arg;
3382
3383               /* TEMPLATE_TEMPLATE_PARM node is preferred over
3384                  TEMPLATE_DECL.  */
3385               if (val != error_mark_node
3386                   && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
3387                 val = TREE_TYPE (val);
3388             }
3389           else
3390             {
3391               if (in_decl && complain)
3392                 {
3393                   cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3394                             i + 1, in_decl);
3395                   cp_error ("  expected a template of type `%D', got `%D'", parm, arg);
3396                 }
3397
3398               val = error_mark_node;
3399             }
3400         }
3401       else
3402         {
3403           val = groktypename (arg);
3404           if (! processing_template_decl)
3405             {
3406               /* [basic.link]: A name with no linkage (notably, the
3407                  name of a class or enumeration declared in a local
3408                  scope) shall not be used to declare an entity with
3409                  linkage.  This implies that names with no linkage
3410                  cannot be used as template arguments.  */
3411               tree t = no_linkage_check (val);
3412               if (t)
3413                 {
3414                   if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
3415                     cp_pedwarn
3416                       ("template-argument `%T' uses anonymous type", val);
3417                   else
3418                     cp_error
3419                       ("template-argument `%T' uses local type `%T'",
3420                        val, t);
3421                   return error_mark_node;
3422                 }
3423             }
3424         }
3425     }
3426   else
3427     {
3428       tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
3429
3430       if (invalid_nontype_parm_type_p (t, complain))
3431         return error_mark_node;
3432
3433       if (processing_template_decl)
3434         arg = maybe_fold_nontype_arg (arg);
3435
3436       if (!uses_template_parms (arg) && !uses_template_parms (t))
3437         /* We used to call digest_init here.  However, digest_init
3438            will report errors, which we don't want when complain
3439            is zero.  More importantly, digest_init will try too
3440            hard to convert things: for example, `0' should not be
3441            converted to pointer type at this point according to
3442            the standard.  Accepting this is not merely an
3443            extension, since deciding whether or not these
3444            conversions can occur is part of determining which
3445            function template to call, or whether a given explicit
3446            argument specification is legal.  */
3447         val = convert_nontype_argument (t, arg);
3448       else
3449         val = arg;
3450
3451       if (val == NULL_TREE)
3452         val = error_mark_node;
3453       else if (val == error_mark_node && complain)
3454         cp_error ("could not convert template argument `%E' to `%T'",
3455                   arg, t);
3456     }
3457
3458   return val;
3459 }
3460
3461 /* Convert all template arguments to their appropriate types, and
3462    return a vector containing the innermost resulting template
3463    arguments.  If any error occurs, return error_mark_node, and, if
3464    COMPLAIN is non-zero, issue an error message.  Some error messages
3465    are issued even if COMPLAIN is zero; for instance, if a template
3466    argument is composed from a local class.
3467
3468    If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3469    provided in ARGLIST, or else trailing parameters must have default
3470    values.  If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3471    deduction for any unspecified trailing arguments.  */
3472
3473 static tree
3474 coerce_template_parms (parms, args, in_decl,
3475                        complain,
3476                        require_all_arguments)
3477      tree parms, args;
3478      tree in_decl;
3479      int complain;
3480      int require_all_arguments;
3481 {
3482   int nparms, nargs, i, lost = 0;
3483   tree inner_args;
3484   tree new_args;
3485   tree new_inner_args;
3486
3487   inner_args = INNERMOST_TEMPLATE_ARGS (args);
3488   nargs = NUM_TMPL_ARGS (inner_args);
3489   nparms = TREE_VEC_LENGTH (parms);
3490
3491   if (nargs > nparms
3492       || (nargs < nparms
3493           && require_all_arguments
3494           && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
3495     {
3496       if (complain)
3497         {
3498           cp_error ("wrong number of template arguments (%d, should be %d)",
3499                     nargs, nparms);
3500
3501           if (in_decl)
3502             cp_error_at ("provided for `%D'", in_decl);
3503         }
3504
3505       return error_mark_node;
3506     }
3507
3508   new_inner_args = make_tree_vec (nparms);
3509   new_args = add_outermost_template_args (args, new_inner_args);
3510   for (i = 0; i < nparms; i++)
3511     {
3512       tree arg;
3513       tree parm;
3514
3515       /* Get the Ith template parameter.  */
3516       parm = TREE_VEC_ELT (parms, i);
3517
3518       /* Calculate the Ith argument.  */
3519       if (inner_args && TREE_CODE (inner_args) == TREE_LIST)
3520         {
3521           arg = TREE_VALUE (inner_args);
3522           inner_args = TREE_CHAIN (inner_args);
3523         }
3524       else if (i < nargs)
3525         arg = TREE_VEC_ELT (inner_args, i);
3526       /* If no template argument was supplied, look for a default
3527          value.  */
3528       else if (TREE_PURPOSE (parm) == NULL_TREE)
3529         {
3530           /* There was no default value.  */
3531           my_friendly_assert (!require_all_arguments, 0);
3532           break;
3533         }
3534       else if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL)
3535         arg = tsubst (TREE_PURPOSE (parm), new_args, complain, in_decl);
3536       else
3537         arg = tsubst_expr (TREE_PURPOSE (parm), new_args, complain,
3538                            in_decl);
3539
3540       /* Now, convert the Ith argument, as necessary.  */
3541       if (arg == NULL_TREE)
3542         /* We're out of arguments.  */
3543         {
3544           my_friendly_assert (!require_all_arguments, 0);
3545           break;
3546         }
3547       else if (arg == error_mark_node)
3548         {
3549           cp_error ("template argument %d is invalid", i + 1);
3550           arg = error_mark_node;
3551         }
3552       else
3553         arg = convert_template_argument (TREE_VALUE (parm),
3554                                          arg, new_args, complain, i,
3555                                          in_decl);
3556
3557       if (arg == error_mark_node)
3558         lost++;
3559       TREE_VEC_ELT (new_inner_args, i) = arg;
3560     }
3561
3562   if (lost)
3563     return error_mark_node;
3564
3565   return new_inner_args;
3566 }
3567
3568 /* Returns 1 if template args OT and NT are equivalent.  */
3569
3570 static int
3571 template_args_equal (ot, nt)
3572      tree ot, nt;
3573 {
3574   if (nt == ot)
3575     return 1;
3576
3577   if (TREE_CODE (nt) == TREE_VEC)
3578     /* For member templates */
3579     return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
3580   else if (TYPE_P (nt))
3581     return TYPE_P (ot) && same_type_p (ot, nt);
3582   else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
3583     return 0;
3584   else
3585     return (cp_tree_equal (ot, nt) > 0);
3586 }
3587
3588 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3589    of template arguments.  Returns 0 otherwise.  */
3590
3591 int
3592 comp_template_args (oldargs, newargs)
3593      tree oldargs, newargs;
3594 {
3595   int i;
3596
3597   if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
3598     return 0;
3599
3600   for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
3601     {
3602       tree nt = TREE_VEC_ELT (newargs, i);
3603       tree ot = TREE_VEC_ELT (oldargs, i);
3604
3605       if (! template_args_equal (ot, nt))
3606         return 0;
3607     }
3608   return 1;
3609 }
3610
3611 /* Given class template name and parameter list, produce a user-friendly name
3612    for the instantiation.  */
3613
3614 static char *
3615 mangle_class_name_for_template (name, parms, arglist)
3616      const char *name;
3617      tree parms, arglist;
3618 {
3619   static struct obstack scratch_obstack;
3620   static char *scratch_firstobj;
3621   int i, nparms;
3622
3623   if (!scratch_firstobj)
3624     gcc_obstack_init (&scratch_obstack);
3625   else
3626     obstack_free (&scratch_obstack, scratch_firstobj);
3627   scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
3628
3629 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
3630 #define cat(s)  obstack_grow (&scratch_obstack, (s), strlen (s))
3631
3632   cat (name);
3633   ccat ('<');
3634   nparms = TREE_VEC_LENGTH (parms);
3635   arglist = INNERMOST_TEMPLATE_ARGS (arglist);
3636   my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268);
3637   for (i = 0; i < nparms; i++)
3638     {
3639       tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3640       tree arg = TREE_VEC_ELT (arglist, i);
3641
3642       if (i)
3643         ccat (',');
3644
3645       if (TREE_CODE (parm) == TYPE_DECL)
3646         {
3647           cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
3648           continue;
3649         }
3650       else if (TREE_CODE (parm) == TEMPLATE_DECL)
3651         {
3652           if (TREE_CODE (arg) == TEMPLATE_DECL)
3653             {
3654               /* Already substituted with real template.  Just output
3655                  the template name here */
3656               tree context = DECL_CONTEXT (arg);
3657               if (context)
3658                 {
3659                   /* The template may be defined in a namespace, or
3660                      may be a member template.  */
3661                   my_friendly_assert (TREE_CODE (context) == NAMESPACE_DECL
3662                                       || CLASS_TYPE_P (context),
3663                                       980422);
3664                   cat(decl_as_string (DECL_CONTEXT (arg), TFF_PLAIN_IDENTIFIER));
3665                   cat("::");
3666                 }
3667               cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
3668             }
3669           else
3670             /* Output the parameter declaration */
3671             cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
3672           continue;
3673         }
3674       else
3675         my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269);
3676
3677       if (TREE_CODE (arg) == TREE_LIST)
3678         {
3679           /* New list cell was built because old chain link was in
3680              use.  */
3681           my_friendly_assert (TREE_PURPOSE (arg) == NULL_TREE, 270);
3682           arg = TREE_VALUE (arg);
3683         }
3684       /* No need to check arglist against parmlist here; we did that
3685          in coerce_template_parms, called from lookup_template_class.  */
3686       cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
3687     }
3688   {
3689     char *bufp = obstack_next_free (&scratch_obstack);
3690     int offset = 0;
3691     while (bufp[offset - 1] == ' ')
3692       offset--;
3693     obstack_blank_fast (&scratch_obstack, offset);
3694
3695     /* B<C<char> >, not B<C<char>> */
3696     if (bufp[offset - 1] == '>')
3697       ccat (' ');
3698   }
3699   ccat ('>');
3700   ccat ('\0');
3701   return (char *) obstack_base (&scratch_obstack);
3702 }
3703
3704 static tree
3705 classtype_mangled_name (t)
3706      tree t;
3707 {
3708   if (CLASSTYPE_TEMPLATE_INFO (t)
3709       /* Specializations have already had their names set up in
3710          lookup_template_class.  */
3711       && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
3712     {
3713       tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
3714
3715       /* For non-primary templates, the template parameters are
3716          implicit from their surrounding context.  */
3717       if (PRIMARY_TEMPLATE_P (tmpl))
3718         {
3719           tree name = DECL_NAME (tmpl);
3720           char *mangled_name = mangle_class_name_for_template
3721             (IDENTIFIER_POINTER (name),
3722              DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
3723              CLASSTYPE_TI_ARGS (t));
3724           tree id = get_identifier (mangled_name);
3725           IDENTIFIER_TEMPLATE (id) = name;
3726           return id;
3727         }
3728     }
3729
3730   return TYPE_IDENTIFIER (t);
3731 }
3732
3733 static void
3734 add_pending_template (d)
3735      tree d;
3736 {
3737   tree ti = (TYPE_P (d)
3738              ? CLASSTYPE_TEMPLATE_INFO (d)
3739              : DECL_TEMPLATE_INFO (d));
3740   int level;
3741
3742   if (TI_PENDING_TEMPLATE_FLAG (ti))
3743     return;
3744
3745   /* We are called both from instantiate_decl, where we've already had a
3746      tinst_level pushed, and instantiate_template, where we haven't.
3747      Compensate.  */
3748   level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
3749
3750   if (level)
3751     push_tinst_level (d);
3752
3753   *template_tail = tree_cons (current_tinst_level, d, NULL_TREE);
3754   template_tail = &TREE_CHAIN (*template_tail);
3755   TI_PENDING_TEMPLATE_FLAG (ti) = 1;
3756
3757   if (level)
3758     pop_tinst_level ();
3759 }
3760
3761
3762 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3763    may be either a _DECL or an overloaded function or an
3764    IDENTIFIER_NODE), and ARGLIST.  */
3765
3766 tree
3767 lookup_template_function (fns, arglist)
3768      tree fns, arglist;
3769 {
3770   tree type;
3771
3772   if (fns == NULL_TREE)
3773     {
3774       cp_error ("non-template used as template");
3775       return error_mark_node;
3776     }
3777
3778   type = TREE_TYPE (fns);
3779   if (TREE_CODE (fns) == OVERLOAD || !type)
3780     type = unknown_type_node;
3781
3782   if (processing_template_decl)
3783     return build_min (TEMPLATE_ID_EXPR, type, fns, arglist);
3784   else
3785     return build (TEMPLATE_ID_EXPR, type, fns, arglist);
3786 }
3787
3788 /* Within the scope of a template class S<T>, the name S gets bound
3789    (in build_self_reference) to a TYPE_DECL for the class, not a
3790    TEMPLATE_DECL.  If DECL is a TYPE_DECL for current_class_type,
3791    or one of its enclosing classes, and that type is a template,
3792    return the associated TEMPLATE_DECL.  Otherwise, the original
3793    DECL is returned.  */
3794
3795 static tree
3796 maybe_get_template_decl_from_type_decl (decl)
3797      tree decl;
3798 {
3799   return (decl != NULL_TREE
3800           && TREE_CODE (decl) == TYPE_DECL
3801           && DECL_ARTIFICIAL (decl)
3802           && CLASS_TYPE_P (TREE_TYPE (decl))
3803           && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
3804     ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
3805 }
3806
3807 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3808    parameters, find the desired type.
3809
3810    D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3811    (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC.  It will
3812    be a TREE_LIST if called directly from the parser, and a TREE_VEC
3813    otherwise.)
3814
3815    IN_DECL, if non-NULL, is the template declaration we are trying to
3816    instantiate.
3817
3818    If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3819    the class we are looking up.
3820
3821    If COMPLAIN is non-zero, issue error messages.
3822
3823    If the template class is really a local class in a template
3824    function, then the FUNCTION_CONTEXT is the function in which it is
3825    being instantiated.  */
3826
3827 tree
3828 lookup_template_class (d1, arglist, in_decl, context, entering_scope, complain)
3829      tree d1, arglist;
3830      tree in_decl;
3831      tree context;
3832      int entering_scope;
3833      int complain;
3834 {
3835   tree template = NULL_TREE, parmlist;
3836   tree t;
3837
3838   if (TREE_CODE (d1) == IDENTIFIER_NODE)
3839     {
3840       if (IDENTIFIER_VALUE (d1)
3841           && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1)))
3842         template = IDENTIFIER_VALUE (d1);
3843       else
3844         {
3845           if (context)
3846             push_decl_namespace (context);
3847           template = lookup_name (d1, /*prefer_type=*/0);
3848           template = maybe_get_template_decl_from_type_decl (template);
3849           if (context)
3850             pop_decl_namespace ();
3851         }
3852       if (template)
3853         context = DECL_CONTEXT (template);
3854     }
3855   else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
3856     {
3857       tree type = TREE_TYPE (d1);
3858
3859       /* If we are declaring a constructor, say A<T>::A<T>, we will get
3860          an implicit typename for the second A.  Deal with it.  */
3861       if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
3862         type = TREE_TYPE (type);
3863
3864       if (CLASSTYPE_TEMPLATE_INFO (type))
3865         {
3866           template = CLASSTYPE_TI_TEMPLATE (type);
3867           d1 = DECL_NAME (template);
3868         }
3869     }
3870   else if (TREE_CODE (d1) == ENUMERAL_TYPE
3871            || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
3872     {
3873       template = TYPE_TI_TEMPLATE (d1);
3874       d1 = DECL_NAME (template);
3875     }
3876   else if (TREE_CODE (d1) == TEMPLATE_DECL
3877            && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
3878     {
3879       template = d1;
3880       d1 = DECL_NAME (template);
3881       context = DECL_CONTEXT (template);
3882     }
3883
3884   /* With something like `template <class T> class X class X { ... };'
3885      we could end up with D1 having nothing but an IDENTIFIER_VALUE.
3886      We don't want to do that, but we have to deal with the situation,
3887      so let's give them some syntax errors to chew on instead of a
3888      crash. Alternatively D1 might not be a template type at all.  */
3889   if (! template)
3890     {
3891       if (complain)
3892         cp_error ("`%T' is not a template", d1);
3893       return error_mark_node;
3894     }
3895
3896   if (TREE_CODE (template) != TEMPLATE_DECL
3897          /* If we're called from the parser, make sure it's a user visible
3898             template.  */
3899       || ((!arglist || TREE_CODE (arglist) == TREE_LIST)
3900           && !DECL_TEMPLATE_PARM_P (template)
3901           && !PRIMARY_TEMPLATE_P (template)))
3902     {
3903       if (complain)
3904         {
3905           cp_error ("non-template type `%T' used as a template", d1);
3906           if (in_decl)
3907             cp_error_at ("for template declaration `%D'", in_decl);
3908         }
3909       return error_mark_node;
3910     }
3911
3912   if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
3913     {
3914       /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3915          template arguments */
3916
3917       tree parm;
3918       tree arglist2;
3919
3920       parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
3921
3922       arglist2 = coerce_template_parms (parmlist, arglist, template,
3923                                         complain, /*require_all_args=*/1);
3924       if (arglist2 == error_mark_node)
3925         return error_mark_node;
3926
3927       parm = copy_template_template_parm (TREE_TYPE (template), arglist2);
3928       TYPE_SIZE (parm) = 0;
3929       return parm;
3930     }
3931   else
3932     {
3933       tree template_type = TREE_TYPE (template);
3934       tree gen_tmpl;
3935       tree type_decl;
3936       tree found = NULL_TREE;
3937       tree *tp;
3938       int arg_depth;
3939       int parm_depth;
3940       int is_partial_instantiation;
3941
3942       gen_tmpl = most_general_template (template);
3943       parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
3944       parm_depth = TMPL_PARMS_DEPTH (parmlist);
3945       arg_depth = TMPL_ARGS_DEPTH (arglist);
3946
3947       if (arg_depth == 1 && parm_depth > 1)
3948         {
3949           /* We've been given an incomplete set of template arguments.
3950              For example, given:
3951
3952                template <class T> struct S1 {
3953                  template <class U> struct S2 {};
3954                  template <class U> struct S2<U*> {};
3955                 };
3956
3957              we will be called with an ARGLIST of `U*', but the
3958              TEMPLATE will be `template <class T> template
3959              <class U> struct S1<T>::S2'.  We must fill in the missing
3960              arguments.  */
3961           arglist
3962             = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
3963                                            arglist);
3964           arg_depth = TMPL_ARGS_DEPTH (arglist);
3965         }
3966
3967       /* Now we should enough arguments.  */
3968       my_friendly_assert (parm_depth == arg_depth, 0);
3969
3970       /* From here on, we're only interested in the most general
3971          template.  */
3972       template = gen_tmpl;
3973
3974       /* Calculate the BOUND_ARGS.  These will be the args that are
3975          actually tsubst'd into the definition to create the
3976          instantiation.  */
3977       if (parm_depth > 1)
3978         {
3979           /* We have multiple levels of arguments to coerce, at once.  */
3980           int i;
3981           int saved_depth = TMPL_ARGS_DEPTH (arglist);
3982
3983           tree bound_args = make_tree_vec (parm_depth);
3984
3985           for (i = saved_depth,
3986                  t = DECL_TEMPLATE_PARMS (template);
3987                i > 0 && t != NULL_TREE;
3988                --i, t = TREE_CHAIN (t))
3989             {
3990               tree a = coerce_template_parms (TREE_VALUE (t),
3991                                               arglist, template,
3992                                               complain, /*require_all_args=*/1);
3993               SET_TMPL_ARGS_LEVEL (bound_args, i, a);
3994
3995               /* We temporarily reduce the length of the ARGLIST so
3996                  that coerce_template_parms will see only the arguments
3997                  corresponding to the template parameters it is
3998                  examining.  */
3999               TREE_VEC_LENGTH (arglist)--;
4000             }
4001
4002           /* Restore the ARGLIST to its full size.  */
4003           TREE_VEC_LENGTH (arglist) = saved_depth;
4004
4005           arglist = bound_args;
4006         }
4007       else
4008         arglist
4009           = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4010                                    INNERMOST_TEMPLATE_ARGS (arglist),
4011                                    template,
4012                                    complain, /*require_all_args=*/1);
4013
4014       if (arglist == error_mark_node)
4015         /* We were unable to bind the arguments.  */
4016         return error_mark_node;
4017
4018       /* In the scope of a template class, explicit references to the
4019          template class refer to the type of the template, not any
4020          instantiation of it.  For example, in:
4021
4022            template <class T> class C { void f(C<T>); }
4023
4024          the `C<T>' is just the same as `C'.  Outside of the
4025          class, however, such a reference is an instantiation.  */
4026       if (comp_template_args (TYPE_TI_ARGS (template_type),
4027                               arglist))
4028         {
4029           found = template_type;
4030
4031           if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4032             {
4033               tree ctx;
4034
4035               /* Note that we use DECL_CONTEXT, rather than
4036                  CP_DECL_CONTEXT, so that the termination test is
4037                  always just `ctx'.  We're not interested in namespace
4038                  scopes.  */
4039               for (ctx = current_class_type;
4040                    ctx;
4041                    ctx = (TYPE_P (ctx)) ? TYPE_CONTEXT (ctx) : DECL_CONTEXT (ctx))
4042                 if (same_type_p (ctx, template_type))
4043                   break;
4044
4045               if (!ctx)
4046                 /* We're not in the scope of the class, so the
4047                    TEMPLATE_TYPE is not the type we want after
4048                    all.  */
4049                 found = NULL_TREE;
4050             }
4051         }
4052       if (found)
4053         return found;
4054
4055       for (tp = &DECL_TEMPLATE_INSTANTIATIONS (template);
4056            *tp;
4057            tp = &TREE_CHAIN (*tp))
4058         if (comp_template_args (TREE_PURPOSE (*tp), arglist))
4059           {
4060             found = *tp;
4061
4062             /* Use the move-to-front heuristic to speed up future
4063                searches.  */
4064             *tp = TREE_CHAIN (*tp);
4065             TREE_CHAIN (found)
4066               = DECL_TEMPLATE_INSTANTIATIONS (template);
4067             DECL_TEMPLATE_INSTANTIATIONS (template) = found;
4068
4069             return TREE_VALUE (found);
4070           }
4071
4072       /* This type is a "partial instantiation" if any of the template
4073          arguments still involve template parameters.  Note that we set
4074          IS_PARTIAL_INSTANTIATION for partial specializations as
4075          well.  */
4076       is_partial_instantiation = uses_template_parms (arglist);
4077
4078       if (!is_partial_instantiation
4079           && !PRIMARY_TEMPLATE_P (template)
4080           && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4081         {
4082           found = xref_tag_from_type (TREE_TYPE (template),
4083                                       DECL_NAME (template),
4084                                       /*globalize=*/1);
4085           return found;
4086         }
4087
4088       context = tsubst (DECL_CONTEXT (template), arglist,
4089                         /*complain=*/0, in_decl);
4090       if (!context)
4091         context = global_namespace;
4092
4093       /* Create the type.  */
4094       if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4095         {
4096           if (!is_partial_instantiation)
4097             {
4098               set_current_access_from_decl (TYPE_NAME (template_type));
4099               t = start_enum (TYPE_IDENTIFIER (template_type));
4100             }
4101           else
4102             /* We don't want to call start_enum for this type, since
4103                the values for the enumeration constants may involve
4104                template parameters.  And, no one should be interested
4105                in the enumeration constants for such a type.  */
4106             t = make_node (ENUMERAL_TYPE);
4107         }
4108       else
4109         {
4110           t = make_aggr_type (TREE_CODE (template_type));
4111           CLASSTYPE_DECLARED_CLASS (t)
4112             = CLASSTYPE_DECLARED_CLASS (template_type);
4113           CLASSTYPE_GOT_SEMICOLON (t) = 1;
4114           SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4115           TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4116
4117           /* A local class.  Make sure the decl gets registered properly.  */
4118           if (context == current_function_decl)
4119             pushtag (DECL_NAME (template), t, 0);
4120         }
4121
4122       /* If we called start_enum or pushtag above, this information
4123          will already be set up.  */
4124       if (!TYPE_NAME (t))
4125         {
4126           TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4127
4128           type_decl = create_implicit_typedef (DECL_NAME (template), t);
4129           DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4130           TYPE_STUB_DECL (t) = type_decl;
4131           DECL_SOURCE_FILE (type_decl)
4132             = DECL_SOURCE_FILE (TYPE_STUB_DECL (template_type));
4133           DECL_SOURCE_LINE (type_decl)
4134             = DECL_SOURCE_LINE (TYPE_STUB_DECL (template_type));
4135         }
4136       else
4137         type_decl = TYPE_NAME (t);
4138
4139       /* Set up the template information.  We have to figure out which
4140          template is the immediate parent if this is a full
4141          instantiation.  */
4142       if (parm_depth == 1 || is_partial_instantiation
4143           || !PRIMARY_TEMPLATE_P (template))
4144         /* This case is easy; there are no member templates involved.  */
4145         found = template;
4146       else
4147         {
4148           /* This is a full instantiation of a member template.  Look
4149              for a partial instantiation of which this is an instance.  */
4150
4151           for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4152                found; found = TREE_CHAIN (found))
4153             {
4154               int success;
4155               tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4156
4157               /* We only want partial instantiations, here, not
4158                  specializations or full instantiations.  */
4159               if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4160                   || !uses_template_parms (TREE_VALUE (found)))
4161                 continue;
4162
4163               /* Temporarily reduce by one the number of levels in the
4164                  ARGLIST and in FOUND so as to avoid comparing the
4165                  last set of arguments.  */
4166               TREE_VEC_LENGTH (arglist)--;
4167               TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4168
4169               /* See if the arguments match.  If they do, then TMPL is
4170                  the partial instantiation we want.  */
4171               success = comp_template_args (TREE_PURPOSE (found), arglist);
4172
4173               /* Restore the argument vectors to their full size.  */
4174               TREE_VEC_LENGTH (arglist)++;
4175               TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4176
4177               if (success)
4178                 {
4179                   found = tmpl;
4180                   break;
4181                 }
4182             }
4183
4184           if (!found)
4185             {
4186               /* There was no partial instantiation. This happens
4187                  where C<T> is a member template of A<T> and it's used
4188                  in something like
4189
4190                   template <typename T> struct B { A<T>::C<int> m; };
4191                   B<float>;
4192
4193                  Create the partial instantiation.
4194                */
4195               TREE_VEC_LENGTH (arglist)--;
4196               template = tsubst (template, arglist, /*complain=*/0, NULL_TREE);
4197               TREE_VEC_LENGTH (arglist)++;
4198               found = template;
4199             }
4200         }
4201
4202       SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4203       DECL_TEMPLATE_INSTANTIATIONS (template)
4204         = tree_cons (arglist, t,
4205                      DECL_TEMPLATE_INSTANTIATIONS (template));
4206
4207       if (TREE_CODE (t) == ENUMERAL_TYPE
4208           && !is_partial_instantiation)
4209         /* Now that the type has been registered on the instantiations
4210            list, we set up the enumerators.  Because the enumeration
4211            constants may involve the enumeration type itself, we make
4212            sure to register the type first, and then create the
4213            constants.  That way, doing tsubst_expr for the enumeration
4214            constants won't result in recursive calls here; we'll find
4215            the instantiation and exit above.  */
4216         tsubst_enum (template_type, t, arglist);
4217
4218       /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4219          is set up.  */
4220       if (TREE_CODE (t) != ENUMERAL_TYPE)
4221         DECL_NAME (type_decl) = classtype_mangled_name (t);
4222       DECL_ASSEMBLER_NAME (type_decl) = DECL_NAME (type_decl);
4223       if (!is_partial_instantiation)
4224         {
4225           if (flag_new_abi)
4226             DECL_ASSEMBLER_NAME (type_decl) = mangle_decl (type_decl);
4227           else
4228             DECL_ASSEMBLER_NAME (type_decl)
4229               = get_identifier (build_overload_name (t, 1, 1));
4230
4231           /* For backwards compatibility; code that uses
4232              -fexternal-templates expects looking up a template to
4233              instantiate it.  I think DDD still relies on this.
4234              (jason 8/20/1998) */
4235           if (TREE_CODE (t) != ENUMERAL_TYPE
4236               && flag_external_templates
4237               && CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template))
4238               && ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template)))
4239             add_pending_template (t);
4240         }
4241       else
4242         /* If the type makes use of template parameters, the
4243            code that generates debugging information will crash.  */
4244         DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4245
4246       return t;
4247     }
4248 }
4249 \f
4250 struct pair_fn_data
4251 {
4252   tree_fn_t fn;
4253   void *data;
4254 };
4255
4256 /* Called from for_each_template_parm via walk_tree.  */
4257
4258 static tree
4259 for_each_template_parm_r (tp, walk_subtrees, d)
4260      tree *tp;
4261      int *walk_subtrees;
4262      void *d;
4263 {
4264   tree t = *tp;
4265   struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4266   tree_fn_t fn = pfd->fn;
4267   void *data = pfd->data;
4268
4269   if (TYPE_P (t)
4270       && for_each_template_parm (TYPE_CONTEXT (t), fn, data))
4271     return error_mark_node;
4272
4273   switch (TREE_CODE (t))
4274     {
4275     case RECORD_TYPE:
4276       if (TYPE_PTRMEMFUNC_P (t))
4277         break;
4278       /* Fall through.  */
4279
4280     case UNION_TYPE:
4281     case ENUMERAL_TYPE:
4282       if (!TYPE_TEMPLATE_INFO (t))
4283         *walk_subtrees = 0;
4284       else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4285                                        fn, data))
4286         return error_mark_node;
4287       break;
4288
4289     case METHOD_TYPE:
4290       /* Since we're not going to walk subtrees, we have to do this
4291          explicitly here.  */
4292       if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data))
4293         return error_mark_node;
4294       /* Fall through.  */
4295
4296     case FUNCTION_TYPE:
4297       /* Check the return type.  */
4298       if (for_each_template_parm (TREE_TYPE (t), fn, data))
4299         return error_mark_node;
4300
4301       /* Check the parameter types.  Since default arguments are not
4302          instantiated until they are needed, the TYPE_ARG_TYPES may
4303          contain expressions that involve template parameters.  But,
4304          no-one should be looking at them yet.  And, once they're
4305          instantiated, they don't contain template parameters, so
4306          there's no point in looking at them then, either.  */
4307       {
4308         tree parm;
4309
4310         for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4311           if (for_each_template_parm (TREE_VALUE (parm), fn, data))
4312             return error_mark_node;
4313
4314         /* Since we've already handled the TYPE_ARG_TYPES, we don't
4315            want walk_tree walking into them itself.  */
4316         *walk_subtrees = 0;
4317       }
4318       break;
4319
4320     case FUNCTION_DECL:
4321     case VAR_DECL:
4322       if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
4323           && for_each_template_parm (DECL_TI_ARGS (t), fn, data))
4324         return error_mark_node;
4325       /* Fall through.  */
4326
4327     case CONST_DECL:
4328     case PARM_DECL:
4329       if (DECL_CONTEXT (t)
4330           && for_each_template_parm (DECL_CONTEXT (t), fn, data))
4331         return error_mark_node;
4332       break;
4333
4334     case BOUND_TEMPLATE_TEMPLATE_PARM:
4335       /* Record template parameters such as `T' inside `TT<T>'.  */
4336       if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data))
4337         return error_mark_node;
4338       /* Fall through.  */
4339
4340     case TEMPLATE_TEMPLATE_PARM:
4341     case TEMPLATE_TYPE_PARM:
4342     case TEMPLATE_PARM_INDEX:
4343       if (fn && (*fn)(t, data))
4344         return error_mark_node;
4345       else if (!fn)
4346         return error_mark_node;
4347       break;
4348
4349     case TEMPLATE_DECL:
4350       /* A template template parameter is encountered */
4351       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
4352           && for_each_template_parm (TREE_TYPE (t), fn, data))
4353         return error_mark_node;
4354
4355       /* Already substituted template template parameter */
4356       *walk_subtrees = 0;
4357       break;
4358
4359     case TYPENAME_TYPE:
4360       if (!fn || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn, data))
4361         return error_mark_node;
4362       break;
4363
4364     case CONSTRUCTOR:
4365       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
4366           && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4367                                      (TREE_TYPE (t)), fn, data))
4368         return error_mark_node;
4369       break;
4370
4371     case INDIRECT_REF:
4372     case COMPONENT_REF:
4373       /* If there's no type, then this thing must be some expression
4374          involving template parameters.  */
4375       if (!fn && !TREE_TYPE (t))
4376         return error_mark_node;
4377       break;
4378
4379     case MODOP_EXPR:
4380     case CAST_EXPR:
4381     case REINTERPRET_CAST_EXPR:
4382     case CONST_CAST_EXPR:
4383     case STATIC_CAST_EXPR:
4384     case DYNAMIC_CAST_EXPR:
4385     case ARROW_EXPR:
4386     case DOTSTAR_EXPR:
4387     case TYPEID_EXPR:
4388     case LOOKUP_EXPR:
4389     case PSEUDO_DTOR_EXPR:
4390       if (!fn)
4391         return error_mark_node;
4392       break;
4393
4394     default:
4395       break;
4396     }
4397
4398   /* We didn't find any template parameters we liked.  */
4399   return NULL_TREE;
4400 }
4401
4402 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
4403    BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
4404    call FN with the parameter and the DATA.
4405    If FN returns non-zero, the iteration is terminated, and
4406    for_each_template_parm returns 1.  Otherwise, the iteration
4407    continues.  If FN never returns a non-zero value, the value
4408    returned by for_each_template_parm is 0.  If FN is NULL, it is
4409    considered to be the function which always returns 1.  */
4410
4411 static int
4412 for_each_template_parm (t, fn, data)
4413      tree t;
4414      tree_fn_t fn;
4415      void* data;
4416 {
4417   struct pair_fn_data pfd;
4418
4419   /* Set up.  */
4420   pfd.fn = fn;
4421   pfd.data = data;
4422
4423   /* Walk the tree.  (Conceptually, we would like to walk without
4424      duplicates, but for_each_template_parm_r recursively calls
4425      for_each_template_parm, so we would need to reorganize a fair
4426      bit to use walk_tree_without_duplicates.)  */
4427   return walk_tree (&t,
4428                     for_each_template_parm_r,
4429                     &pfd,
4430                     NULL) != NULL_TREE;
4431 }
4432
4433 int
4434 uses_template_parms (t)
4435      tree t;
4436 {
4437   return for_each_template_parm (t, 0, 0);
4438 }
4439
4440 static int tinst_depth;
4441 extern int max_tinst_depth;
4442 #ifdef GATHER_STATISTICS
4443 int depth_reached;
4444 #endif
4445 static int tinst_level_tick;
4446 static int last_template_error_tick;
4447
4448 /* We're starting to instantiate D; record the template instantiation context
4449    for diagnostics and to restore it later.  */
4450
4451 static int
4452 push_tinst_level (d)
4453      tree d;
4454 {
4455   tree new;
4456
4457   if (tinst_depth >= max_tinst_depth)
4458     {
4459       /* If the instantiation in question still has unbound template parms,
4460          we don't really care if we can't instantiate it, so just return.
4461          This happens with base instantiation for implicit `typename'.  */
4462       if (uses_template_parms (d))
4463         return 0;
4464
4465       last_template_error_tick = tinst_level_tick;
4466       cp_error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'",
4467              max_tinst_depth, d);
4468
4469       print_instantiation_context ();
4470
4471       return 0;
4472     }
4473
4474   new = build_expr_wfl (d, input_filename, lineno, 0);
4475   TREE_CHAIN (new) = current_tinst_level;
4476   current_tinst_level = new;
4477
4478   ++tinst_depth;
4479 #ifdef GATHER_STATISTICS
4480   if (tinst_depth > depth_reached)
4481     depth_reached = tinst_depth;
4482 #endif
4483
4484   ++tinst_level_tick;
4485   return 1;
4486 }
4487
4488 /* We're done instantiating this template; return to the instantiation
4489    context.  */
4490
4491 void
4492 pop_tinst_level ()
4493 {
4494   tree old = current_tinst_level;
4495
4496   /* Restore the filename and line number stashed away when we started
4497      this instantiation.  */
4498   lineno = TINST_LINE (old);
4499   input_filename = TINST_FILE (old);
4500   extract_interface_info ();
4501
4502   current_tinst_level = TREE_CHAIN (old);
4503   --tinst_depth;
4504   ++tinst_level_tick;
4505 }
4506
4507 /* We're instantiating a deferred template; restore the template
4508    instantiation context in which the instantiation was requested, which
4509    is one step out from LEVEL.  */
4510
4511 static void
4512 reopen_tinst_level (level)
4513      tree level;
4514 {
4515   tree t;
4516
4517   tinst_depth = 0;
4518   for (t = level; t; t = TREE_CHAIN (t))
4519     ++tinst_depth;
4520
4521   current_tinst_level = level;
4522   pop_tinst_level ();
4523 }
4524
4525 /* Return the outermost template instantiation context, for use with
4526    -falt-external-templates.  */
4527
4528 tree
4529 tinst_for_decl ()
4530 {
4531   tree p = current_tinst_level;
4532
4533   if (p)
4534     for (; TREE_CHAIN (p) ; p = TREE_CHAIN (p))
4535       ;
4536   return p;
4537 }
4538
4539 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL.  ARGS is the
4540    vector of template arguments, as for tsubst.
4541
4542    Returns an appropriate tsubst'd friend declaration.  */
4543
4544 static tree
4545 tsubst_friend_function (decl, args)
4546      tree decl;
4547      tree args;
4548 {
4549   tree new_friend;
4550   int line = lineno;
4551   const char *file = input_filename;
4552
4553   lineno = DECL_SOURCE_LINE (decl);
4554   input_filename = DECL_SOURCE_FILE (decl);
4555
4556   if (TREE_CODE (decl) == FUNCTION_DECL
4557       && DECL_TEMPLATE_INSTANTIATION (decl)
4558       && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
4559     /* This was a friend declared with an explicit template
4560        argument list, e.g.:
4561
4562        friend void f<>(T);
4563
4564        to indicate that f was a template instantiation, not a new
4565        function declaration.  Now, we have to figure out what
4566        instantiation of what template.  */
4567     {
4568       tree template_id, arglist, fns;
4569       tree new_args;
4570       tree tmpl;
4571       tree ns = CP_DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
4572
4573       /* Friend functions are looked up in the containing namespace scope.
4574          We must enter that scope, to avoid finding member functions of the
4575          current cless with same name.  */
4576       push_nested_namespace (ns);
4577       fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
4578                          /*complain=*/1, NULL_TREE);
4579       pop_nested_namespace (ns);
4580       arglist = tsubst (DECL_TI_ARGS (decl), args,
4581                         /*complain=*/1, NULL_TREE);
4582       template_id = lookup_template_function (fns, arglist);
4583
4584       new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE);
4585       tmpl = determine_specialization (template_id, new_friend,
4586                                        &new_args,
4587                                        /*need_member_template=*/0);
4588       new_friend = instantiate_template (tmpl, new_args);
4589       goto done;
4590     }
4591
4592   new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE);
4593
4594   /* The NEW_FRIEND will look like an instantiation, to the
4595      compiler, but is not an instantiation from the point of view of
4596      the language.  For example, we might have had:
4597
4598      template <class T> struct S {
4599        template <class U> friend void f(T, U);
4600      };
4601
4602      Then, in S<int>, template <class U> void f(int, U) is not an
4603      instantiation of anything.  */
4604   DECL_USE_TEMPLATE (new_friend) = 0;
4605   if (TREE_CODE (decl) == TEMPLATE_DECL)
4606     {
4607       DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
4608       DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
4609         = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
4610     }
4611
4612   /* The mangled name for the NEW_FRIEND is incorrect.  The call to
4613      tsubst will have resulted in a call to
4614      set_mangled_name_for_template_decl.  But, the function is not a
4615      template instantiation and should not be mangled like one.
4616      Therefore, we remangle the function name.  We don't have to do
4617      this if the NEW_FRIEND is a template since
4618      set_mangled_name_for_template_decl doesn't do anything if the
4619      function declaration still uses template arguments.  */
4620   if (TREE_CODE (new_friend) != TEMPLATE_DECL)
4621     {
4622       set_mangled_name_for_decl (new_friend);
4623       DECL_RTL (new_friend) = 0;
4624       make_decl_rtl (new_friend, NULL_PTR);
4625     }
4626
4627   if (DECL_NAMESPACE_SCOPE_P (new_friend))
4628     {
4629       tree old_decl;
4630       tree new_friend_template_info;
4631       tree new_friend_result_template_info;
4632       tree ns;
4633       int  new_friend_is_defn;
4634
4635       /* We must save some information from NEW_FRIEND before calling
4636          duplicate decls since that function will free NEW_FRIEND if
4637          possible.  */
4638       new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
4639       if (TREE_CODE (new_friend) == TEMPLATE_DECL)
4640         {
4641           /* This declaration is a `primary' template.  */
4642           DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
4643
4644           new_friend_is_defn
4645             = DECL_INITIAL (DECL_TEMPLATE_RESULT (new_friend)) != NULL_TREE;
4646           new_friend_result_template_info
4647             = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
4648         }
4649       else
4650         {
4651           new_friend_is_defn = DECL_INITIAL (new_friend) != NULL_TREE;
4652           new_friend_result_template_info = NULL_TREE;
4653         }
4654
4655       /* Inside pushdecl_namespace_level, we will push into the
4656          current namespace. However, the friend function should go
4657          into the namespace of the template. */
4658       ns = decl_namespace_context (new_friend);
4659       push_nested_namespace (ns);
4660       old_decl = pushdecl_namespace_level (new_friend);
4661       pop_nested_namespace (ns);
4662
4663       if (old_decl != new_friend)
4664         {
4665           /* This new friend declaration matched an existing
4666              declaration.  For example, given:
4667
4668                template <class T> void f(T);
4669                template <class U> class C {
4670                  template <class T> friend void f(T) {}
4671                };
4672
4673              the friend declaration actually provides the definition
4674              of `f', once C has been instantiated for some type.  So,
4675              old_decl will be the out-of-class template declaration,
4676              while new_friend is the in-class definition.
4677
4678              But, if `f' was called before this point, the
4679              instantiation of `f' will have DECL_TI_ARGS corresponding
4680              to `T' but not to `U', references to which might appear
4681              in the definition of `f'.  Previously, the most general
4682              template for an instantiation of `f' was the out-of-class
4683              version; now it is the in-class version.  Therefore, we
4684              run through all specialization of `f', adding to their
4685              DECL_TI_ARGS appropriately.  In particular, they need a
4686              new set of outer arguments, corresponding to the
4687              arguments for this class instantiation.
4688
4689              The same situation can arise with something like this:
4690
4691                friend void f(int);
4692                template <class T> class C {
4693                  friend void f(T) {}
4694                };
4695
4696              when `C<int>' is instantiated.  Now, `f(int)' is defined
4697              in the class.  */
4698
4699           if (!new_friend_is_defn)
4700             /* On the other hand, if the in-class declaration does
4701                *not* provide a definition, then we don't want to alter
4702                existing definitions.  We can just leave everything
4703                alone.  */
4704             ;
4705           else
4706             {
4707               /* Overwrite whatever template info was there before, if
4708                  any, with the new template information pertaining to
4709                  the declaration.  */
4710               DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
4711
4712               if (TREE_CODE (old_decl) != TEMPLATE_DECL)
4713                 /* duplicate_decls will take care of this case.  */
4714                 ;
4715               else
4716                 {
4717                   tree t;
4718                   tree new_friend_args;
4719
4720                   DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
4721                     = new_friend_result_template_info;
4722
4723                   new_friend_args = TI_ARGS (new_friend_template_info);
4724                   for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
4725                        t != NULL_TREE;
4726                        t = TREE_CHAIN (t))
4727                     {
4728                       tree spec = TREE_VALUE (t);
4729
4730                       DECL_TI_ARGS (spec)
4731                         = add_outermost_template_args (new_friend_args,
4732                                                        DECL_TI_ARGS (spec));
4733                     }
4734
4735                   /* Now, since specializations are always supposed to
4736                      hang off of the most general template, we must move
4737                      them.  */
4738                   t = most_general_template (old_decl);
4739                   if (t != old_decl)
4740                     {
4741                       DECL_TEMPLATE_SPECIALIZATIONS (t)
4742                         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
4743                                    DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
4744                       DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
4745                     }
4746                 }
4747             }
4748
4749           /* The information from NEW_FRIEND has been merged into OLD_DECL
4750              by duplicate_decls.  */
4751           new_friend = old_decl;
4752         }
4753     }
4754   else if (COMPLETE_TYPE_P (DECL_CONTEXT (new_friend)))
4755     {
4756       /* Check to see that the declaration is really present, and,
4757          possibly obtain an improved declaration.  */
4758       tree fn = check_classfn (DECL_CONTEXT (new_friend),
4759                                new_friend);
4760
4761       if (fn)
4762         new_friend = fn;
4763     }
4764
4765  done:
4766   lineno = line;
4767   input_filename = file;
4768   return new_friend;
4769 }
4770
4771 /* FRIEND_TMPL is a friend TEMPLATE_DECL.  ARGS is the vector of
4772    template arguments, as for tsubst.
4773
4774    Returns an appropriate tsubst'd friend type or error_mark_node on
4775    failure.  */
4776
4777 static tree
4778 tsubst_friend_class (friend_tmpl, args)
4779      tree friend_tmpl;
4780      tree args;
4781 {
4782   tree friend_type;
4783   tree tmpl;
4784
4785   /* First, we look for a class template.  */
4786   tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0);
4787
4788   /* But, if we don't find one, it might be because we're in a
4789      situation like this:
4790
4791        template <class T>
4792        struct S {
4793          template <class U>
4794          friend struct S;
4795        };
4796
4797      Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
4798      for `S<int>', not the TEMPLATE_DECL.  */
4799   if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
4800     {
4801       tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1);
4802       tmpl = maybe_get_template_decl_from_type_decl (tmpl);
4803     }
4804
4805   if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
4806     {
4807       /* The friend template has already been declared.  Just
4808          check to see that the declarations match, and install any new
4809          default parameters.  We must tsubst the default parameters,
4810          of course.  We only need the innermost template parameters
4811          because that is all that redeclare_class_template will look
4812          at.  */
4813       tree parms
4814         = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
4815                                  args, /*complain=*/1);
4816       if (!parms)
4817         return error_mark_node;
4818       redeclare_class_template (TREE_TYPE (tmpl), parms);
4819       friend_type = TREE_TYPE (tmpl);
4820     }
4821   else
4822     {
4823       /* The friend template has not already been declared.  In this
4824          case, the instantiation of the template class will cause the
4825          injection of this template into the global scope.  */
4826       tmpl = tsubst (friend_tmpl, args, /*complain=*/1, NULL_TREE);
4827
4828       /* The new TMPL is not an instantiation of anything, so we
4829          forget its origins.  We don't reset CLASSTYPE_TI_TEMPLATE for
4830          the new type because that is supposed to be the corresponding
4831          template decl, i.e., TMPL.  */
4832       DECL_USE_TEMPLATE (tmpl) = 0;
4833       DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
4834       CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
4835
4836       /* Inject this template into the global scope.  */
4837       friend_type = TREE_TYPE (pushdecl_top_level (tmpl));
4838     }
4839
4840   return friend_type;
4841 }
4842
4843 tree
4844 instantiate_class_template (type)
4845      tree type;
4846 {
4847   tree template, args, pattern, t;
4848   tree typedecl;
4849
4850   if (type == error_mark_node)
4851     return error_mark_node;
4852
4853   if (TYPE_BEING_DEFINED (type) || COMPLETE_TYPE_P (type))
4854     return type;
4855
4856   /* Figure out which template is being instantiated.  */
4857   template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
4858   my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL, 279);
4859
4860   /* Figure out which arguments are being used to do the
4861      instantiation.  */
4862   args = CLASSTYPE_TI_ARGS (type);
4863   PARTIAL_INSTANTIATION_P (type) = uses_template_parms (args);
4864
4865   if (pedantic && PARTIAL_INSTANTIATION_P (type))
4866     /* If this is a partial instantiation, then we can't instantiate
4867        the type; there's no telling whether or not one of the
4868        template parameters might eventually be instantiated to some
4869        value that results in a specialization being used.  For
4870        example, consider:
4871
4872          template <class T>
4873          struct S {};
4874
4875          template <class U>
4876          void f(S<U>);
4877
4878          template <>
4879          struct S<int> {};
4880
4881        Now, the `S<U>' in `f<int>' is the specialization, not an
4882        instantiation of the original template.  */
4883     return type;
4884
4885   /* Determine what specialization of the original template to
4886      instantiate.  */
4887   if (PARTIAL_INSTANTIATION_P (type))
4888     /* There's no telling which specialization is appropriate at this
4889        point.  Since all peeking at the innards of this partial
4890        instantiation are extensions (like the "implicit typename"
4891        extension, which allows users to omit the keyword `typename' on
4892        names that are declared as types in template base classes), we
4893        are free to do what we please.
4894
4895        Trying to figure out which partial instantiation to use can
4896        cause a crash.  (Some of the template arguments don't even have
4897        types.)  So, we just use the most general version.  */
4898     t = NULL_TREE;
4899   else
4900     {
4901       t = most_specialized_class (template, args);
4902
4903       if (t == error_mark_node)
4904         {
4905           const char *str = "candidates are:";
4906           cp_error ("ambiguous class template instantiation for `%#T'", type);
4907           for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t;
4908                t = TREE_CHAIN (t))
4909             {
4910               if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t),
4911                                       args))
4912                 {
4913                   cp_error_at ("%s %+#T", str, TREE_TYPE (t));
4914                   str = "               ";
4915                 }
4916             }
4917           TYPE_BEING_DEFINED (type) = 1;
4918           return error_mark_node;
4919         }
4920     }
4921
4922   if (t)
4923     pattern = TREE_TYPE (t);
4924   else
4925     pattern = TREE_TYPE (template);
4926
4927   /* If the template we're instantiating is incomplete, then clearly
4928      there's nothing we can do.  */
4929   if (!COMPLETE_TYPE_P (pattern))
4930     return type;
4931
4932   /* If this is a partial instantiation, don't tsubst anything.  We will
4933      only use this type for implicit typename, so the actual contents don't
4934      matter.  All that matters is whether a particular name is a type.  */
4935   if (PARTIAL_INSTANTIATION_P (type))
4936     {
4937       /* The fields set here must be kept in sync with those cleared
4938          in begin_class_definition.  */
4939       TYPE_BINFO_BASETYPES (type) = TYPE_BINFO_BASETYPES (pattern);
4940       TYPE_FIELDS (type) = TYPE_FIELDS (pattern);
4941       TYPE_METHODS (type) = TYPE_METHODS (pattern);
4942       CLASSTYPE_TAGS (type) = CLASSTYPE_TAGS (pattern);
4943       CLASSTYPE_VBASECLASSES (type) = CLASSTYPE_VBASECLASSES (pattern);
4944
4945       /* Pretend that the type is complete, so that we will look
4946          inside it during name lookup and such.  */
4947       TYPE_SIZE (type) = bitsize_zero_node;
4948       return type;
4949     }
4950
4951   /* If we've recursively instantiated too many templates, stop.  */
4952   if (! push_tinst_level (type))
4953     return type;
4954
4955   /* Now we're really doing the instantiation.  Mark the type as in
4956      the process of being defined.  */
4957   TYPE_BEING_DEFINED (type) = 1;
4958
4959   maybe_push_to_top_level (uses_template_parms (type));
4960
4961   if (t)
4962     {
4963       /* This TYPE is actually a instantiation of of a partial
4964          specialization.  We replace the innermost set of ARGS with
4965          the arguments appropriate for substitution.  For example,
4966          given:
4967
4968            template <class T> struct S {};
4969            template <class T> struct S<T*> {};
4970
4971          and supposing that we are instantiating S<int*>, ARGS will
4972          present be {int*} but we need {int}.  */
4973       tree inner_args
4974         = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t),
4975                               args);
4976
4977       /* If there were multiple levels in ARGS, replacing the
4978          innermost level would alter CLASSTYPE_TI_ARGS, which we don't
4979          want, so we make a copy first.  */
4980       if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
4981         {
4982           args = copy_node (args);
4983           SET_TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args), inner_args);
4984         }
4985       else
4986         args = inner_args;
4987     }
4988
4989   if (flag_external_templates)
4990     {
4991       if (flag_alt_external_templates)
4992         {
4993           CLASSTYPE_INTERFACE_ONLY (type) = interface_only;
4994           SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type, interface_unknown);
4995           CLASSTYPE_VTABLE_NEEDS_WRITING (type)
4996             = (! CLASSTYPE_INTERFACE_ONLY (type)
4997                && CLASSTYPE_INTERFACE_KNOWN (type));
4998         }
4999       else
5000         {
5001           CLASSTYPE_INTERFACE_ONLY (type) = CLASSTYPE_INTERFACE_ONLY (pattern);
5002           SET_CLASSTYPE_INTERFACE_UNKNOWN_X
5003             (type, CLASSTYPE_INTERFACE_UNKNOWN (pattern));
5004           CLASSTYPE_VTABLE_NEEDS_WRITING (type)
5005             = (! CLASSTYPE_INTERFACE_ONLY (type)
5006                && CLASSTYPE_INTERFACE_KNOWN (type));
5007         }
5008     }
5009   else
5010     {
5011       SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5012       CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
5013     }
5014
5015   TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5016   TYPE_HAS_DESTRUCTOR (type) = TYPE_HAS_DESTRUCTOR (pattern);
5017   TYPE_OVERLOADS_CALL_EXPR (type) = TYPE_OVERLOADS_CALL_EXPR (pattern);
5018   TYPE_OVERLOADS_ARRAY_REF (type) = TYPE_OVERLOADS_ARRAY_REF (pattern);
5019   TYPE_OVERLOADS_ARROW (type) = TYPE_OVERLOADS_ARROW (pattern);
5020   TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5021   TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5022   TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5023   TYPE_VEC_DELETE_TAKES_SIZE (type) = TYPE_VEC_DELETE_TAKES_SIZE (pattern);
5024   TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5025   TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5026   TYPE_HAS_ABSTRACT_ASSIGN_REF (type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern);
5027   TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5028   TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5029   TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5030   TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5031   TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
5032     = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (pattern);
5033   TYPE_USES_MULTIPLE_INHERITANCE (type)
5034     = TYPE_USES_MULTIPLE_INHERITANCE (pattern);
5035   TYPE_USES_VIRTUAL_BASECLASSES (type)
5036     = TYPE_USES_VIRTUAL_BASECLASSES (pattern);
5037   TYPE_PACKED (type) = TYPE_PACKED (pattern);
5038   TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5039   TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5040   TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5041   if (ANON_AGGR_TYPE_P (pattern))
5042     SET_ANON_AGGR_TYPE_P (type);
5043
5044   if (TYPE_BINFO_BASETYPES (pattern))
5045     {
5046       tree base_list = NULL_TREE;
5047       tree pbases = TYPE_BINFO_BASETYPES (pattern);
5048       int i;
5049
5050       /* Substitute into each of the bases to determine the actual
5051          basetypes.  */
5052       for (i = 0; i < TREE_VEC_LENGTH (pbases); ++i)
5053         {
5054           tree base;
5055           tree access;
5056           tree pbase;
5057
5058           pbase = TREE_VEC_ELT (pbases, i);
5059
5060           /* Substitute to figure out the base class.  */
5061           base = tsubst (BINFO_TYPE (pbase), args,
5062                          /*complain=*/1, NULL_TREE);
5063           if (base == error_mark_node)
5064             continue;
5065
5066           /* Calculate the correct access node.  */
5067           if (TREE_VIA_VIRTUAL (pbase))
5068             {
5069               if (TREE_VIA_PUBLIC (pbase))
5070                 access = access_public_virtual_node;
5071               else if (TREE_VIA_PROTECTED (pbase))
5072                 access = access_protected_virtual_node;
5073               else
5074                 access = access_private_virtual_node;
5075             }
5076           else
5077             {
5078               if (TREE_VIA_PUBLIC (pbase))
5079                 access = access_public_node;
5080               else if (TREE_VIA_PROTECTED (pbase))
5081                 access = access_protected_node;
5082               else
5083                 access = access_private_node;
5084             }
5085
5086           base_list = tree_cons (access, base, base_list);
5087         }
5088
5089       /* The list is now in reverse order; correct that.  */
5090       base_list = nreverse (base_list);
5091
5092       /* Now call xref_basetypes to set up all the base-class
5093          information.  */
5094       xref_basetypes (TREE_CODE (pattern) == RECORD_TYPE
5095                       ? (CLASSTYPE_DECLARED_CLASS (pattern)
5096                          ? class_type_node : record_type_node)
5097                       : union_type_node,
5098                       DECL_NAME (TYPE_NAME (pattern)),
5099                       type,
5100                       base_list);
5101     }
5102
5103   /* Now that our base classes are set up, enter the scope of the
5104      class, so that name lookups into base classes, etc. will work
5105      correctly.  This is precisely analogous to what we do in
5106      begin_class_definition when defining an ordinary non-template
5107      class.  */
5108   pushclass (type, 1);
5109
5110   for (t = CLASSTYPE_TAGS (pattern); t; t = TREE_CHAIN (t))
5111     {
5112       tree tag = TREE_VALUE (t);
5113       tree name = TYPE_IDENTIFIER (tag);
5114       tree newtag;
5115
5116       newtag = tsubst (tag, args, /*complain=*/1, NULL_TREE);
5117       my_friendly_assert (newtag != error_mark_node, 20010206);
5118       if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5119         {
5120           if (TYPE_LANG_SPECIFIC (tag) && CLASSTYPE_IS_TEMPLATE (tag))
5121             /* Unfortunately, lookup_template_class sets
5122                CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5123                instantiation (i.e., for the type of a member template
5124                class nested within a template class.)  This behavior is
5125                required for maybe_process_partial_specialization to work
5126                correctly, but is not accurate in this case; the TAG is not
5127                an instantiation of anything.  (The corresponding
5128                TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
5129             CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5130
5131           /* Now, we call pushtag to put this NEWTAG into the scope of
5132              TYPE.  We first set up the IDENTIFIER_TYPE_VALUE to avoid
5133              pushtag calling push_template_decl.  We don't have to do
5134              this for enums because it will already have been done in
5135              tsubst_enum.  */
5136           if (name)
5137             SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5138           pushtag (name, newtag, /*globalize=*/0);
5139         }
5140     }
5141
5142   /* Don't replace enum constants here.  */
5143   for (t = TYPE_FIELDS (pattern); t; t = TREE_CHAIN (t))
5144     if (TREE_CODE (t) != CONST_DECL)
5145       {
5146         tree r;
5147
5148         /* The the file and line for this declaration, to assist in
5149            error message reporting.  Since we called push_tinst_level
5150            above, we don't need to restore these.  */
5151         lineno = DECL_SOURCE_LINE (t);
5152         input_filename = DECL_SOURCE_FILE (t);
5153
5154         r = tsubst (t, args, /*complain=*/1, NULL_TREE);
5155         if (TREE_CODE (r) == VAR_DECL)
5156           {
5157             tree init;
5158
5159             if (DECL_INITIALIZED_IN_CLASS_P (r))
5160               init = tsubst_expr (DECL_INITIAL (t), args,
5161                                   /*complain=*/1, NULL_TREE);
5162             else
5163               init = NULL_TREE;
5164
5165             finish_static_data_member_decl (r, init,
5166                                             /*asmspec_tree=*/NULL_TREE,
5167                                             /*flags=*/0);
5168
5169             if (DECL_INITIALIZED_IN_CLASS_P (r))
5170               check_static_variable_definition (r, TREE_TYPE (r));
5171           }
5172
5173         /* R will have a TREE_CHAIN if and only if it has already been
5174            processed by finish_member_declaration.  This can happen
5175            if, for example, it is a TYPE_DECL for a class-scoped
5176            ENUMERAL_TYPE; such a thing will already have been added to
5177            the field list by tsubst_enum above.  */
5178         if (!TREE_CHAIN (r))
5179           {
5180             set_current_access_from_decl (r);
5181             finish_member_declaration (r);
5182           }
5183       }
5184
5185   /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
5186      for this instantiation.  */
5187   for (t = TYPE_METHODS (pattern); t; t = TREE_CHAIN (t))
5188     {
5189       tree r = tsubst (t, args, /*complain=*/1, NULL_TREE);
5190       set_current_access_from_decl (r);
5191       finish_member_declaration (r);
5192     }
5193
5194   /* Construct the DECL_FRIENDLIST for the new class type.  */
5195   typedecl = TYPE_MAIN_DECL (type);
5196   for (t = DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern));
5197        t != NULL_TREE;
5198        t = TREE_CHAIN (t))
5199     {
5200       tree friends;
5201
5202       for (friends = TREE_VALUE (t);
5203            friends != NULL_TREE;
5204            friends = TREE_CHAIN (friends))
5205         if (TREE_PURPOSE (friends) == error_mark_node)
5206           add_friend (type,
5207                       tsubst_friend_function (TREE_VALUE (friends),
5208                                               args));
5209         else
5210           my_friendly_abort (20000216);
5211     }
5212
5213   for (t = CLASSTYPE_FRIEND_CLASSES (pattern);
5214        t != NULL_TREE;
5215        t = TREE_CHAIN (t))
5216     {
5217       tree friend_type = TREE_VALUE (t);
5218       tree new_friend_type;
5219
5220       if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5221         new_friend_type = tsubst_friend_class (friend_type, args);
5222       else if (uses_template_parms (friend_type))
5223         new_friend_type = tsubst (friend_type, args, /*complain=*/1,
5224                                   NULL_TREE);
5225       else
5226         {
5227           tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
5228
5229           /* The call to xref_tag_from_type does injection for friend
5230              classes.  */
5231           push_nested_namespace (ns);
5232           new_friend_type =
5233             xref_tag_from_type (friend_type, NULL_TREE, 1);
5234           pop_nested_namespace (ns);
5235         }
5236
5237       if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5238         /* Trick make_friend_class into realizing that the friend
5239            we're adding is a template, not an ordinary class.  It's
5240            important that we use make_friend_class since it will
5241            perform some error-checking and output cross-reference
5242            information.  */
5243         ++processing_template_decl;
5244
5245       if (new_friend_type != error_mark_node)
5246         make_friend_class (type, new_friend_type);
5247
5248       if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5249         --processing_template_decl;
5250     }
5251
5252   for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
5253     if (TREE_CODE (t) == FIELD_DECL)
5254       {
5255         TREE_TYPE (t) = complete_type (TREE_TYPE (t));
5256         require_complete_type (t);
5257       }
5258
5259   /* Set the file and line number information to whatever is given for
5260      the class itself.  This puts error messages involving generated
5261      implicit functions at a predictable point, and the same point
5262      that would be used for non-template classes.  */
5263   lineno = DECL_SOURCE_LINE (typedecl);
5264   input_filename = DECL_SOURCE_FILE (typedecl);
5265
5266   unreverse_member_declarations (type);
5267   finish_struct_1 (type);
5268   CLASSTYPE_GOT_SEMICOLON (type) = 1;
5269
5270   /* Clear this now so repo_template_used is happy.  */
5271   TYPE_BEING_DEFINED (type) = 0;
5272   repo_template_used (type);
5273
5274   /* Now that the class is complete, instantiate default arguments for
5275      any member functions.  We don't do this earlier because the
5276      default arguments may reference members of the class.  */
5277   if (!PRIMARY_TEMPLATE_P (template))
5278     for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
5279       if (TREE_CODE (t) == FUNCTION_DECL
5280           /* Implicitly generated member functions will not have template
5281              information; they are not instantiations, but instead are
5282              created "fresh" for each instantiation.  */
5283           && DECL_TEMPLATE_INFO (t))
5284         tsubst_default_arguments (t);
5285
5286   popclass ();
5287   pop_from_top_level ();
5288   pop_tinst_level ();
5289
5290   return type;
5291 }
5292
5293 static int
5294 list_eq (t1, t2)
5295      tree t1, t2;
5296 {
5297   if (t1 == NULL_TREE)
5298     return t2 == NULL_TREE;
5299   if (t2 == NULL_TREE)
5300     return 0;
5301   /* Don't care if one declares its arg const and the other doesn't -- the
5302      main variant of the arg type is all that matters.  */
5303   if (TYPE_MAIN_VARIANT (TREE_VALUE (t1))
5304       != TYPE_MAIN_VARIANT (TREE_VALUE (t2)))
5305     return 0;
5306   return list_eq (TREE_CHAIN (t1), TREE_CHAIN (t2));
5307 }
5308
5309 /* If arg is a non-type template parameter that does not depend on template
5310    arguments, fold it like we weren't in the body of a template.  */
5311
5312 static tree
5313 maybe_fold_nontype_arg (arg)
5314      tree arg;
5315 {
5316   /* If we're not in a template, ARG is already as simple as it's going to
5317      get, and trying to reprocess the trees will break.  */
5318   if (! processing_template_decl)
5319     return arg;
5320
5321   if (!TYPE_P (arg) && !uses_template_parms (arg))
5322     {
5323       /* Sometimes, one of the args was an expression involving a
5324          template constant parameter, like N - 1.  Now that we've
5325          tsubst'd, we might have something like 2 - 1.  This will
5326          confuse lookup_template_class, so we do constant folding
5327          here.  We have to unset processing_template_decl, to
5328          fool build_expr_from_tree() into building an actual
5329          tree.  */
5330
5331       int saved_processing_template_decl = processing_template_decl;
5332       processing_template_decl = 0;
5333       arg = fold (build_expr_from_tree (arg));
5334       processing_template_decl = saved_processing_template_decl;
5335     }
5336   return arg;
5337 }
5338
5339 /* Substitute ARGS into the vector of template arguments T.  */
5340
5341 static tree
5342 tsubst_template_arg_vector (t, args, complain)
5343      tree t;
5344      tree args;
5345      int complain;
5346 {
5347   int len = TREE_VEC_LENGTH (t), need_new = 0, i;
5348   tree *elts = (tree *) alloca (len * sizeof (tree));
5349
5350   memset ((char *) elts, 0, len * sizeof (tree));
5351
5352   for (i = 0; i < len; i++)
5353     {
5354       if (TREE_VEC_ELT (t, i) != NULL_TREE
5355           && TREE_CODE (TREE_VEC_ELT (t, i)) == TREE_VEC)
5356         elts[i] = tsubst_template_arg_vector (TREE_VEC_ELT (t, i),
5357                                               args, complain);
5358       else
5359         elts[i] = maybe_fold_nontype_arg
5360           (tsubst_expr (TREE_VEC_ELT (t, i), args, complain,
5361                         NULL_TREE));
5362
5363       if (elts[i] == error_mark_node)
5364         return error_mark_node;
5365
5366       if (elts[i] != TREE_VEC_ELT (t, i))
5367         need_new = 1;
5368     }
5369
5370   if (!need_new)
5371     return t;
5372
5373   t = make_tree_vec (len);
5374   for (i = 0; i < len; i++)
5375     TREE_VEC_ELT (t, i) = elts[i];
5376
5377   return t;
5378 }
5379
5380 /* Return the result of substituting ARGS into the template parameters
5381    given by PARMS.  If there are m levels of ARGS and m + n levels of
5382    PARMS, then the result will contain n levels of PARMS.  For
5383    example, if PARMS is `template <class T> template <class U>
5384    template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5385    result will be `template <int*, double, class V>'.  */
5386
5387 static tree
5388 tsubst_template_parms (parms, args, complain)
5389      tree parms;
5390      tree args;
5391      int complain;
5392 {
5393   tree r = NULL_TREE;
5394   tree* new_parms;
5395
5396   for (new_parms = &r;
5397        TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
5398        new_parms = &(TREE_CHAIN (*new_parms)),
5399          parms = TREE_CHAIN (parms))
5400     {
5401       tree new_vec =
5402         make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
5403       int i;
5404
5405       for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
5406         {
5407           tree default_value =
5408             TREE_PURPOSE (TREE_VEC_ELT (TREE_VALUE (parms), i));
5409           tree parm_decl =
5410             TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms), i));
5411
5412           TREE_VEC_ELT (new_vec, i)
5413             = build_tree_list (tsubst (default_value, args, complain,
5414                                        NULL_TREE),
5415                                tsubst (parm_decl, args, complain,
5416                                        NULL_TREE));
5417         }
5418
5419       *new_parms =
5420         tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
5421                              - TMPL_ARGS_DEPTH (args)),
5422                    new_vec, NULL_TREE);
5423     }
5424
5425   return r;
5426 }
5427
5428 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5429    type T.  If T is not an aggregate or enumeration type, it is
5430    handled as if by tsubst.  IN_DECL is as for tsubst.  If
5431    ENTERING_SCOPE is non-zero, T is the context for a template which
5432    we are presently tsubst'ing.  Return the substituted value.  */
5433
5434 static tree
5435 tsubst_aggr_type (t, args, complain, in_decl, entering_scope)
5436      tree t;
5437      tree args;
5438      int complain;
5439      tree in_decl;
5440      int entering_scope;
5441 {
5442   if (t == NULL_TREE)
5443     return NULL_TREE;
5444
5445   switch (TREE_CODE (t))
5446     {
5447     case RECORD_TYPE:
5448       if (TYPE_PTRMEMFUNC_P (t))
5449         {
5450           tree r = build_ptrmemfunc_type
5451             (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl));
5452           return cp_build_qualified_type_real (r, TYPE_QUALS (t),
5453                                                complain);
5454         }
5455
5456       /* else fall through */
5457     case ENUMERAL_TYPE:
5458     case UNION_TYPE:
5459       if (TYPE_TEMPLATE_INFO (t))
5460         {
5461           tree argvec;
5462           tree context;
5463           tree r;
5464
5465           /* First, determine the context for the type we are looking
5466              up.  */
5467           if (TYPE_CONTEXT (t) != NULL_TREE)
5468             context = tsubst_aggr_type (TYPE_CONTEXT (t), args,
5469                                         complain,
5470                                         in_decl, /*entering_scope=*/1);
5471           else
5472             context = NULL_TREE;
5473
5474           /* Then, figure out what arguments are appropriate for the
5475              type we are trying to find.  For example, given:
5476
5477                template <class T> struct S;
5478                template <class T, class U> void f(T, U) { S<U> su; }
5479
5480              and supposing that we are instantiating f<int, double>,
5481              then our ARGS will be {int, double}, but, when looking up
5482              S we only want {double}.  */
5483           argvec = tsubst_template_arg_vector (TYPE_TI_ARGS (t), args,
5484                                                complain);
5485           if (argvec == error_mark_node)
5486             return error_mark_node;
5487
5488           r = lookup_template_class (t, argvec, in_decl, context,
5489                                      entering_scope, complain);
5490
5491           return cp_build_qualified_type_real (r, TYPE_QUALS (t),
5492                                                complain);
5493         }
5494       else
5495         /* This is not a template type, so there's nothing to do.  */
5496         return t;
5497
5498     default:
5499       return tsubst (t, args, complain, in_decl);
5500     }
5501 }
5502
5503 /* Substitute into the default argument ARG (a default argument for
5504    FN), which has the indicated TYPE.  */
5505
5506 tree
5507 tsubst_default_argument (fn, type, arg)
5508      tree fn;
5509      tree type;
5510      tree arg;
5511 {
5512   /* This default argument came from a template.  Instantiate the
5513      default argument here, not in tsubst.  In the case of
5514      something like:
5515
5516        template <class T>
5517        struct S {
5518          static T t();
5519          void f(T = t());
5520        };
5521
5522      we must be careful to do name lookup in the scope of S<T>,
5523      rather than in the current class.  */
5524   if (DECL_CLASS_SCOPE_P (fn))
5525     pushclass (DECL_CONTEXT (fn), 2);
5526
5527   arg = tsubst_expr (arg, DECL_TI_ARGS (fn), /*complain=*/1, NULL_TREE);
5528
5529   if (DECL_CLASS_SCOPE_P (fn))
5530     popclass ();
5531
5532   /* Make sure the default argument is reasonable.  */
5533   arg = check_default_argument (type, arg);
5534
5535   return arg;
5536 }
5537
5538 /* Substitute into all the default arguments for FN.  */
5539
5540 static void
5541 tsubst_default_arguments (fn)
5542      tree fn;
5543 {
5544   tree arg;
5545   tree tmpl_args;
5546
5547   tmpl_args = DECL_TI_ARGS (fn);
5548
5549   /* If this function is not yet instantiated, we certainly don't need
5550      its default arguments.  */
5551   if (uses_template_parms (tmpl_args))
5552     return;
5553
5554   for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
5555        arg;
5556        arg = TREE_CHAIN (arg))
5557     if (TREE_PURPOSE (arg))
5558       TREE_PURPOSE (arg) = tsubst_default_argument (fn,
5559                                                     TREE_VALUE (arg),
5560                                                     TREE_PURPOSE (arg));
5561 }
5562
5563 /* Substitute the ARGS into the T, which is a _DECL.  TYPE is the
5564    (already computed) substitution of ARGS into TREE_TYPE (T), if
5565    appropriate.  Return the result of the substitution.  */
5566
5567 static tree
5568 tsubst_decl (t, args, type)
5569      tree t;
5570      tree args;
5571      tree type;
5572 {
5573   int saved_lineno;
5574   const char *saved_filename;
5575   tree r = NULL_TREE;
5576   tree in_decl = t;
5577
5578   /* Set the filename and linenumber to improve error-reporting.  */
5579   saved_lineno = lineno;
5580   saved_filename = input_filename;
5581   lineno = DECL_SOURCE_LINE (t);
5582   input_filename = DECL_SOURCE_FILE (t);
5583
5584   switch (TREE_CODE (t))
5585     {
5586     case TEMPLATE_DECL:
5587       {
5588         /* We can get here when processing a member template function
5589            of a template class.  */
5590         tree decl = DECL_TEMPLATE_RESULT (t);
5591         tree spec;
5592         int is_template_template_parm = DECL_TEMPLATE_TEMPLATE_PARM_P (t);
5593
5594         if (!is_template_template_parm)
5595           {
5596             /* We might already have an instance of this template.
5597                The ARGS are for the surrounding class type, so the
5598                full args contain the tsubst'd args for the context,
5599                plus the innermost args from the template decl.  */
5600             tree tmpl_args = DECL_CLASS_TEMPLATE_P (t)
5601               ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
5602               : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
5603             tree full_args;
5604
5605             full_args = tsubst_template_arg_vector (tmpl_args, args,
5606                                                     /*complain=*/1);
5607
5608             /* tsubst_template_arg_vector doesn't copy the vector if
5609                nothing changed.  But, *something* should have
5610                changed.  */
5611             my_friendly_assert (full_args != tmpl_args, 0);
5612
5613             spec = retrieve_specialization (t, full_args);
5614             if (spec != NULL_TREE)
5615               {
5616                 r = spec;
5617                 break;
5618               }
5619           }
5620
5621         /* Make a new template decl.  It will be similar to the
5622            original, but will record the current template arguments.
5623            We also create a new function declaration, which is just
5624            like the old one, but points to this new template, rather
5625            than the old one.  */
5626         r = copy_decl (t);
5627         my_friendly_assert (DECL_LANG_SPECIFIC (r) != 0, 0);
5628         TREE_CHAIN (r) = NULL_TREE;
5629
5630         if (is_template_template_parm)
5631           {
5632             tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl);
5633             DECL_TEMPLATE_RESULT (r) = new_decl;
5634             TREE_TYPE (r) = TREE_TYPE (new_decl);
5635             break;
5636           }
5637
5638         DECL_CONTEXT (r)
5639           = tsubst_aggr_type (DECL_CONTEXT (t), args,
5640                               /*complain=*/1, in_decl,
5641                               /*entering_scope=*/1);
5642         DECL_VIRTUAL_CONTEXT (r)
5643           = tsubst_aggr_type (DECL_VIRTUAL_CONTEXT (t), args,
5644                               /*complain=*/1, in_decl,
5645                               /*entering_scope=*/1);
5646         DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
5647
5648         if (TREE_CODE (decl) == TYPE_DECL)
5649           {
5650             tree new_type = tsubst (TREE_TYPE (t), args,
5651                                     /*complain=*/1, in_decl);
5652             TREE_TYPE (r) = new_type;
5653             CLASSTYPE_TI_TEMPLATE (new_type) = r;
5654             DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
5655             DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
5656           }
5657         else
5658           {
5659             tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl);
5660
5661             DECL_TEMPLATE_RESULT (r) = new_decl;
5662             DECL_TI_TEMPLATE (new_decl) = r;
5663             TREE_TYPE (r) = TREE_TYPE (new_decl);
5664             DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
5665           }
5666
5667         SET_DECL_IMPLICIT_INSTANTIATION (r);
5668         DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
5669         DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
5670
5671         /* The template parameters for this new template are all the
5672            template parameters for the old template, except the
5673            outermost level of parameters. */
5674         DECL_TEMPLATE_PARMS (r)
5675           = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
5676                                    /*complain=*/1);
5677
5678         if (PRIMARY_TEMPLATE_P (t))
5679           DECL_PRIMARY_TEMPLATE (r) = r;
5680
5681         /* We don't partially instantiate partial specializations.  */
5682         if (TREE_CODE (decl) == TYPE_DECL)
5683           break;
5684
5685         /* Record this partial instantiation.  */
5686         register_specialization (r, t,
5687                                  DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)));
5688
5689       }
5690       break;
5691
5692     case FUNCTION_DECL:
5693       {
5694         tree ctx;
5695         tree argvec = NULL_TREE;
5696         tree *friends;
5697         tree gen_tmpl;
5698         int member;
5699         int args_depth;
5700         int parms_depth;
5701
5702         /* Nobody should be tsubst'ing into non-template functions.  */
5703         my_friendly_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE, 0);
5704
5705         if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
5706           {
5707             tree spec;
5708
5709             /* Calculate the most general template of which R is a
5710                specialization, and the complete set of arguments used to
5711                specialize R.  */
5712             gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
5713             argvec
5714               = tsubst_template_arg_vector (DECL_TI_ARGS
5715                                             (DECL_TEMPLATE_RESULT (gen_tmpl)),
5716                                             args, /*complain=*/1);
5717
5718             /* Check to see if we already have this specialization.  */
5719             spec = retrieve_specialization (gen_tmpl, argvec);
5720
5721             if (spec)
5722               {
5723                 r = spec;
5724                 break;
5725               }
5726
5727             /* We can see more levels of arguments than parameters if
5728                there was a specialization of a member template, like
5729                this:
5730
5731                  template <class T> struct S { template <class U> void f(); }
5732                  template <> template <class U> void S<int>::f(U);
5733
5734                Here, we'll be substituting into the specialization,
5735                because that's where we can find the code we actually
5736                want to generate, but we'll have enough arguments for
5737                the most general template.
5738
5739                We also deal with the peculiar case:
5740
5741                  template <class T> struct S {
5742                    template <class U> friend void f();
5743                  };
5744                  template <class U> void f() {}
5745                  template S<int>;
5746                  template void f<double>();
5747
5748                Here, the ARGS for the instantiation of will be {int,
5749                double}.  But, we only need as many ARGS as there are
5750                levels of template parameters in CODE_PATTERN.  We are
5751                careful not to get fooled into reducing the ARGS in
5752                situations like:
5753
5754                  template <class T> struct S { template <class U> void f(U); }
5755                  template <class T> template <> void S<T>::f(int) {}
5756
5757                which we can spot because the pattern will be a
5758                specialization in this case.  */
5759             args_depth = TMPL_ARGS_DEPTH (args);
5760             parms_depth =
5761               TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
5762             if (args_depth > parms_depth
5763                 && !DECL_TEMPLATE_SPECIALIZATION (t))
5764               args = get_innermost_template_args (args, parms_depth);
5765           }
5766         else
5767           {
5768             /* This special case arises when we have something like this:
5769
5770                  template <class T> struct S {
5771                    friend void f<int>(int, double);
5772                  };
5773
5774                Here, the DECL_TI_TEMPLATE for the friend declaration
5775                will be a LOOKUP_EXPR or an IDENTIFIER_NODE.  We are
5776                being called from tsubst_friend_function, and we want
5777                only to create a new decl (R) with appropriate types so
5778                that we can call determine_specialization.  */
5779             my_friendly_assert ((TREE_CODE (DECL_TI_TEMPLATE (t))
5780                                  == LOOKUP_EXPR)
5781                                 || (TREE_CODE (DECL_TI_TEMPLATE (t))
5782                                     == IDENTIFIER_NODE), 0);
5783             gen_tmpl = NULL_TREE;
5784           }
5785
5786         if (DECL_CLASS_SCOPE_P (t))
5787           {
5788             if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
5789               member = 2;
5790             else
5791               member = 1;
5792             ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
5793                                     /*complain=*/1, t,
5794                                     /*entering_scope=*/1);
5795           }
5796         else
5797           {
5798             member = 0;
5799             ctx = DECL_CONTEXT (t);
5800           }
5801         type = tsubst (type, args, /*complain=*/1, in_decl);
5802         if (type == error_mark_node)
5803           return error_mark_node;
5804
5805         /* We do NOT check for matching decls pushed separately at this
5806            point, as they may not represent instantiations of this
5807            template, and in any case are considered separate under the
5808            discrete model.  */
5809         r = copy_decl (t);
5810         DECL_USE_TEMPLATE (r) = 0;
5811         TREE_TYPE (r) = type;
5812
5813         DECL_CONTEXT (r) = ctx;
5814         DECL_VIRTUAL_CONTEXT (r)
5815           = tsubst_aggr_type (DECL_VIRTUAL_CONTEXT (t), args,
5816                               /*complain=*/1, t,
5817                               /*entering_scope=*/1);
5818
5819         if (member && DECL_CONV_FN_P (r))
5820           {
5821             /* Type-conversion operator.  Reconstruct the name, in
5822                case it's the name of one of the template's parameters.  */
5823             if (flag_new_abi)
5824               DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
5825             else
5826               DECL_NAME (r) = build_typename_overload (TREE_TYPE (type));
5827           }
5828
5829         DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
5830                                      /*complain=*/1, t);
5831         DECL_RESULT (r) = NULL_TREE;
5832
5833         TREE_STATIC (r) = 0;
5834         TREE_PUBLIC (r) = TREE_PUBLIC (t);
5835         DECL_EXTERNAL (r) = 1;
5836         DECL_INTERFACE_KNOWN (r) = 0;
5837         DECL_DEFER_OUTPUT (r) = 0;
5838         TREE_CHAIN (r) = NULL_TREE;
5839         DECL_PENDING_INLINE_INFO (r) = 0;
5840         DECL_PENDING_INLINE_P (r) = 0;
5841         DECL_SAVED_TREE (r) = NULL_TREE;
5842         TREE_USED (r) = 0;
5843         if (DECL_CLONED_FUNCTION (r))
5844           {
5845             DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
5846                                                args, /*complain=*/1, t);
5847             TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
5848             TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
5849           }
5850
5851         /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled
5852            name.  There's no need to do this in the special friend
5853            case mentioned above where GEN_TMPL is NULL.  */
5854         if (gen_tmpl)
5855           {
5856             DECL_TEMPLATE_INFO (r)
5857               = tree_cons (gen_tmpl, argvec, NULL_TREE);
5858             SET_DECL_IMPLICIT_INSTANTIATION (r);
5859             register_specialization (r, gen_tmpl, argvec);
5860
5861             /* Set the mangled name for R.  */
5862             if (DECL_DESTRUCTOR_P (t))
5863               {
5864                 if (flag_new_abi)
5865                   set_mangled_name_for_decl (r);
5866                 else
5867                   DECL_ASSEMBLER_NAME (r) = build_destructor_name (ctx);
5868               }
5869             else
5870               {
5871                 /* Instantiations of template functions must be mangled
5872                    specially, in order to conform to 14.5.5.1
5873                    [temp.over.link].  */
5874                 tree tmpl = DECL_TI_TEMPLATE (t);
5875
5876                 /* TMPL will be NULL if this is a specialization of a
5877                    member function of a template class.  */
5878                 if (name_mangling_version < 1
5879                     || tmpl == NULL_TREE
5880                     || (member && !is_member_template (tmpl)
5881                         && !DECL_TEMPLATE_INFO (tmpl)))
5882                   set_mangled_name_for_decl (r);
5883                 else
5884                   set_mangled_name_for_template_decl (r);
5885               }
5886
5887             DECL_RTL (r) = 0;
5888             make_decl_rtl (r, NULL_PTR);
5889
5890             /* Like grokfndecl.  If we don't do this, pushdecl will
5891                mess up our TREE_CHAIN because it doesn't find a
5892                previous decl.  Sigh.  */
5893             if (member
5894                 && ! uses_template_parms (r)
5895                 && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r))
5896                     == NULL_TREE))
5897               SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r), r);
5898
5899             /* We're not supposed to instantiate default arguments
5900                until they are called, for a template.  But, for a
5901                declaration like:
5902
5903                  template <class T> void f ()
5904                  { extern void g(int i = T()); }
5905
5906                we should do the substitution when the template is
5907                instantiated.  We handle the member function case in
5908                instantiate_class_template since the default arguments
5909                might refer to other members of the class.  */
5910             if (!member
5911                 && !PRIMARY_TEMPLATE_P (gen_tmpl)
5912                 && !uses_template_parms (argvec))
5913               tsubst_default_arguments (r);
5914           }
5915
5916         /* Copy the list of befriending classes.  */
5917         for (friends = &DECL_BEFRIENDING_CLASSES (r);
5918              *friends;
5919              friends = &TREE_CHAIN (*friends))
5920           {
5921             *friends = copy_node (*friends);
5922             TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
5923                                             args, /*complain=*/1,
5924                                             in_decl);
5925           }
5926
5927         if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
5928           {
5929             maybe_retrofit_in_chrg (r);
5930             if (DECL_CONSTRUCTOR_P (r))
5931               grok_ctor_properties (ctx, r);
5932             /* If this is an instantiation of a member template, clone it.
5933                If it isn't, that'll be handled by
5934                clone_constructors_and_destructors.  */
5935             if (PRIMARY_TEMPLATE_P (gen_tmpl))
5936               clone_function_decl(r, /*update_method_vec_p=*/0);
5937           }
5938         else if (IDENTIFIER_OPNAME_P (DECL_NAME (r)))
5939           grok_op_properties (r, DECL_VIRTUAL_P (r), DECL_FRIEND_P (r));
5940       }
5941       break;
5942
5943     case PARM_DECL:
5944       {
5945         r = copy_node (t);
5946         TREE_TYPE (r) = type;
5947         c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
5948
5949         if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
5950           DECL_INITIAL (r) = TREE_TYPE (r);
5951         else
5952           DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
5953                                      /*complain=*/1, in_decl);
5954
5955         DECL_CONTEXT (r) = NULL_TREE;
5956         if (PROMOTE_PROTOTYPES
5957             && (TREE_CODE (type) == INTEGER_TYPE
5958                 || TREE_CODE (type) == ENUMERAL_TYPE)
5959             && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5960           DECL_ARG_TYPE (r) = integer_type_node;
5961         if (TREE_CHAIN (t))
5962           TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
5963                                    /*complain=*/1, TREE_CHAIN (t));
5964       }
5965       break;
5966
5967     case FIELD_DECL:
5968       {
5969         r = copy_decl (t);
5970         TREE_TYPE (r) = type;
5971         c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
5972
5973         /* We don't have to set DECL_CONTEXT here; it is set by
5974            finish_member_declaration.  */
5975         DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args,
5976                                         /*complain=*/1, in_decl);
5977         TREE_CHAIN (r) = NULL_TREE;
5978         if (TREE_CODE (type) == VOID_TYPE)
5979           cp_error_at ("instantiation of `%D' as type void", r);
5980       }
5981       break;
5982
5983     case USING_DECL:
5984       {
5985         r = copy_node (t);
5986         DECL_INITIAL (r)
5987           = tsubst_copy (DECL_INITIAL (t), args, /*complain=*/1, in_decl);
5988         TREE_CHAIN (r) = NULL_TREE;
5989       }
5990       break;
5991
5992     case TYPE_DECL:
5993       if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5994           || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
5995         {
5996           /* If this is the canonical decl, we don't have to mess with
5997              instantiations, and often we can't (for typename, template
5998              type parms and such).  Note that TYPE_NAME is not correct for
5999              the above test if we've copied the type for a typedef.  */
6000           r = TYPE_NAME (type);
6001           break;
6002         }
6003
6004       /* Fall through.  */
6005
6006     case VAR_DECL:
6007       {
6008         tree argvec = NULL_TREE;
6009         tree gen_tmpl = NULL_TREE;
6010         tree spec;
6011         tree tmpl = NULL_TREE;
6012         tree ctx;
6013         int local_p;
6014
6015         /* Assume this is a non-local variable.  */
6016         local_p = 0;
6017
6018         if (TYPE_P (CP_DECL_CONTEXT (t)))
6019           ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6020                                   /*complain=*/1,
6021                                   in_decl, /*entering_scope=*/1);
6022         else
6023           {
6024             /* Subsequent calls to pushdecl will fill this in.  */
6025             ctx = NULL_TREE;
6026             if (!DECL_NAMESPACE_SCOPE_P (t))
6027               local_p = 1;
6028           }
6029
6030         /* Check to see if we already have this specialization.  */
6031         if (!local_p)
6032           {
6033             tmpl = DECL_TI_TEMPLATE (t);
6034             gen_tmpl = most_general_template (tmpl);
6035             argvec = tsubst (DECL_TI_ARGS (t), args, /*complain=*/1, in_decl);
6036             spec = retrieve_specialization (gen_tmpl, argvec);
6037           }
6038         else
6039           spec = retrieve_local_specialization (t);
6040
6041         if (spec)
6042           {
6043             r = spec;
6044             break;
6045           }
6046
6047         r = copy_decl (t);
6048         TREE_TYPE (r) = type;
6049         c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
6050         DECL_CONTEXT (r) = ctx;
6051
6052         /* Don't try to expand the initializer until someone tries to use
6053            this variable; otherwise we run into circular dependencies.  */
6054         DECL_INITIAL (r) = NULL_TREE;
6055         DECL_RTL (r) = 0;
6056         DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
6057
6058         /* For __PRETTY_FUNCTION__ we have to adjust the initializer.  */
6059         if (DECL_PRETTY_FUNCTION_P (r))
6060           {
6061             DECL_INITIAL (r) = tsubst (DECL_INITIAL (t),
6062                                        args,
6063                                        /*complain=*/1,
6064                                        NULL_TREE);
6065             TREE_TYPE (r) = TREE_TYPE (DECL_INITIAL (r));
6066           }
6067
6068         /* Even if the original location is out of scope, the newly
6069            substituted one is not.  */
6070         if (TREE_CODE (r) == VAR_DECL)
6071           DECL_DEAD_FOR_LOCAL (r) = 0;
6072
6073         if (!local_p)
6074           {
6075             /* A static data member declaration is always marked
6076                external when it is declared in-class, even if an
6077                initializer is present.  We mimic the non-template
6078                processing here.  */
6079             DECL_EXTERNAL (r) = 1;
6080
6081             register_specialization (r, gen_tmpl, argvec);
6082             DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
6083             SET_DECL_IMPLICIT_INSTANTIATION (r);
6084           }
6085         else
6086           register_local_specialization (r, t);
6087
6088         TREE_CHAIN (r) = NULL_TREE;
6089         if (TREE_CODE (r) == VAR_DECL && TREE_CODE (type) == VOID_TYPE)
6090           cp_error_at ("instantiation of `%D' as type void", r);
6091       }
6092       break;
6093
6094     default:
6095       my_friendly_abort (0);
6096     }
6097
6098   /* Restore the file and line information.  */
6099   lineno = saved_lineno;
6100   input_filename = saved_filename;
6101
6102   return r;
6103 }
6104
6105 /* Substitue into the ARG_TYPES of a function type.  */
6106
6107 static tree
6108 tsubst_arg_types (arg_types, args, complain, in_decl)
6109      tree arg_types;
6110      tree args;
6111      int complain;
6112      tree in_decl;
6113 {
6114   tree remaining_arg_types;
6115   tree type;
6116
6117   if (!arg_types || arg_types == void_list_node)
6118     return arg_types;
6119
6120   remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
6121                                           args, complain, in_decl);
6122   if (remaining_arg_types == error_mark_node)
6123     return error_mark_node;
6124
6125   type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
6126   if (type == error_mark_node)
6127     return error_mark_node;
6128   if (VOID_TYPE_P (type))
6129     {
6130       if (complain)
6131         {
6132           cp_error ("invalid parameter type `%T'", type);
6133           if (in_decl)
6134             cp_error_at ("in declaration `%D'", in_decl);
6135         }
6136       return error_mark_node;
6137     }
6138
6139   /* Do array-to-pointer, function-to-pointer conversion, and ignore
6140      top-level qualifiers as required.  */
6141   type = TYPE_MAIN_VARIANT (type_decays_to (type));
6142
6143   /* Note that we do not substitute into default arguments here.  The
6144      standard mandates that they be instantiated only when needed,
6145      which is done in build_over_call.  */
6146   return hash_tree_cons (TREE_PURPOSE (arg_types), type,
6147                          remaining_arg_types);
6148
6149 }
6150
6151 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE.  This routine does
6152    *not* handle the exception-specification for FNTYPE, because the
6153    initial substitution of explicitly provided template parameters
6154    during argument deduction forbids substitution into the
6155    exception-specification:
6156
6157      [temp.deduct]
6158
6159      All references in the function type of the function template to  the
6160      corresponding template parameters are replaced by the specified tem-
6161      plate argument values.  If a substitution in a template parameter or
6162      in  the function type of the function template results in an invalid
6163      type, type deduction fails.  [Note: The equivalent  substitution  in
6164      exception specifications is done only when the function is instanti-
6165      ated, at which point a program is  ill-formed  if  the  substitution
6166      results in an invalid type.]  */
6167
6168 static tree
6169 tsubst_function_type (t, args, complain, in_decl)
6170      tree t;
6171      tree args;
6172      int complain;
6173      tree in_decl;
6174 {
6175   tree return_type;
6176   tree arg_types;
6177   tree fntype;
6178
6179   /* The TYPE_CONTEXT is not used for function/method types.  */
6180   my_friendly_assert (TYPE_CONTEXT (t) == NULL_TREE, 0);
6181
6182   /* Substitue the return type.  */
6183   return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6184   if (return_type == error_mark_node)
6185     return error_mark_node;
6186
6187   /* Substitue the argument types.  */
6188   arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
6189                                 complain, in_decl);
6190   if (arg_types == error_mark_node)
6191     return error_mark_node;
6192
6193   /* Construct a new type node and return it.  */
6194   if (TREE_CODE (t) == FUNCTION_TYPE)
6195     fntype = build_function_type (return_type, arg_types);
6196   else
6197     {
6198       tree r = TREE_TYPE (TREE_VALUE (arg_types));
6199       if (! IS_AGGR_TYPE (r))
6200         {
6201           /* [temp.deduct]
6202
6203              Type deduction may fail for any of the following
6204              reasons:
6205
6206              -- Attempting to create "pointer to member of T" when T
6207              is not a class type.  */
6208           if (complain)
6209             cp_error ("creating pointer to member function of non-class type `%T'",
6210                       r);
6211           return error_mark_node;
6212         }
6213
6214       fntype = build_cplus_method_type (r, return_type, TREE_CHAIN
6215                                         (arg_types));
6216     }
6217   fntype = build_qualified_type (fntype, TYPE_QUALS (t));
6218   fntype = build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
6219
6220   return fntype;
6221 }
6222
6223 /* Substitute into the PARMS of a call-declarator.  */
6224
6225 static tree
6226 tsubst_call_declarator_parms (parms, args, complain, in_decl)
6227      tree parms;
6228      tree args;
6229      int complain;
6230      tree in_decl;
6231 {
6232   tree new_parms;
6233   tree type;
6234   tree defarg;
6235
6236   if (!parms || parms == void_list_node)
6237     return parms;
6238
6239   new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms),
6240                                             args, complain, in_decl);
6241
6242   /* Figure out the type of this parameter.  */
6243   type = tsubst (TREE_VALUE (parms), args, complain, in_decl);
6244
6245   /* Figure out the default argument as well.  Note that we use
6246      tsubst_expr since the default argument is really an expression.  */
6247   defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl);
6248
6249   /* Chain this parameter on to the front of those we have already
6250      processed.  We don't use hash_tree_cons because that function
6251      doesn't check TREE_PARMLIST.  */
6252   new_parms = tree_cons (defarg, type, new_parms);
6253
6254   /* And note that these are parameters.  */
6255   TREE_PARMLIST (new_parms) = 1;
6256
6257   return new_parms;
6258 }
6259
6260 /* Take the tree structure T and replace template parameters used
6261    therein with the argument vector ARGS.  IN_DECL is an associated
6262    decl for diagnostics.  If an error occurs, returns ERROR_MARK_NODE.
6263    An appropriate error message is issued only if COMPLAIN is
6264    non-zero.  Note that we must be relatively non-tolerant of
6265    extensions here, in order to preserve conformance; if we allow
6266    substitutions that should not be allowed, we may allow argument
6267    deductions that should not succeed, and therefore report ambiguous
6268    overload situations where there are none.  In theory, we could
6269    allow the substitution, but indicate that it should have failed,
6270    and allow our caller to make sure that the right thing happens, but
6271    we don't try to do this yet.
6272
6273    This function is used for dealing with types, decls and the like;
6274    for expressions, use tsubst_expr or tsubst_copy.  */
6275
6276 tree
6277 tsubst (t, args, complain, in_decl)
6278      tree t, args;
6279      int complain;
6280      tree in_decl;
6281 {
6282   tree type, r;
6283
6284   if (t == NULL_TREE || t == error_mark_node
6285       || t == integer_type_node
6286       || t == void_type_node
6287       || t == char_type_node
6288       || TREE_CODE (t) == NAMESPACE_DECL)
6289     return t;
6290
6291   if (TREE_CODE (t) == IDENTIFIER_NODE)
6292     type = IDENTIFIER_TYPE_VALUE (t);
6293   else
6294     type = TREE_TYPE (t);
6295   if (type == unknown_type_node)
6296     my_friendly_abort (42);
6297
6298   if (type && TREE_CODE (t) != FUNCTION_DECL
6299       && TREE_CODE (t) != TYPENAME_TYPE
6300       && TREE_CODE (t) != TEMPLATE_DECL
6301       && TREE_CODE (t) != IDENTIFIER_NODE
6302       && TREE_CODE (t) != FUNCTION_TYPE
6303       && TREE_CODE (t) != METHOD_TYPE)
6304     type = tsubst (type, args, complain, in_decl);
6305   if (type == error_mark_node)
6306     return error_mark_node;
6307
6308   if (DECL_P (t))
6309     return tsubst_decl (t, args, type);
6310
6311   switch (TREE_CODE (t))
6312     {
6313     case RECORD_TYPE:
6314     case UNION_TYPE:
6315     case ENUMERAL_TYPE:
6316       return tsubst_aggr_type (t, args, complain, in_decl,
6317                                /*entering_scope=*/0);
6318
6319     case ERROR_MARK:
6320     case IDENTIFIER_NODE:
6321     case OP_IDENTIFIER:
6322     case VOID_TYPE:
6323     case REAL_TYPE:
6324     case COMPLEX_TYPE:
6325     case VECTOR_TYPE:
6326     case BOOLEAN_TYPE:
6327     case INTEGER_CST:
6328     case REAL_CST:
6329     case STRING_CST:
6330       return t;
6331
6332     case INTEGER_TYPE:
6333       if (t == integer_type_node)
6334         return t;
6335
6336       if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
6337           && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
6338         return t;
6339
6340       {
6341         tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
6342
6343         max = tsubst_expr (omax, args, complain, in_decl);
6344         if (max == error_mark_node)
6345           return error_mark_node;
6346
6347         /* See if we can reduce this expression to something simpler.  */
6348         max = maybe_fold_nontype_arg (max);
6349         if (!processing_template_decl)
6350           max = decl_constant_value (max);
6351
6352         if (processing_template_decl
6353             /* When providing explicit arguments to a template
6354                function, but leaving some arguments for subsequent
6355                deduction, MAX may be template-dependent even if we're
6356                not PROCESSING_TEMPLATE_DECL.  We still need to check for
6357                template parms, though; MAX won't be an INTEGER_CST for
6358                dynamic arrays, either.  */
6359             || (TREE_CODE (max) != INTEGER_CST
6360                 && uses_template_parms (max)))
6361           {
6362             tree itype = make_node (INTEGER_TYPE);
6363             TYPE_MIN_VALUE (itype) = size_zero_node;
6364             TYPE_MAX_VALUE (itype) = build_min (MINUS_EXPR, sizetype, max,
6365                                                 integer_one_node);
6366             return itype;
6367           }
6368
6369         if (integer_zerop (omax))
6370           {
6371             /* Still allow an explicit array of size zero.  */
6372             if (pedantic)
6373               pedwarn ("creating array with size zero");
6374           }
6375         else if (integer_zerop (max)
6376                  || (TREE_CODE (max) == INTEGER_CST
6377                      && INT_CST_LT (max, integer_zero_node)))
6378           {
6379             /* [temp.deduct]
6380
6381                Type deduction may fail for any of the following
6382                reasons:
6383
6384                  Attempting to create an array with a size that is
6385                  zero or negative.  */
6386             if (complain)
6387               cp_error ("creating array with size zero (`%E')", max);
6388
6389             return error_mark_node;
6390           }
6391
6392         return compute_array_index_type (NULL_TREE, max);
6393       }
6394
6395     case TEMPLATE_TYPE_PARM:
6396     case TEMPLATE_TEMPLATE_PARM:
6397     case BOUND_TEMPLATE_TEMPLATE_PARM:
6398     case TEMPLATE_PARM_INDEX:
6399       {
6400         int idx;
6401         int level;
6402         int levels;
6403
6404         r = NULL_TREE;
6405
6406         if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
6407             || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
6408             || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
6409           {
6410             idx = TEMPLATE_TYPE_IDX (t);
6411             level = TEMPLATE_TYPE_LEVEL (t);
6412           }
6413         else
6414           {
6415             idx = TEMPLATE_PARM_IDX (t);
6416             level = TEMPLATE_PARM_LEVEL (t);
6417           }
6418
6419         if (TREE_VEC_LENGTH (args) > 0)
6420           {
6421             tree arg = NULL_TREE;
6422
6423             levels = TMPL_ARGS_DEPTH (args);
6424             if (level <= levels)
6425               arg = TMPL_ARG (args, level, idx);
6426
6427             if (arg == error_mark_node)
6428               return error_mark_node;
6429             else if (arg != NULL_TREE)
6430               {
6431                 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
6432                   {
6433                     my_friendly_assert (TYPE_P (arg), 0);
6434                     return cp_build_qualified_type_real
6435                       (arg, CP_TYPE_QUALS (arg) | CP_TYPE_QUALS (t),
6436                        complain);
6437                   }
6438                 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
6439                   {
6440                     /* We are processing a type constructed from
6441                        a template template parameter */
6442                     tree argvec = tsubst (TYPE_TI_ARGS (t),
6443                                           args, complain, in_decl);
6444                     if (argvec == error_mark_node)
6445                       return error_mark_node;
6446
6447                     /* We can get a TEMPLATE_TEMPLATE_PARM here when
6448                        we are resolving nested-types in the signature of
6449                        a member function templates.
6450                        Otherwise ARG is a TEMPLATE_DECL and is the real
6451                        template to be instantiated.  */
6452                     if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
6453                       arg = TYPE_NAME (arg);
6454
6455                     r = lookup_template_class (arg,
6456                                                argvec, in_decl,
6457                                                DECL_CONTEXT (arg),
6458                                                /*entering_scope=*/0,
6459                                                complain);
6460                     return cp_build_qualified_type_real (r,
6461                                                          TYPE_QUALS (t),
6462                                                          complain);
6463                   }
6464                 else
6465                   /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX.  */
6466                   return arg;
6467               }
6468           }
6469         else
6470           my_friendly_abort (981018);
6471
6472         if (level == 1)
6473           /* This can happen during the attempted tsubst'ing in
6474              unify.  This means that we don't yet have any information
6475              about the template parameter in question.  */
6476           return t;
6477
6478         /* If we get here, we must have been looking at a parm for a
6479            more deeply nested template.  Make a new version of this
6480            template parameter, but with a lower level.  */
6481         switch (TREE_CODE (t))
6482           {
6483           case TEMPLATE_TYPE_PARM:
6484           case TEMPLATE_TEMPLATE_PARM:
6485           case BOUND_TEMPLATE_TEMPLATE_PARM:
6486             if (CP_TYPE_QUALS (t))
6487               {
6488                 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
6489                 r = cp_build_qualified_type_real (r, CP_TYPE_QUALS (t),
6490                                                   complain);
6491               }
6492             else
6493               {
6494                 r = copy_node (t);
6495                 TEMPLATE_TYPE_PARM_INDEX (r)
6496                   = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
6497                                                 r, levels);
6498                 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
6499                 TYPE_MAIN_VARIANT (r) = r;
6500                 TYPE_POINTER_TO (r) = NULL_TREE;
6501                 TYPE_REFERENCE_TO (r) = NULL_TREE;
6502
6503                 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
6504                   {
6505                     tree argvec = tsubst (TYPE_TI_ARGS (t), args,
6506                                           complain, in_decl);
6507                     if (argvec == error_mark_node)
6508                       return error_mark_node;
6509
6510                     TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
6511                       = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
6512                   }
6513               }
6514             break;
6515
6516           case TEMPLATE_PARM_INDEX:
6517             r = reduce_template_parm_level (t, type, levels);
6518             break;
6519
6520           default:
6521             my_friendly_abort (0);
6522           }
6523
6524         return r;
6525       }
6526
6527     case TREE_LIST:
6528       {
6529         tree purpose, value, chain, result;
6530
6531         if (t == void_list_node)
6532           return t;
6533
6534         purpose = TREE_PURPOSE (t);
6535         if (purpose)
6536           {
6537             purpose = tsubst (purpose, args, complain, in_decl);
6538             if (purpose == error_mark_node)
6539               return error_mark_node;
6540           }
6541         value = TREE_VALUE (t);
6542         if (value)
6543           {
6544             value = tsubst (value, args, complain, in_decl);
6545             if (value == error_mark_node)
6546               return error_mark_node;
6547           }
6548         chain = TREE_CHAIN (t);
6549         if (chain && chain != void_type_node)
6550           {
6551             chain = tsubst (chain, args, complain, in_decl);
6552             if (chain == error_mark_node)
6553               return error_mark_node;
6554           }
6555         if (purpose == TREE_PURPOSE (t)
6556             && value == TREE_VALUE (t)
6557             && chain == TREE_CHAIN (t))
6558           return t;
6559         if (TREE_PARMLIST (t))
6560           {
6561             result = tree_cons (purpose, value, chain);
6562             TREE_PARMLIST (result) = 1;
6563           }
6564         else
6565           result = hash_tree_cons (purpose, value, chain);
6566         return result;
6567       }
6568     case TREE_VEC:
6569       if (type != NULL_TREE)
6570         {
6571           /* A binfo node.  We always need to make a copy, of the node
6572              itself and of its BINFO_BASETYPES.  */
6573
6574           t = copy_node (t);
6575
6576           /* Make sure type isn't a typedef copy.  */
6577           type = BINFO_TYPE (TYPE_BINFO (type));
6578
6579           TREE_TYPE (t) = complete_type (type);
6580           if (IS_AGGR_TYPE (type))
6581             {
6582               BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type);
6583               BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type);
6584               if (TYPE_BINFO_BASETYPES (type) != NULL_TREE)
6585                 BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type));
6586             }
6587           return t;
6588         }
6589
6590       /* Otherwise, a vector of template arguments.  */
6591       return tsubst_template_arg_vector (t, args, complain);
6592
6593     case POINTER_TYPE:
6594     case REFERENCE_TYPE:
6595       {
6596         enum tree_code code;
6597
6598         if (type == TREE_TYPE (t))
6599           return t;
6600
6601         code = TREE_CODE (t);
6602
6603
6604         /* [temp.deduct]
6605
6606            Type deduction may fail for any of the following
6607            reasons:
6608
6609            -- Attempting to create a pointer to reference type.
6610            -- Attempting to create a reference to a reference type or
6611               a reference to void.  */
6612         if (TREE_CODE (type) == REFERENCE_TYPE
6613             || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
6614           {
6615             static int   last_line = 0;
6616             static const char* last_file = 0;
6617
6618             /* We keep track of the last time we issued this error
6619                message to avoid spewing a ton of messages during a
6620                single bad template instantiation.  */
6621             if (complain && (last_line != lineno ||
6622                              last_file != input_filename))
6623               {
6624                 if (TREE_CODE (type) == VOID_TYPE)
6625                   cp_error ("forming reference to void");
6626                 else
6627                   cp_error ("forming %s to reference type `%T'",
6628                             (code == POINTER_TYPE) ? "pointer" : "reference",
6629                             type);
6630                 last_line = lineno;
6631                 last_file = input_filename;
6632               }
6633
6634             return error_mark_node;
6635           }
6636         else if (code == POINTER_TYPE)
6637           r = build_pointer_type (type);
6638         else
6639           r = build_reference_type (type);
6640         r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
6641
6642         if (r != error_mark_node)
6643           /* Will this ever be needed for TYPE_..._TO values?  */
6644           layout_type (r);
6645
6646         return r;
6647       }
6648     case OFFSET_TYPE:
6649       {
6650         r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
6651         if (r == error_mark_node || !IS_AGGR_TYPE (r))
6652           {
6653             /* [temp.deduct]
6654
6655                Type deduction may fail for any of the following
6656                reasons:
6657
6658                -- Attempting to create "pointer to member of T" when T
6659                   is not a class type.  */
6660             if (complain)
6661               cp_error ("creating pointer to member of non-class type `%T'",
6662                         r);
6663             return error_mark_node;
6664           }
6665         return build_offset_type (r, type);
6666       }
6667     case FUNCTION_TYPE:
6668     case METHOD_TYPE:
6669       {
6670         tree fntype;
6671         tree raises;
6672
6673         fntype = tsubst_function_type (t, args, complain, in_decl);
6674         if (fntype == error_mark_node)
6675           return error_mark_node;
6676
6677         /* Substitue the exception specification. */
6678         raises = TYPE_RAISES_EXCEPTIONS (t);
6679         if (raises)
6680           {
6681             tree   list = NULL_TREE;
6682
6683             if (! TREE_VALUE (raises))
6684               list = raises;
6685             else
6686               for (; raises != NULL_TREE; raises = TREE_CHAIN (raises))
6687                 {
6688                   tree spec = TREE_VALUE (raises);
6689
6690                   spec = tsubst (spec, args, complain, in_decl);
6691                   if (spec == error_mark_node)
6692                     return spec;
6693                   list = add_exception_specifier (list, spec, complain);
6694                 }
6695             fntype = build_exception_variant (fntype, list);
6696           }
6697         return fntype;
6698       }
6699     case ARRAY_TYPE:
6700       {
6701         tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
6702         if (domain == error_mark_node)
6703           return error_mark_node;
6704
6705         /* As an optimization, we avoid regenerating the array type if
6706            it will obviously be the same as T.  */
6707         if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
6708           return t;
6709
6710         /* These checks should match the ones in grokdeclarator.
6711
6712            [temp.deduct]
6713
6714            The deduction may fail for any of the following reasons:
6715
6716            -- Attempting to create an array with an element type that
6717               is void, a function type, or a reference type.  */
6718         if (TREE_CODE (type) == VOID_TYPE
6719             || TREE_CODE (type) == FUNCTION_TYPE
6720             || TREE_CODE (type) == REFERENCE_TYPE)
6721           {
6722             if (complain)
6723               cp_error ("creating array of `%T'", type);
6724             return error_mark_node;
6725           }
6726
6727         r = build_cplus_array_type (type, domain);
6728         return r;
6729       }
6730
6731     case PLUS_EXPR:
6732     case MINUS_EXPR:
6733       {
6734         tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
6735                           in_decl);
6736         tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain,
6737                           in_decl);
6738
6739         if (e1 == error_mark_node || e2 == error_mark_node)
6740           return error_mark_node;
6741
6742         return fold (build (TREE_CODE (t), TREE_TYPE (t), e1, e2));
6743       }
6744
6745     case NEGATE_EXPR:
6746     case NOP_EXPR:
6747       {
6748         tree e = tsubst (TREE_OPERAND (t, 0), args, complain,
6749                           in_decl);
6750         if (e == error_mark_node)
6751           return error_mark_node;
6752
6753         return fold (build (TREE_CODE (t), TREE_TYPE (t), e));
6754       }
6755
6756     case TYPENAME_TYPE:
6757       {
6758         tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
6759                                      in_decl, /*entering_scope=*/1);
6760         tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
6761                               complain, in_decl);
6762
6763         if (ctx == error_mark_node || f == error_mark_node)
6764           return error_mark_node;
6765
6766         if (!IS_AGGR_TYPE (ctx))
6767           {
6768             if (complain)
6769               cp_error ("`%T' is not a class, struct, or union type",
6770                         ctx);
6771             return error_mark_node;
6772           }
6773         else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
6774           {
6775             /* Normally, make_typename_type does not require that the CTX
6776                have complete type in order to allow things like:
6777
6778                  template <class T> struct S { typename S<T>::X Y; };
6779
6780                But, such constructs have already been resolved by this
6781                point, so here CTX really should have complete type, unless
6782                it's a partial instantiation.  */
6783             ctx = complete_type (ctx);
6784             if (!COMPLETE_TYPE_P (ctx))
6785               {
6786                 if (complain)
6787                   incomplete_type_error (NULL_TREE, ctx);
6788                 return error_mark_node;
6789               }
6790           }
6791
6792         f = make_typename_type (ctx, f, complain);
6793         if (f == error_mark_node)
6794           return f;
6795         return cp_build_qualified_type_real (f,
6796                                              CP_TYPE_QUALS (f)
6797                                              | CP_TYPE_QUALS (t),
6798                                              complain);
6799       }
6800
6801     case INDIRECT_REF:
6802       {
6803         tree e = tsubst (TREE_OPERAND (t, 0), args, complain,
6804                          in_decl);
6805         if (e == error_mark_node)
6806           return error_mark_node;
6807         return make_pointer_declarator (type, e);
6808       }
6809
6810     case ADDR_EXPR:
6811       {
6812         tree e = tsubst (TREE_OPERAND (t, 0), args, complain,
6813                          in_decl);
6814         if (e == error_mark_node)
6815           return error_mark_node;
6816         return make_reference_declarator (type, e);
6817       }
6818
6819     case ARRAY_REF:
6820       {
6821         tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
6822                           in_decl);
6823         tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain,
6824                                in_decl);
6825         if (e1 == error_mark_node || e2 == error_mark_node)
6826           return error_mark_node;
6827
6828         return build_nt (ARRAY_REF, e1, e2, tsubst_expr);
6829       }
6830
6831     case CALL_EXPR:
6832       {
6833         tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
6834                           in_decl);
6835         tree e2 = (tsubst_call_declarator_parms
6836                    (CALL_DECLARATOR_PARMS (t), args, complain, in_decl));
6837         tree e3 = tsubst (CALL_DECLARATOR_EXCEPTION_SPEC (t), args,
6838                           complain, in_decl);
6839
6840         if (e1 == error_mark_node || e2 == error_mark_node
6841             || e3 == error_mark_node)
6842           return error_mark_node;
6843
6844         return make_call_declarator (e1, e2, CALL_DECLARATOR_QUALS (t), e3);
6845       }
6846
6847     case SCOPE_REF:
6848       {
6849         tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
6850                                   in_decl);
6851         tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
6852         if (e1 == error_mark_node || e2 == error_mark_node)
6853           return error_mark_node;
6854
6855         return build_nt (TREE_CODE (t), e1, e2);
6856       }
6857
6858     case TYPEOF_TYPE:
6859       {
6860         tree e1 = tsubst_expr (TYPE_FIELDS (t), args, complain,
6861                                in_decl);
6862         if (e1 == error_mark_node)
6863           return error_mark_node;
6864
6865         return TREE_TYPE (e1);
6866       }
6867
6868     case FUNCTION_NAME:
6869       {
6870         const char *name;
6871         int len;
6872         tree type;
6873         tree str;
6874
6875         /* This code should match declare_hidden_char_array in
6876            c-common.c.  */
6877         name = (*decl_printable_name) (current_function_decl, 2);
6878         len = strlen (name) + 1;
6879         type =  build_array_type (char_type_node,
6880                                   build_index_type (size_int (len)));
6881         str = build_string (len, name);
6882         TREE_TYPE (str) = type;
6883         return str;
6884       }
6885
6886     default:
6887       sorry ("use of `%s' in template",
6888              tree_code_name [(int) TREE_CODE (t)]);
6889       return error_mark_node;
6890     }
6891 }
6892
6893 /* Like tsubst, but deals with expressions.  This function just replaces
6894    template parms; to finish processing the resultant expression, use
6895    tsubst_expr.  */
6896
6897 tree
6898 tsubst_copy (t, args, complain, in_decl)
6899      tree t, args;
6900      int complain;
6901      tree in_decl;
6902 {
6903   enum tree_code code;
6904   tree r;
6905
6906   if (t == NULL_TREE || t == error_mark_node)
6907     return t;
6908
6909   code = TREE_CODE (t);
6910
6911   switch (code)
6912     {
6913     case PARM_DECL:
6914       return do_identifier (DECL_NAME (t), 0, NULL_TREE);
6915
6916     case CONST_DECL:
6917       {
6918         tree enum_type;
6919         tree v;
6920
6921         if (!DECL_CONTEXT (t))
6922           /* This is a global enumeration constant.  */
6923           return t;
6924
6925         /* Unfortunately, we cannot just call lookup_name here.
6926            Consider:
6927
6928              template <int I> int f() {
6929              enum E { a = I };
6930              struct S { void g() { E e = a; } };
6931              };
6932
6933            When we instantiate f<7>::S::g(), say, lookup_name is not
6934            clever enough to find f<7>::a.  */
6935         enum_type
6936           = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
6937                               /*entering_scope=*/0);
6938
6939         for (v = TYPE_VALUES (enum_type);
6940              v != NULL_TREE;
6941              v = TREE_CHAIN (v))
6942           if (TREE_PURPOSE (v) == DECL_NAME (t))
6943             return TREE_VALUE (v);
6944
6945           /* We didn't find the name.  That should never happen; if
6946              name-lookup found it during preliminary parsing, we
6947              should find it again here during instantiation.  */
6948         my_friendly_abort (0);
6949       }
6950       return t;
6951
6952     case FIELD_DECL:
6953       if (DECL_CONTEXT (t))
6954         {
6955           tree ctx;
6956
6957           ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
6958                                   /*entering_scope=*/1);
6959           if (ctx != DECL_CONTEXT (t))
6960             return lookup_field (ctx, DECL_NAME (t), 0, 0);
6961         }
6962       return t;
6963
6964     case VAR_DECL:
6965     case FUNCTION_DECL:
6966       if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
6967         t = tsubst (t, args, complain, in_decl);
6968       mark_used (t);
6969       return t;
6970
6971     case TEMPLATE_DECL:
6972       if (is_member_template (t))
6973         return tsubst (t, args, complain, in_decl);
6974       else
6975         return t;
6976
6977     case LOOKUP_EXPR:
6978       {
6979         /* We must tsbust into a LOOKUP_EXPR in case the names to
6980            which it refers is a conversion operator; in that case the
6981            name will change.  We avoid making unnecessary copies,
6982            however.  */
6983
6984         tree id = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
6985
6986         if (id != TREE_OPERAND (t, 0))
6987           {
6988             r = build_nt (LOOKUP_EXPR, id);
6989             LOOKUP_EXPR_GLOBAL (r) = LOOKUP_EXPR_GLOBAL (t);
6990             t = r;
6991           }
6992
6993         return t;
6994       }
6995
6996     case CAST_EXPR:
6997     case REINTERPRET_CAST_EXPR:
6998     case CONST_CAST_EXPR:
6999     case STATIC_CAST_EXPR:
7000     case DYNAMIC_CAST_EXPR:
7001     case NOP_EXPR:
7002       return build1
7003         (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7004          tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7005
7006     case INDIRECT_REF:
7007     case NEGATE_EXPR:
7008     case TRUTH_NOT_EXPR:
7009     case BIT_NOT_EXPR:
7010     case ADDR_EXPR:
7011     case CONVERT_EXPR:      /* Unary + */
7012     case SIZEOF_EXPR:
7013     case ALIGNOF_EXPR:
7014     case ARROW_EXPR:
7015     case THROW_EXPR:
7016     case TYPEID_EXPR:
7017     case REALPART_EXPR:
7018     case IMAGPART_EXPR:
7019       return build1
7020         (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7021          tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7022
7023     case PLUS_EXPR:
7024     case MINUS_EXPR:
7025     case MULT_EXPR:
7026     case TRUNC_DIV_EXPR:
7027     case CEIL_DIV_EXPR:
7028     case FLOOR_DIV_EXPR:
7029     case ROUND_DIV_EXPR:
7030     case EXACT_DIV_EXPR:
7031     case BIT_AND_EXPR:
7032     case BIT_ANDTC_EXPR:
7033     case BIT_IOR_EXPR:
7034     case BIT_XOR_EXPR:
7035     case TRUNC_MOD_EXPR:
7036     case FLOOR_MOD_EXPR:
7037     case TRUTH_ANDIF_EXPR:
7038     case TRUTH_ORIF_EXPR:
7039     case TRUTH_AND_EXPR:
7040     case TRUTH_OR_EXPR:
7041     case RSHIFT_EXPR:
7042     case LSHIFT_EXPR:
7043     case RROTATE_EXPR:
7044     case LROTATE_EXPR:
7045     case EQ_EXPR:
7046     case NE_EXPR:
7047     case MAX_EXPR:
7048     case MIN_EXPR:
7049     case LE_EXPR:
7050     case GE_EXPR:
7051     case LT_EXPR:
7052     case GT_EXPR:
7053     case COMPONENT_REF:
7054     case ARRAY_REF:
7055     case COMPOUND_EXPR:
7056     case SCOPE_REF:
7057     case DOTSTAR_EXPR:
7058     case MEMBER_REF:
7059     case PREDECREMENT_EXPR:
7060     case PREINCREMENT_EXPR:
7061     case POSTDECREMENT_EXPR:
7062     case POSTINCREMENT_EXPR:
7063       return build_nt
7064         (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7065          tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7066
7067     case CALL_EXPR:
7068       {
7069         tree fn = TREE_OPERAND (t, 0);
7070         if (is_overloaded_fn (fn))
7071           fn = tsubst_copy (get_first_fn (fn), args, complain, in_decl);
7072         else
7073           /* Sometimes FN is a LOOKUP_EXPR.  */
7074           fn = tsubst_copy (fn, args, complain, in_decl);
7075         return build_nt
7076           (code, fn, tsubst_copy (TREE_OPERAND (t, 1), args, complain,
7077                                   in_decl),
7078            NULL_TREE);
7079       }
7080
7081     case METHOD_CALL_EXPR:
7082       {
7083         tree name = TREE_OPERAND (t, 0);
7084         if (TREE_CODE (name) == BIT_NOT_EXPR)
7085           {
7086             name = tsubst_copy (TREE_OPERAND (name, 0), args,
7087                                 complain, in_decl);
7088             name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7089           }
7090         else if (TREE_CODE (name) == SCOPE_REF
7091                  && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
7092           {
7093             tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
7094                                      complain, in_decl);
7095             name = TREE_OPERAND (name, 1);
7096             name = tsubst_copy (TREE_OPERAND (name, 0), args,
7097                                 complain, in_decl);
7098             name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7099             name = build_nt (SCOPE_REF, base, name);
7100           }
7101         else
7102           name = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
7103         return build_nt
7104           (code, name, tsubst_copy (TREE_OPERAND (t, 1), args,
7105                                     complain, in_decl),
7106            tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl),
7107            NULL_TREE);
7108       }
7109
7110     case STMT_EXPR:
7111       /* This processing should really occur in tsubst_expr, However,
7112          tsubst_expr does not recurse into expressions, since it
7113          assumes that there aren't any statements inside them.
7114          Instead, it simply calls build_expr_from_tree.  So, we need
7115          to expand the STMT_EXPR here.  */
7116       if (!processing_template_decl)
7117         {
7118           tree stmt_expr = begin_stmt_expr ();
7119           tsubst_expr (STMT_EXPR_STMT (t), args,
7120                        complain, in_decl);
7121           return finish_stmt_expr (stmt_expr);
7122         }
7123
7124       return t;
7125
7126     case COND_EXPR:
7127     case MODOP_EXPR:
7128     case PSEUDO_DTOR_EXPR:
7129       {
7130         r = build_nt
7131           (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7132            tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7133            tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7134         return r;
7135       }
7136
7137     case NEW_EXPR:
7138       {
7139         r = build_nt
7140         (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7141          tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7142          tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7143         NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
7144         return r;
7145       }
7146
7147     case DELETE_EXPR:
7148       {
7149         r = build_nt
7150         (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7151          tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7152         DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
7153         DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
7154         return r;
7155       }
7156
7157     case TEMPLATE_ID_EXPR:
7158       {
7159         /* Substituted template arguments */
7160         tree targs = tsubst_copy (TREE_OPERAND (t, 1), args, complain,
7161                                   in_decl);
7162
7163         if (targs && TREE_CODE (targs) == TREE_LIST)
7164           {
7165             tree chain;
7166             for (chain = targs; chain; chain = TREE_CHAIN (chain))
7167               TREE_VALUE (chain) = maybe_fold_nontype_arg (TREE_VALUE (chain));
7168           }
7169         else if (targs)
7170           {
7171             int i;
7172             for (i = 0; i < TREE_VEC_LENGTH (targs); ++i)
7173               TREE_VEC_ELT (targs, i)
7174                 = maybe_fold_nontype_arg (TREE_VEC_ELT (targs, i));
7175           }
7176
7177         return lookup_template_function
7178           (tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), targs);
7179       }
7180
7181     case TREE_LIST:
7182       {
7183         tree purpose, value, chain;
7184
7185         if (t == void_list_node)
7186           return t;
7187
7188         purpose = TREE_PURPOSE (t);
7189         if (purpose)
7190           purpose = tsubst_copy (purpose, args, complain, in_decl);
7191         value = TREE_VALUE (t);
7192         if (value)
7193           value = tsubst_copy (value, args, complain, in_decl);
7194         chain = TREE_CHAIN (t);
7195         if (chain && chain != void_type_node)
7196           chain = tsubst_copy (chain, args, complain, in_decl);
7197         if (purpose == TREE_PURPOSE (t)
7198             && value == TREE_VALUE (t)
7199             && chain == TREE_CHAIN (t))
7200           return t;
7201         return tree_cons (purpose, value, chain);
7202       }
7203
7204     case RECORD_TYPE:
7205     case UNION_TYPE:
7206     case ENUMERAL_TYPE:
7207     case INTEGER_TYPE:
7208     case TEMPLATE_TYPE_PARM:
7209     case TEMPLATE_TEMPLATE_PARM:
7210     case BOUND_TEMPLATE_TEMPLATE_PARM:
7211     case TEMPLATE_PARM_INDEX:
7212     case POINTER_TYPE:
7213     case REFERENCE_TYPE:
7214     case OFFSET_TYPE:
7215     case FUNCTION_TYPE:
7216     case METHOD_TYPE:
7217     case ARRAY_TYPE:
7218     case TYPENAME_TYPE:
7219     case TYPE_DECL:
7220       return tsubst (t, args, complain, in_decl);
7221
7222     case IDENTIFIER_NODE:
7223       if (IDENTIFIER_TYPENAME_P (t))
7224         {
7225           tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7226           if (flag_new_abi)
7227             return mangle_conv_op_name_for_type (new_type);
7228           else
7229             return (build_typename_overload (new_type));
7230         }
7231       else
7232         return t;
7233
7234     case CONSTRUCTOR:
7235       {
7236         r = build
7237           (CONSTRUCTOR, tsubst (TREE_TYPE (t), args, complain, in_decl),
7238            NULL_TREE, tsubst_copy (CONSTRUCTOR_ELTS (t), args,
7239                                    complain, in_decl));
7240         TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
7241         return r;
7242       }
7243
7244     case VA_ARG_EXPR:
7245       return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
7246                                         in_decl),
7247                            tsubst (TREE_TYPE (t), args, complain, in_decl));
7248
7249     case FUNCTION_NAME:
7250       return tsubst (t, args, complain, in_decl);
7251
7252     default:
7253       return t;
7254     }
7255 }
7256
7257 /* Like tsubst_copy, but also does semantic processing.  */
7258
7259 tree
7260 tsubst_expr (t, args, complain, in_decl)
7261      tree t, args;
7262      int complain;
7263      tree in_decl;
7264 {
7265   tree stmt;
7266
7267   if (t == NULL_TREE || t == error_mark_node)
7268     return t;
7269
7270   if (processing_template_decl)
7271     return tsubst_copy (t, args, complain, in_decl);
7272
7273   switch (TREE_CODE (t))
7274     {
7275     case RETURN_INIT:
7276       prep_stmt (t);
7277       finish_named_return_value
7278         (TREE_OPERAND (t, 0),
7279          tsubst_expr (TREE_OPERAND (t, 1), args, /*complain=*/1, in_decl));
7280       tsubst_expr (TREE_CHAIN (t), args, complain, in_decl);
7281       break;
7282
7283     case CTOR_INITIALIZER:
7284       {
7285         tree member_init_list;
7286         tree base_init_list;
7287
7288         prep_stmt (t);
7289         member_init_list
7290           = tsubst_initializer_list (TREE_OPERAND (t, 0), args);
7291         base_init_list
7292           = tsubst_initializer_list (TREE_OPERAND (t, 1), args);
7293         setup_vtbl_ptr (member_init_list, base_init_list);
7294         tsubst_expr (TREE_CHAIN (t), args, complain, in_decl);
7295         break;
7296       }
7297
7298     case RETURN_STMT:
7299       prep_stmt (t);
7300       finish_return_stmt (tsubst_expr (RETURN_EXPR (t),
7301                                        args, complain, in_decl));
7302       break;
7303
7304     case EXPR_STMT:
7305       prep_stmt (t);
7306       finish_expr_stmt (tsubst_expr (EXPR_STMT_EXPR (t),
7307                                      args, complain, in_decl));
7308       break;
7309
7310     case DECL_STMT:
7311       {
7312         tree decl;
7313         tree init;
7314
7315         prep_stmt (t);
7316         decl = DECL_STMT_DECL (t);
7317         if (TREE_CODE (decl) == LABEL_DECL)
7318           finish_label_decl (DECL_NAME (decl));
7319         else
7320           {
7321             init = DECL_INITIAL (decl);
7322             decl = tsubst (decl, args, complain, in_decl);
7323             init = tsubst_expr (init, args, complain, in_decl);
7324             if (decl != error_mark_node)
7325               {
7326                 if (TREE_CODE (decl) != TYPE_DECL)
7327                   /* Make sure the type is instantiated now. */
7328                   complete_type (TREE_TYPE (decl));
7329                 if (init)
7330                   DECL_INITIAL (decl) = error_mark_node;
7331                 /* By marking the declaration as instantiated, we avoid
7332                    trying to instantiate it.  Since instantiate_decl can't
7333                    handle local variables, and since we've already done
7334                    all that needs to be done, that's the right thing to
7335                    do.  */
7336                 if (TREE_CODE (decl) == VAR_DECL)
7337                   DECL_TEMPLATE_INSTANTIATED (decl) = 1;
7338                 maybe_push_decl (decl);
7339                 cp_finish_decl (decl, init, NULL_TREE, 0);
7340               }
7341           }
7342         return decl;
7343       }
7344
7345     case FOR_STMT:
7346       {
7347         tree tmp;
7348         prep_stmt (t);
7349
7350         stmt = begin_for_stmt ();
7351         for (tmp = FOR_INIT_STMT (t); tmp; tmp = TREE_CHAIN (tmp))
7352           tsubst_expr (tmp, args, complain, in_decl);
7353         finish_for_init_stmt (stmt);
7354         finish_for_cond (tsubst_expr (FOR_COND (t), args,
7355                                       complain, in_decl),
7356                          stmt);
7357         tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
7358         finish_for_expr (tmp, stmt);
7359         tsubst_expr (FOR_BODY (t), args, complain, in_decl);
7360         finish_for_stmt (stmt);
7361       }
7362       break;
7363
7364     case WHILE_STMT:
7365       {
7366         prep_stmt (t);
7367         stmt = begin_while_stmt ();
7368         finish_while_stmt_cond (tsubst_expr (WHILE_COND (t),
7369                                              args, complain, in_decl),
7370                                 stmt);
7371         tsubst_expr (WHILE_BODY (t), args, complain, in_decl);
7372         finish_while_stmt (stmt);
7373       }
7374       break;
7375
7376     case DO_STMT:
7377       {
7378         prep_stmt (t);
7379         stmt = begin_do_stmt ();
7380         tsubst_expr (DO_BODY (t), args, complain, in_decl);
7381         finish_do_body (stmt);
7382         finish_do_stmt (tsubst_expr (DO_COND (t), args,
7383                                      complain, in_decl),
7384                         stmt);
7385       }
7386       break;
7387
7388     case IF_STMT:
7389       {
7390         tree tmp;
7391
7392         prep_stmt (t);
7393         stmt = begin_if_stmt ();
7394         finish_if_stmt_cond (tsubst_expr (IF_COND (t),
7395                                           args, complain, in_decl),
7396                              stmt);
7397
7398         if (tmp = THEN_CLAUSE (t), tmp)
7399           {
7400             tsubst_expr (tmp, args, complain, in_decl);
7401             finish_then_clause (stmt);
7402           }
7403
7404         if (tmp = ELSE_CLAUSE (t), tmp)
7405           {
7406             begin_else_clause ();
7407             tsubst_expr (tmp, args, complain, in_decl);
7408             finish_else_clause (stmt);
7409           }
7410
7411         finish_if_stmt ();
7412       }
7413       break;
7414
7415     case COMPOUND_STMT:
7416       {
7417         tree substmt;
7418
7419         prep_stmt (t);
7420         stmt = begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t));
7421         for (substmt = COMPOUND_BODY (t);
7422              substmt != NULL_TREE;
7423              substmt = TREE_CHAIN (substmt))
7424           tsubst_expr (substmt, args, complain, in_decl);
7425         return finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t), stmt);
7426       }
7427       break;
7428
7429     case BREAK_STMT:
7430       prep_stmt (t);
7431       finish_break_stmt ();
7432       break;
7433
7434     case CONTINUE_STMT:
7435       prep_stmt (t);
7436       finish_continue_stmt ();
7437       break;
7438
7439     case SWITCH_STMT:
7440       {
7441         tree val;
7442
7443         prep_stmt (t);
7444         stmt = begin_switch_stmt ();
7445         val = tsubst_expr (SWITCH_COND (t), args, complain, in_decl);
7446         finish_switch_cond (val, stmt);
7447         tsubst_expr (SWITCH_BODY (t), args, complain, in_decl);
7448         finish_switch_stmt (stmt);
7449       }
7450       break;
7451
7452     case CASE_LABEL:
7453       prep_stmt (t);
7454       finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl),
7455                          tsubst_expr (CASE_HIGH (t), args, complain,
7456                                       in_decl));
7457       break;
7458
7459     case LABEL_STMT:
7460       lineno = STMT_LINENO (t);
7461       finish_label_stmt (DECL_NAME (LABEL_STMT_LABEL (t)));
7462       break;
7463
7464     case GOTO_STMT:
7465       prep_stmt (t);
7466       t = GOTO_DESTINATION (t);
7467       if (TREE_CODE (t) != LABEL_DECL)
7468         /* Computed goto's must be tsubst'd into.  On the other hand,
7469            non-computed gotos must not be; the identifier in question
7470            will have no binding.  */
7471         t = tsubst_expr (t, args, complain, in_decl);
7472       else
7473         t = DECL_NAME (t);
7474       finish_goto_stmt (t);
7475       break;
7476
7477     case ASM_STMT:
7478       prep_stmt (t);
7479       finish_asm_stmt (ASM_CV_QUAL (t),
7480                        tsubst_expr (ASM_STRING (t), args, complain, in_decl),
7481                        tsubst_expr (ASM_OUTPUTS (t), args, complain, in_decl),
7482                        tsubst_expr (ASM_INPUTS (t), args, complain, in_decl),
7483                        tsubst_expr (ASM_CLOBBERS (t), args, complain,
7484                                     in_decl));
7485       break;
7486
7487     case TRY_BLOCK:
7488       prep_stmt (t);
7489       if (CLEANUP_P (t))
7490         {
7491           stmt = begin_try_block ();
7492           tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
7493           finish_cleanup_try_block (stmt);
7494           finish_cleanup (tsubst_expr (TRY_HANDLERS (t), args,
7495                                        complain, in_decl),
7496                           stmt);
7497         }
7498       else
7499         {
7500           tree handler;
7501
7502           if (FN_TRY_BLOCK_P (t))
7503             stmt = begin_function_try_block ();
7504           else
7505             stmt = begin_try_block ();
7506
7507           tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
7508
7509           if (FN_TRY_BLOCK_P (t))
7510             finish_function_try_block (stmt);
7511           else
7512             finish_try_block (stmt);
7513
7514           handler = TRY_HANDLERS (t);
7515           for (; handler; handler = TREE_CHAIN (handler))
7516             tsubst_expr (handler, args, complain, in_decl);
7517           if (FN_TRY_BLOCK_P (t))
7518             finish_function_handler_sequence (stmt);
7519           else
7520             finish_handler_sequence (stmt);
7521         }
7522       break;
7523
7524     case HANDLER:
7525       {
7526         tree decl;
7527         tree blocks;
7528
7529         prep_stmt (t);
7530         stmt = begin_handler ();
7531         if (HANDLER_PARMS (t))
7532           {
7533             decl = DECL_STMT_DECL (HANDLER_PARMS (t));
7534             decl = tsubst (decl, args, complain, in_decl);
7535             /* Prevent instantiate_decl from trying to instantiate
7536                this variable.  We've already done all that needs to be
7537                done.  */
7538             DECL_TEMPLATE_INSTANTIATED (decl) = 1;
7539           }
7540         else
7541           decl = NULL_TREE;
7542         blocks = finish_handler_parms (decl, stmt);
7543         tsubst_expr (HANDLER_BODY (t), args, complain, in_decl);
7544         finish_handler (blocks, stmt);
7545       }
7546       break;
7547
7548     case TAG_DEFN:
7549       prep_stmt (t);
7550       t = TREE_TYPE (t);
7551       tsubst (t, args, complain, NULL_TREE);
7552       break;
7553
7554     default:
7555       return build_expr_from_tree (tsubst_copy (t, args, complain, in_decl));
7556     }
7557   return NULL_TREE;
7558 }
7559
7560 /* TMPL is a TEMPLATE_DECL for a cloned constructor or destructor.
7561    Instantiate it with the ARGS.  */
7562
7563 static tree
7564 instantiate_clone (tmpl, args)
7565      tree tmpl;
7566      tree args;
7567 {
7568   tree spec;
7569   tree clone;
7570
7571   /* Instantiated the cloned function, rather than the clone.  */
7572   spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), args);
7573
7574   /* Then, see if we've already cloned the instantiation.  */
7575   for (clone = TREE_CHAIN (spec);
7576        clone && DECL_CLONED_FUNCTION_P (clone);
7577        clone = TREE_CHAIN (clone))
7578     if (DECL_NAME (clone) == DECL_NAME (tmpl))
7579       return clone;
7580
7581   /* If we haven't, do so know.  */
7582   if (!clone)
7583     clone_function_decl (spec, /*update_method_vec_p=*/0);
7584
7585   /* Look again.  */
7586   for (clone = TREE_CHAIN (spec);
7587        clone && DECL_CLONED_FUNCTION_P (clone);
7588        clone = TREE_CHAIN (clone))
7589     if (DECL_NAME (clone) == DECL_NAME (tmpl))
7590       return clone;
7591
7592   /* We should always have found the clone by now.  */
7593   my_friendly_abort (20000411);
7594   return NULL_TREE;
7595 }
7596
7597 /* Instantiate the indicated variable or function template TMPL with
7598    the template arguments in TARG_PTR.  */
7599
7600 tree
7601 instantiate_template (tmpl, targ_ptr)
7602      tree tmpl, targ_ptr;
7603 {
7604   tree clone;
7605   tree fndecl;
7606   tree gen_tmpl;
7607   tree spec;
7608   int i, len;
7609   tree inner_args;
7610
7611   if (tmpl == error_mark_node)
7612     return error_mark_node;
7613
7614   my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283);
7615
7616   /* If this function is a clone, handle it specially.  */
7617   if (DECL_CLONED_FUNCTION_P (tmpl))
7618     return instantiate_clone (tmpl, targ_ptr);
7619
7620   /* Check to see if we already have this specialization.  */
7621   spec = retrieve_specialization (tmpl, targ_ptr);
7622   if (spec != NULL_TREE)
7623     return spec;
7624
7625   gen_tmpl = most_general_template (tmpl);
7626   if (tmpl != gen_tmpl)
7627     {
7628       /* The TMPL is a partial instantiation.  To get a full set of
7629          arguments we must add the arguments used to perform the
7630          partial instantiation.  */
7631       targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
7632                                               targ_ptr);
7633
7634       /* Check to see if we already have this specialization.  */
7635       spec = retrieve_specialization (gen_tmpl, targ_ptr);
7636       if (spec != NULL_TREE)
7637         return spec;
7638     }
7639
7640   len = DECL_NTPARMS (gen_tmpl);
7641   inner_args = INNERMOST_TEMPLATE_ARGS (targ_ptr);
7642   i = len;
7643   while (i--)
7644     {
7645       tree t = TREE_VEC_ELT (inner_args, i);
7646       if (TYPE_P (t))
7647         {
7648           tree nt = target_type (t);
7649           if (IS_AGGR_TYPE (nt) && decl_function_context (TYPE_MAIN_DECL (nt)))
7650             {
7651               cp_error ("type `%T' composed from a local class is not a valid template-argument", t);
7652               cp_error ("  trying to instantiate `%D'", gen_tmpl);
7653               return error_mark_node;
7654             }
7655         }
7656     }
7657
7658   /* substitute template parameters */
7659   fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
7660                    targ_ptr, /*complain=*/1, gen_tmpl);
7661   /* The DECL_TI_TEMPLATE should always be the immediate parent
7662      template, not the most general template.  */
7663   DECL_TI_TEMPLATE (fndecl) = tmpl;
7664
7665   if (flag_external_templates)
7666     add_pending_template (fndecl);
7667
7668   /* If we've just instantiated the main entry point for a function,
7669      instantiate all the alternate entry points as well.  */
7670   for (clone = TREE_CHAIN (gen_tmpl);
7671        clone && DECL_CLONED_FUNCTION_P (clone);
7672        clone = TREE_CHAIN (clone))
7673     instantiate_template (clone, targ_ptr);
7674
7675   return fndecl;
7676 }
7677
7678 /* The FN is a TEMPLATE_DECL for a function.  The ARGS are the
7679    arguments that are being used when calling it.  TARGS is a vector
7680    into which the deduced template arguments are placed.
7681
7682    Return zero for success, 2 for an incomplete match that doesn't resolve
7683    all the types, and 1 for complete failure.  An error message will be
7684    printed only for an incomplete match.
7685
7686    If FN is a conversion operator, or we are trying to produce a specific
7687    specialization, RETURN_TYPE is the return type desired.
7688
7689    The EXPLICIT_TARGS are explicit template arguments provided via a
7690    template-id.
7691
7692    The parameter STRICT is one of:
7693
7694    DEDUCE_CALL:
7695      We are deducing arguments for a function call, as in
7696      [temp.deduct.call].
7697
7698    DEDUCE_CONV:
7699      We are deducing arguments for a conversion function, as in
7700      [temp.deduct.conv].
7701
7702    DEDUCE_EXACT:
7703      We are deducing arguments when doing an explicit instantiation
7704      as in [temp.explicit], when determining an explicit specialization
7705      as in [temp.expl.spec], or when taking the address of a function
7706      template, as in [temp.deduct.funcaddr].
7707
7708    DEDUCE_ORDER:
7709      We are deducing arguments when calculating the partial
7710      ordering between specializations of function or class
7711      templates, as in [temp.func.order] and [temp.class.order].
7712
7713    LEN is the number of parms to consider before returning success, or -1
7714    for all.  This is used in partial ordering to avoid comparing parms for
7715    which no actual argument was passed, since they are not considered in
7716    overload resolution (and are explicitly excluded from consideration in
7717    partial ordering in [temp.func.order]/6).  */
7718
7719 int
7720 fn_type_unification (fn, explicit_targs, targs, args, return_type,
7721                      strict, len)
7722      tree fn, explicit_targs, targs, args, return_type;
7723      unification_kind_t strict;
7724      int len;
7725 {
7726   tree parms;
7727   tree fntype;
7728   int result;
7729
7730   my_friendly_assert (TREE_CODE (fn) == TEMPLATE_DECL, 0);
7731
7732   fntype = TREE_TYPE (fn);
7733   if (explicit_targs)
7734     {
7735       /* [temp.deduct]
7736
7737          The specified template arguments must match the template
7738          parameters in kind (i.e., type, nontype, template), and there
7739          must not be more arguments than there are parameters;
7740          otherwise type deduction fails.
7741
7742          Nontype arguments must match the types of the corresponding
7743          nontype template parameters, or must be convertible to the
7744          types of the corresponding nontype parameters as specified in
7745          _temp.arg.nontype_, otherwise type deduction fails.
7746
7747          All references in the function type of the function template
7748          to the corresponding template parameters are replaced by the
7749          specified template argument values.  If a substitution in a
7750          template parameter or in the function type of the function
7751          template results in an invalid type, type deduction fails.  */
7752       int i;
7753       tree converted_args;
7754
7755       converted_args
7756         = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
7757                                   explicit_targs, NULL_TREE, /*complain=*/0,
7758                                   /*require_all_arguments=*/0));
7759       if (converted_args == error_mark_node)
7760         return 1;
7761
7762       fntype = tsubst (fntype, converted_args, /*complain=*/0, NULL_TREE);
7763       if (fntype == error_mark_node)
7764         return 1;
7765
7766       /* Place the explicitly specified arguments in TARGS.  */
7767       for (i = 0; i < TREE_VEC_LENGTH (targs); i++)
7768         TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
7769     }
7770
7771   parms = TYPE_ARG_TYPES (fntype);
7772   /* Never do unification on the 'this' parameter.  */
7773   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
7774     parms = TREE_CHAIN (parms);
7775
7776   if (return_type)
7777     {
7778       /* We've been given a return type to match, prepend it.  */
7779       parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
7780       args = tree_cons (NULL_TREE, return_type, args);
7781       if (len >= 0)
7782         ++len;
7783     }
7784
7785   /* We allow incomplete unification without an error message here
7786      because the standard doesn't seem to explicitly prohibit it.  Our
7787      callers must be ready to deal with unification failures in any
7788      event.  */
7789   result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
7790                                   targs, parms, args, /*subr=*/0,
7791                                   strict, /*allow_incomplete*/1, len);
7792
7793   if (result == 0)
7794     /* All is well so far.  Now, check:
7795
7796        [temp.deduct]
7797
7798        When all template arguments have been deduced, all uses of
7799        template parameters in nondeduced contexts are replaced with
7800        the corresponding deduced argument values.  If the
7801        substitution results in an invalid type, as described above,
7802        type deduction fails.  */
7803     if (tsubst (TREE_TYPE (fn), targs, /*complain=*/0, NULL_TREE)
7804         == error_mark_node)
7805       return 1;
7806
7807   return result;
7808 }
7809
7810 /* Adjust types before performing type deduction, as described in
7811    [temp.deduct.call] and [temp.deduct.conv].  The rules in these two
7812    sections are symmetric.  PARM is the type of a function parameter
7813    or the return type of the conversion function.  ARG is the type of
7814    the argument passed to the call, or the type of the value
7815    initialized with the result of the conversion function.  */
7816
7817 static int
7818 maybe_adjust_types_for_deduction (strict, parm, arg)
7819      unification_kind_t strict;
7820      tree* parm;
7821      tree* arg;
7822 {
7823   int result = 0;
7824
7825   switch (strict)
7826     {
7827     case DEDUCE_CALL:
7828       break;
7829
7830     case DEDUCE_CONV:
7831       {
7832         /* Swap PARM and ARG throughout the remainder of this
7833            function; the handling is precisely symmetric since PARM
7834            will initialize ARG rather than vice versa.  */
7835         tree* temp = parm;
7836         parm = arg;
7837         arg = temp;
7838         break;
7839       }
7840
7841     case DEDUCE_EXACT:
7842       /* There is nothing to do in this case.  */
7843       return 0;
7844
7845     case DEDUCE_ORDER:
7846       /* DR 214. [temp.func.order] is underspecified, and leads to no
7847          ordering between things like `T *' and `T const &' for `U *'.
7848          The former has T=U and the latter T=U*. The former looks more
7849          specialized and John Spicer considers it well-formed (the EDG
7850          compiler accepts it).
7851
7852          John also confirms that deduction should proceed as in a function
7853          call. Which implies the usual ARG and PARM bashing as DEDUCE_CALL.
7854          However, in ordering, ARG can have REFERENCE_TYPE, but no argument
7855          to an actual call can have such a type.
7856
7857          When deducing against a REFERENCE_TYPE, we can either not change
7858          PARM's type, or we can change ARG's type too. The latter, though
7859          seemingly more safe, turns out to give the following quirk. Consider
7860          deducing a call to a `const int *' with the following template
7861          function parameters
7862            #1; T const *const &   ; T = int
7863            #2; T *const &         ; T = const int
7864            #3; T *                ; T = const int
7865          It looks like #1 is the more specialized.  Taken pairwise, #1 is
7866          more specialized than #2 and #2 is more specialized than #3, yet
7867          there is no ordering between #1 and #3.
7868
7869          So, if ARG is a reference, we look though it when PARM is
7870          not a refence. When both are references we don't change either.  */
7871       if (TREE_CODE (*arg) == REFERENCE_TYPE)
7872         {
7873           if (TREE_CODE (*parm) == REFERENCE_TYPE)
7874             return 0;
7875           *arg = TREE_TYPE (*arg);
7876           result |= UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
7877           goto skip_arg;
7878         }
7879       break;
7880     default:
7881       my_friendly_abort (0);
7882     }
7883
7884   if (TREE_CODE (*parm) != REFERENCE_TYPE)
7885     {
7886       /* [temp.deduct.call]
7887
7888          If P is not a reference type:
7889
7890          --If A is an array type, the pointer type produced by the
7891          array-to-pointer standard conversion (_conv.array_) is
7892          used in place of A for type deduction; otherwise,
7893
7894          --If A is a function type, the pointer type produced by
7895          the function-to-pointer standard conversion
7896          (_conv.func_) is used in place of A for type deduction;
7897          otherwise,
7898
7899          --If A is a cv-qualified type, the top level
7900          cv-qualifiers of A's type are ignored for type
7901          deduction.  */
7902       if (TREE_CODE (*arg) == ARRAY_TYPE)
7903         *arg = build_pointer_type (TREE_TYPE (*arg));
7904       else if (TREE_CODE (*arg) == FUNCTION_TYPE)
7905         *arg = build_pointer_type (*arg);
7906       else
7907         *arg = TYPE_MAIN_VARIANT (*arg);
7908     }
7909
7910   skip_arg:;
7911   /* [temp.deduct.call]
7912
7913      If P is a cv-qualified type, the top level cv-qualifiers
7914      of P's type are ignored for type deduction.  If P is a
7915      reference type, the type referred to by P is used for
7916      type deduction.  */
7917   *parm = TYPE_MAIN_VARIANT (*parm);
7918   if (TREE_CODE (*parm) == REFERENCE_TYPE)
7919     {
7920       *parm = TREE_TYPE (*parm);
7921       result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
7922     }
7923   return result;
7924 }
7925
7926 /* Most parms like fn_type_unification.
7927
7928    If SUBR is 1, we're being called recursively (to unify the
7929    arguments of a function or method parameter of a function
7930    template).  */
7931
7932 static int
7933 type_unification_real (tparms, targs, xparms, xargs, subr,
7934                        strict, allow_incomplete, xlen)
7935      tree tparms, targs, xparms, xargs;
7936      int subr;
7937      unification_kind_t strict;
7938      int allow_incomplete, xlen;
7939 {
7940   tree parm, arg;
7941   int i;
7942   int ntparms = TREE_VEC_LENGTH (tparms);
7943   int sub_strict;
7944   int saw_undeduced = 0;
7945   tree parms, args;
7946   int len;
7947
7948   my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289);
7949   my_friendly_assert (xparms == NULL_TREE
7950                       || TREE_CODE (xparms) == TREE_LIST, 290);
7951   /* ARGS could be NULL (via a call from parse.y to
7952      build_x_function_call).  */
7953   if (xargs)
7954     my_friendly_assert (TREE_CODE (xargs) == TREE_LIST, 291);
7955   my_friendly_assert (ntparms > 0, 292);
7956
7957   switch (strict)
7958     {
7959     case DEDUCE_CALL:
7960       sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
7961                     | UNIFY_ALLOW_DERIVED);
7962       break;
7963
7964     case DEDUCE_CONV:
7965       sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
7966       break;
7967
7968     case DEDUCE_EXACT:
7969       sub_strict = UNIFY_ALLOW_NONE;
7970       break;
7971
7972     case DEDUCE_ORDER:
7973       sub_strict = UNIFY_ALLOW_NONE;
7974       break;
7975
7976     default:
7977       my_friendly_abort (0);
7978     }
7979
7980   if (xlen == 0)
7981     return 0;
7982
7983  again:
7984   parms = xparms;
7985   args = xargs;
7986   len = xlen;
7987
7988   while (parms
7989          && parms != void_list_node
7990          && args
7991          && args != void_list_node)
7992     {
7993       parm = TREE_VALUE (parms);
7994       parms = TREE_CHAIN (parms);
7995       arg = TREE_VALUE (args);
7996       args = TREE_CHAIN (args);
7997
7998       if (arg == error_mark_node)
7999         return 1;
8000       if (arg == unknown_type_node)
8001         /* We can't deduce anything from this, but we might get all the
8002            template args from other function args.  */
8003         continue;
8004
8005       /* Conversions will be performed on a function argument that
8006          corresponds with a function parameter that contains only
8007          non-deducible template parameters and explicitly specified
8008          template parameters.  */
8009       if (! uses_template_parms (parm))
8010         {
8011           tree type;
8012
8013           if (!TYPE_P (arg))
8014             type = TREE_TYPE (arg);
8015           else
8016             {
8017               type = arg;
8018               arg = NULL_TREE;
8019             }
8020
8021           if (strict == DEDUCE_EXACT || strict == DEDUCE_ORDER)
8022             {
8023               if (same_type_p (parm, type))
8024                 continue;
8025             }
8026           else
8027             /* It might work; we shouldn't check now, because we might
8028                get into infinite recursion.  Overload resolution will
8029                handle it.  */
8030             continue;
8031
8032           return 1;
8033         }
8034
8035       if (!TYPE_P (arg))
8036         {
8037           my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293);
8038           if (type_unknown_p (arg))
8039             {
8040               /* [temp.deduct.type] A template-argument can be deduced from
8041                  a pointer to function or pointer to member function
8042                  argument if the set of overloaded functions does not
8043                  contain function templates and at most one of a set of
8044                  overloaded functions provides a unique match.  */
8045
8046               if (resolve_overloaded_unification
8047                   (tparms, targs, parm, arg, strict, sub_strict)
8048                   != 0)
8049                 return 1;
8050               continue;
8051             }
8052           arg = TREE_TYPE (arg);
8053         }
8054
8055       {
8056         int arg_strict = sub_strict;
8057
8058         if (!subr)
8059           arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
8060
8061         if (unify (tparms, targs, parm, arg, arg_strict))
8062           return 1;
8063       }
8064
8065       /* Are we done with the interesting parms?  */
8066       if (--len == 0)
8067         goto done;
8068     }
8069   /* Fail if we've reached the end of the parm list, and more args
8070      are present, and the parm list isn't variadic.  */
8071   if (args && args != void_list_node && parms == void_list_node)
8072     return 1;
8073   /* Fail if parms are left and they don't have default values.  */
8074   if (parms
8075       && parms != void_list_node
8076       && TREE_PURPOSE (parms) == NULL_TREE)
8077     return 1;
8078
8079  done:
8080   if (!subr)
8081     for (i = 0; i < ntparms; i++)
8082       if (TREE_VEC_ELT (targs, i) == NULL_TREE)
8083         {
8084           tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
8085
8086           /* If this is an undeduced nontype parameter that depends on
8087              a type parameter, try another pass; its type may have been
8088              deduced from a later argument than the one from which
8089              this parameter can be deduced.  */
8090           if (TREE_CODE (tparm) == PARM_DECL
8091               && uses_template_parms (TREE_TYPE (tparm))
8092               && !saw_undeduced++)
8093             goto again;
8094
8095           if (!allow_incomplete)
8096             error ("incomplete type unification");
8097           return 2;
8098         }
8099   return 0;
8100 }
8101
8102 /* Subroutine of type_unification_real.  Args are like the variables at the
8103    call site.  ARG is an overloaded function (or template-id); we try
8104    deducing template args from each of the overloads, and if only one
8105    succeeds, we go with that.  Modifies TARGS and returns 0 on success.  */
8106
8107 static int
8108 resolve_overloaded_unification (tparms, targs, parm, arg, strict,
8109                                 sub_strict)
8110      tree tparms, targs, parm, arg;
8111      unification_kind_t strict;
8112      int sub_strict;
8113 {
8114   tree tempargs = copy_node (targs);
8115   int good = 0;
8116
8117   if (TREE_CODE (arg) == ADDR_EXPR)
8118     arg = TREE_OPERAND (arg, 0);
8119
8120   if (TREE_CODE (arg) == COMPONENT_REF)
8121     /* Handle `&x' where `x' is some static or non-static member
8122        function name.  */
8123     arg = TREE_OPERAND (arg, 1);
8124
8125   if (TREE_CODE (arg) == OFFSET_REF)
8126     arg = TREE_OPERAND (arg, 1);
8127
8128   /* Strip baselink information.  */
8129   while (TREE_CODE (arg) == TREE_LIST)
8130     arg = TREE_VALUE (arg);
8131
8132   if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
8133     {
8134       /* If we got some explicit template args, we need to plug them into
8135          the affected templates before we try to unify, in case the
8136          explicit args will completely resolve the templates in question.  */
8137
8138       tree expl_subargs = TREE_OPERAND (arg, 1);
8139       arg = TREE_OPERAND (arg, 0);
8140
8141       for (; arg; arg = OVL_NEXT (arg))
8142         {
8143           tree fn = OVL_CURRENT (arg);
8144           tree subargs, elem;
8145
8146           if (TREE_CODE (fn) != TEMPLATE_DECL)
8147             continue;
8148
8149           subargs = get_bindings_overload (fn, DECL_TEMPLATE_RESULT (fn),
8150                                            expl_subargs);
8151           if (subargs)
8152             {
8153               elem = tsubst (TREE_TYPE (fn), subargs, /*complain=*/0,
8154                              NULL_TREE);
8155               if (TREE_CODE (elem) == METHOD_TYPE)
8156                 elem = build_ptrmemfunc_type (build_pointer_type (elem));
8157               good += try_one_overload (tparms, targs, tempargs, parm, elem,
8158                                         strict, sub_strict);
8159             }
8160         }
8161     }
8162   else if (TREE_CODE (arg) == OVERLOAD)
8163     {
8164       for (; arg; arg = OVL_NEXT (arg))
8165         {
8166           tree type = TREE_TYPE (OVL_CURRENT (arg));
8167           if (TREE_CODE (type) == METHOD_TYPE)
8168             type = build_ptrmemfunc_type (build_pointer_type (type));
8169           good += try_one_overload (tparms, targs, tempargs, parm,
8170                                     type,
8171                                     strict, sub_strict);
8172         }
8173     }
8174   else
8175     my_friendly_abort (981006);
8176
8177   /* [temp.deduct.type] A template-argument can be deduced from a pointer
8178      to function or pointer to member function argument if the set of
8179      overloaded functions does not contain function templates and at most
8180      one of a set of overloaded functions provides a unique match.
8181
8182      So if we found multiple possibilities, we return success but don't
8183      deduce anything.  */
8184
8185   if (good == 1)
8186     {
8187       int i = TREE_VEC_LENGTH (targs);
8188       for (; i--; )
8189         if (TREE_VEC_ELT (tempargs, i))
8190           TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
8191     }
8192   if (good)
8193     return 0;
8194
8195   return 1;
8196 }
8197
8198 /* Subroutine of resolve_overloaded_unification; does deduction for a single
8199    overload.  Fills TARGS with any deduced arguments, or error_mark_node if
8200    different overloads deduce different arguments for a given parm.
8201    Returns 1 on success.  */
8202
8203 static int
8204 try_one_overload (tparms, orig_targs, targs, parm, arg, strict,
8205                   sub_strict)
8206      tree tparms, orig_targs, targs, parm, arg;
8207      unification_kind_t strict;
8208      int sub_strict;
8209 {
8210   int nargs;
8211   tree tempargs;
8212   int i;
8213
8214   /* [temp.deduct.type] A template-argument can be deduced from a pointer
8215      to function or pointer to member function argument if the set of
8216      overloaded functions does not contain function templates and at most
8217      one of a set of overloaded functions provides a unique match.
8218
8219      So if this is a template, just return success.  */
8220
8221   if (uses_template_parms (arg))
8222     return 1;
8223
8224   sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
8225
8226   /* We don't copy orig_targs for this because if we have already deduced
8227      some template args from previous args, unify would complain when we
8228      try to deduce a template parameter for the same argument, even though
8229      there isn't really a conflict.  */
8230   nargs = TREE_VEC_LENGTH (targs);
8231   tempargs = make_tree_vec (nargs);
8232
8233   if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
8234     return 0;
8235
8236   /* First make sure we didn't deduce anything that conflicts with
8237      explicitly specified args.  */
8238   for (i = nargs; i--; )
8239     {
8240       tree elt = TREE_VEC_ELT (tempargs, i);
8241       tree oldelt = TREE_VEC_ELT (orig_targs, i);
8242
8243       if (elt == NULL_TREE)
8244         continue;
8245       else if (uses_template_parms (elt))
8246         {
8247           /* Since we're unifying against ourselves, we will fill in template
8248              args used in the function parm list with our own template parms.
8249              Discard them.  */
8250           TREE_VEC_ELT (tempargs, i) = NULL_TREE;
8251           continue;
8252         }
8253       else if (oldelt && ! template_args_equal (oldelt, elt))
8254         return 0;
8255     }
8256
8257   for (i = nargs; i--; )
8258     {
8259       tree elt = TREE_VEC_ELT (tempargs, i);
8260
8261       if (elt)
8262         TREE_VEC_ELT (targs, i) = elt;
8263     }
8264
8265   return 1;
8266 }
8267
8268 /* Verify that nondeduce template argument agrees with the type
8269    obtained from argument deduction.  Return nonzero if the
8270    verification fails.
8271
8272    For example:
8273
8274      struct A { typedef int X; };
8275      template <class T, class U> struct C {};
8276      template <class T> struct C<T, typename T::X> {};
8277
8278    Then with the instantiation `C<A, int>', we can deduce that
8279    `T' is `A' but unify () does not check whether `typename T::X'
8280    is `int'.  This function ensure that they agree.
8281
8282    TARGS, PARMS are the same as the arguments of unify.
8283    ARGS contains template arguments from all levels.  */
8284
8285 static int
8286 verify_class_unification (targs, parms, args)
8287      tree targs, parms, args;
8288 {
8289   int i;
8290   int nparms = TREE_VEC_LENGTH (parms);
8291   tree new_parms = tsubst (parms, add_outermost_template_args (args, targs),
8292                            /*complain=*/0, NULL_TREE);
8293   if (new_parms == error_mark_node)
8294     return 1;
8295
8296   args = INNERMOST_TEMPLATE_ARGS (args);
8297
8298   for (i = 0; i < nparms; i++)
8299     {
8300       tree parm = TREE_VEC_ELT (new_parms, i);
8301       tree arg = TREE_VEC_ELT (args, i);
8302
8303       /* In case we are deducing from a function argument of a function
8304          templates, some parameters may not be deduced yet.  So we
8305          make sure that only fully substituted elements of PARM are
8306          compared below.  */
8307
8308       if (!uses_template_parms (parm) && !template_args_equal (parm, arg))
8309         return 1;
8310     }
8311   return 0;
8312 }
8313
8314 /* PARM is a template class (perhaps with unbound template
8315    parameters).  ARG is a fully instantiated type.  If ARG can be
8316    bound to PARM, return ARG, otherwise return NULL_TREE.  TPARMS and
8317    TARGS are as for unify.  */
8318
8319 static tree
8320 try_class_unification (tparms, targs, parm, arg)
8321      tree tparms;
8322      tree targs;
8323      tree parm;
8324      tree arg;
8325 {
8326   tree copy_of_targs;
8327
8328   if (!CLASSTYPE_TEMPLATE_INFO (arg)
8329       || CLASSTYPE_TI_TEMPLATE (arg) != CLASSTYPE_TI_TEMPLATE (parm))
8330     return NULL_TREE;
8331
8332   /* We need to make a new template argument vector for the call to
8333      unify.  If we used TARGS, we'd clutter it up with the result of
8334      the attempted unification, even if this class didn't work out.
8335      We also don't want to commit ourselves to all the unifications
8336      we've already done, since unification is supposed to be done on
8337      an argument-by-argument basis.  In other words, consider the
8338      following pathological case:
8339
8340        template <int I, int J, int K>
8341        struct S {};
8342
8343        template <int I, int J>
8344        struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
8345
8346        template <int I, int J, int K>
8347        void f(S<I, J, K>, S<I, I, I>);
8348
8349        void g() {
8350          S<0, 0, 0> s0;
8351          S<0, 1, 2> s2;
8352
8353          f(s0, s2);
8354        }
8355
8356      Now, by the time we consider the unification involving `s2', we
8357      already know that we must have `f<0, 0, 0>'.  But, even though
8358      `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is not legal
8359      because there are two ways to unify base classes of S<0, 1, 2>
8360      with S<I, I, I>.  If we kept the already deduced knowledge, we
8361      would reject the possibility I=1.  */
8362   copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
8363
8364   /* If unification failed, we're done.  */
8365   if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
8366              CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
8367     return NULL_TREE;
8368
8369   return arg;
8370 }
8371
8372 /* Subroutine of get_template_base.  RVAL, if non-NULL, is a base we
8373    have already discovered to be satisfactory.  ARG_BINFO is the binfo
8374    for the base class of ARG that we are currently examining.  */
8375
8376 static tree
8377 get_template_base_recursive (tparms, targs, parm,
8378                              arg_binfo, rval, flags)
8379      tree tparms;
8380      tree targs;
8381      tree arg_binfo;
8382      tree rval;
8383      tree parm;
8384      int flags;
8385 {
8386   tree binfos;
8387   int i, n_baselinks;
8388   tree arg = BINFO_TYPE (arg_binfo);
8389
8390   if (!(flags & GTB_IGNORE_TYPE))
8391     {
8392       tree r = try_class_unification (tparms, targs,
8393                                       parm, arg);
8394
8395       /* If there is more than one satisfactory baseclass, then:
8396
8397            [temp.deduct.call]
8398
8399            If they yield more than one possible deduced A, the type
8400            deduction fails.
8401
8402            applies.  */
8403       if (r && rval && !same_type_p (r, rval))
8404         return error_mark_node;
8405       else if (r)
8406         rval = r;
8407     }
8408
8409   binfos = BINFO_BASETYPES (arg_binfo);
8410   n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
8411
8412   /* Process base types.  */
8413   for (i = 0; i < n_baselinks; i++)
8414     {
8415       tree base_binfo = TREE_VEC_ELT (binfos, i);
8416       int this_virtual;
8417
8418       /* Skip this base, if we've already seen it.  */
8419       if (BINFO_MARKED (base_binfo))
8420         continue;
8421
8422       this_virtual =
8423         (flags & GTB_VIA_VIRTUAL) || TREE_VIA_VIRTUAL (base_binfo);
8424
8425       /* When searching for a non-virtual, we cannot mark virtually
8426          found binfos.  */
8427       if (! this_virtual)
8428         SET_BINFO_MARKED (base_binfo);
8429
8430       rval = get_template_base_recursive (tparms, targs,
8431                                           parm,
8432                                           base_binfo,
8433                                           rval,
8434                                           GTB_VIA_VIRTUAL * this_virtual);
8435
8436       /* If we discovered more than one matching base class, we can
8437          stop now.  */
8438       if (rval == error_mark_node)
8439         return error_mark_node;
8440     }
8441
8442   return rval;
8443 }
8444
8445 /* Given a template type PARM and a class type ARG, find the unique
8446    base type in ARG that is an instance of PARM.  We do not examine
8447    ARG itself; only its base-classes.  If there is no appropriate base
8448    class, return NULL_TREE.  If there is more than one, return
8449    error_mark_node.  PARM may be the type of a partial specialization,
8450    as well as a plain template type.  Used by unify.  */
8451
8452 static tree
8453 get_template_base (tparms, targs, parm, arg)
8454      tree tparms;
8455      tree targs;
8456      tree parm;
8457      tree arg;
8458 {
8459   tree rval;
8460   tree arg_binfo;
8461
8462   my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)), 92);
8463
8464   arg_binfo = TYPE_BINFO (complete_type (arg));
8465   rval = get_template_base_recursive (tparms, targs,
8466                                       parm, arg_binfo,
8467                                       NULL_TREE,
8468                                       GTB_IGNORE_TYPE);
8469
8470   /* Since get_template_base_recursive marks the bases classes, we
8471      must unmark them here.  */
8472   dfs_walk (arg_binfo, dfs_unmark, markedp, 0);
8473
8474   return rval;
8475 }
8476
8477 /* Returns the level of DECL, which declares a template parameter.  */
8478
8479 static int
8480 template_decl_level (decl)
8481      tree decl;
8482 {
8483   switch (TREE_CODE (decl))
8484     {
8485     case TYPE_DECL:
8486     case TEMPLATE_DECL:
8487       return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
8488
8489     case PARM_DECL:
8490       return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
8491
8492     default:
8493       my_friendly_abort (0);
8494       return 0;
8495     }
8496 }
8497
8498 /* Decide whether ARG can be unified with PARM, considering only the
8499    cv-qualifiers of each type, given STRICT as documented for unify.
8500    Returns non-zero iff the unification is OK on that basis.*/
8501
8502 static int
8503 check_cv_quals_for_unify (strict, arg, parm)
8504      int strict;
8505      tree arg;
8506      tree parm;
8507 {
8508   if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
8509       && !at_least_as_qualified_p (arg, parm))
8510     return 0;
8511
8512   if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
8513       && !at_least_as_qualified_p (parm, arg))
8514     return 0;
8515
8516   return 1;
8517 }
8518
8519 /* Takes parameters as for type_unification.  Returns 0 if the
8520    type deduction succeeds, 1 otherwise.  The parameter STRICT is a
8521    bitwise or of the following flags:
8522
8523      UNIFY_ALLOW_NONE:
8524        Require an exact match between PARM and ARG.
8525      UNIFY_ALLOW_MORE_CV_QUAL:
8526        Allow the deduced ARG to be more cv-qualified (by qualification
8527        conversion) than ARG.
8528      UNIFY_ALLOW_LESS_CV_QUAL:
8529        Allow the deduced ARG to be less cv-qualified than ARG.
8530      UNIFY_ALLOW_DERIVED:
8531        Allow the deduced ARG to be a template base class of ARG,
8532        or a pointer to a template base class of the type pointed to by
8533        ARG.
8534      UNIFY_ALLOW_INTEGER:
8535        Allow any integral type to be deduced.  See the TEMPLATE_PARM_INDEX
8536        case for more information.
8537      UNIFY_ALLOW_OUTER_LEVEL:
8538        This is the outermost level of a deduction. Used to determine validity
8539        of qualification conversions. A valid qualification conversion must
8540        have const qualified pointers leading up to the inner type which
8541        requires additional CV quals, except at the outer level, where const
8542        is not required [conv.qual]. It would be normal to set this flag in
8543        addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
8544      UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
8545        This is the outermost level of a deduction, and PARM can be more CV
8546        qualified at this point.
8547      UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
8548        This is the outermost level of a deduction, and PARM can be less CV
8549        qualified at this point.  */
8550
8551 static int
8552 unify (tparms, targs, parm, arg, strict)
8553      tree tparms, targs, parm, arg;
8554      int strict;
8555 {
8556   int idx;
8557   tree targ;
8558   tree tparm;
8559   int strict_in = strict;
8560
8561   /* I don't think this will do the right thing with respect to types.
8562      But the only case I've seen it in so far has been array bounds, where
8563      signedness is the only information lost, and I think that will be
8564      okay.  */
8565   while (TREE_CODE (parm) == NOP_EXPR)
8566     parm = TREE_OPERAND (parm, 0);
8567
8568   if (arg == error_mark_node)
8569     return 1;
8570   if (arg == unknown_type_node)
8571     /* We can't deduce anything from this, but we might get all the
8572        template args from other function args.  */
8573     return 0;
8574
8575   /* If PARM uses template parameters, then we can't bail out here,
8576      even if ARG == PARM, since we won't record unifications for the
8577      template parameters.  We might need them if we're trying to
8578      figure out which of two things is more specialized.  */
8579   if (arg == parm && !uses_template_parms (parm))
8580     return 0;
8581
8582   /* Immediately reject some pairs that won't unify because of
8583      cv-qualification mismatches.  */
8584   if (TREE_CODE (arg) == TREE_CODE (parm)
8585       && TYPE_P (arg)
8586       /* We check the cv-qualifiers when unifying with template type
8587          parameters below.  We want to allow ARG `const T' to unify with
8588          PARM `T' for example, when computing which of two templates
8589          is more specialized, for example.  */
8590       && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
8591       && !check_cv_quals_for_unify (strict_in, arg, parm))
8592     return 1;
8593
8594   if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
8595       && TYPE_P (arg) && !CP_TYPE_CONST_P (arg))
8596     strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
8597   strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
8598   strict &= ~UNIFY_ALLOW_DERIVED;
8599   strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
8600   strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
8601
8602   switch (TREE_CODE (parm))
8603     {
8604     case TYPENAME_TYPE:
8605       /* In a type which contains a nested-name-specifier, template
8606          argument values cannot be deduced for template parameters used
8607          within the nested-name-specifier.  */
8608       return 0;
8609
8610     case TEMPLATE_TYPE_PARM:
8611     case TEMPLATE_TEMPLATE_PARM:
8612     case BOUND_TEMPLATE_TEMPLATE_PARM:
8613       tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
8614
8615       if (TEMPLATE_TYPE_LEVEL (parm)
8616           != template_decl_level (tparm))
8617         /* The PARM is not one we're trying to unify.  Just check
8618            to see if it matches ARG.  */
8619         return (TREE_CODE (arg) == TREE_CODE (parm)
8620                 && same_type_p (parm, arg)) ? 0 : 1;
8621       idx = TEMPLATE_TYPE_IDX (parm);
8622       targ = TREE_VEC_ELT (targs, idx);
8623       tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
8624
8625       /* Check for mixed types and values.  */
8626       if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
8627            && TREE_CODE (tparm) != TYPE_DECL)
8628           || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
8629               && TREE_CODE (tparm) != TEMPLATE_DECL))
8630         return 1;
8631
8632       if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
8633         {
8634           /* ARG must be constructed from a template class or a template
8635              template parameter.  */
8636           if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
8637               && (TREE_CODE (arg) != RECORD_TYPE || !CLASSTYPE_TEMPLATE_INFO (arg)))
8638             return 1;
8639
8640           {
8641             tree parmtmpl = TYPE_TI_TEMPLATE (parm);
8642             tree parmvec = TYPE_TI_ARGS (parm);
8643             tree argvec = TYPE_TI_ARGS (arg);
8644             tree argtmplvec
8645               = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
8646             int i;
8647
8648             /* The parameter and argument roles have to be switched here
8649                in order to handle default arguments properly.  For example,
8650                template<template <class> class TT> void f(TT<int>)
8651                should be able to accept vector<int> which comes from
8652                template <class T, class Allocator = allocator>
8653                class vector.  */
8654
8655             if (coerce_template_parms (argtmplvec, parmvec, parmtmpl, 0, 1)
8656                 == error_mark_node)
8657               return 1;
8658
8659             /* Deduce arguments T, i from TT<T> or TT<i>.
8660                We check each element of PARMVEC and ARGVEC individually
8661                rather than the whole TREE_VEC since they can have
8662                different number of elements.  */
8663
8664             for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
8665               {
8666                 tree t = TREE_VEC_ELT (parmvec, i);
8667
8668                 if (unify (tparms, targs, t,
8669                            TREE_VEC_ELT (argvec, i),
8670                            UNIFY_ALLOW_NONE))
8671                   return 1;
8672               }
8673           }
8674           arg = TYPE_TI_TEMPLATE (arg);
8675
8676           /* Fall through to deduce template name.  */
8677         }
8678
8679       if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
8680           || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
8681         {
8682           /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>.  */
8683
8684           /* Simple cases: Value already set, does match or doesn't.  */
8685           if (targ != NULL_TREE && template_args_equal (targ, arg))
8686             return 0;
8687           else if (targ)
8688             return 1;
8689         }
8690       else
8691         {
8692           /* If PARM is `const T' and ARG is only `int', we don't have
8693              a match unless we are allowing additional qualification.
8694              If ARG is `const int' and PARM is just `T' that's OK;
8695              that binds `const int' to `T'.  */
8696           if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
8697                                          arg, parm))
8698             return 1;
8699
8700           /* Consider the case where ARG is `const volatile int' and
8701              PARM is `const T'.  Then, T should be `volatile int'.  */
8702           arg =
8703             cp_build_qualified_type_real (arg,
8704                                           CP_TYPE_QUALS (arg)
8705                                           & ~CP_TYPE_QUALS (parm),
8706                                           /*complain=*/0);
8707           if (arg == error_mark_node)
8708             return 1;
8709
8710           /* Simple cases: Value already set, does match or doesn't.  */
8711           if (targ != NULL_TREE && same_type_p (targ, arg))
8712             return 0;
8713           else if (targ)
8714             return 1;
8715         }
8716
8717       /* Make sure that ARG is not a variable-sized array.  (Note that
8718          were talking about variable-sized arrays (like `int[n]'),
8719          rather than arrays of unknown size (like `int[]').)  We'll
8720          get very confused by such a type since the bound of the array
8721          will not be computable in an instantiation.  Besides, such
8722          types are not allowed in ISO C++, so we can do as we please
8723          here.  */
8724       if (TREE_CODE (arg) == ARRAY_TYPE
8725           && !uses_template_parms (arg)
8726           && TYPE_DOMAIN (arg)
8727           && (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (arg)))
8728               != INTEGER_CST))
8729         return 1;
8730
8731       TREE_VEC_ELT (targs, idx) = arg;
8732       return 0;
8733
8734     case TEMPLATE_PARM_INDEX:
8735       tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
8736
8737       if (TEMPLATE_PARM_LEVEL (parm)
8738           != template_decl_level (tparm))
8739         /* The PARM is not one we're trying to unify.  Just check
8740            to see if it matches ARG.  */
8741         return (TREE_CODE (arg) == TREE_CODE (parm)
8742                 && cp_tree_equal (parm, arg) > 0) ? 0 : 1;
8743
8744       idx = TEMPLATE_PARM_IDX (parm);
8745       targ = TREE_VEC_ELT (targs, idx);
8746
8747       if (targ)
8748         {
8749           int i = (cp_tree_equal (targ, arg) > 0);
8750           if (i == 1)
8751             return 0;
8752           else if (i == 0)
8753             return 1;
8754           else
8755             my_friendly_abort (42);
8756         }
8757
8758       /* [temp.deduct.type] If, in the declaration of a function template
8759          with a non-type template-parameter, the non-type
8760          template-parameter is used in an expression in the function
8761          parameter-list and, if the corresponding template-argument is
8762          deduced, the template-argument type shall match the type of the
8763          template-parameter exactly, except that a template-argument
8764          deduced from an array bound may be of any integral type.
8765          The non-type parameter might use already deduced type parameters.  */
8766       tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
8767       if (same_type_p (TREE_TYPE (arg), tparm))
8768           /* OK */;
8769       else if ((strict & UNIFY_ALLOW_INTEGER)
8770                && (TREE_CODE (tparm) == INTEGER_TYPE
8771                    || TREE_CODE (tparm) == BOOLEAN_TYPE))
8772         /* OK */;
8773       else if (uses_template_parms (tparm))
8774         /* We haven't deduced the type of this parameter yet.  Try again
8775            later.  */
8776         return 0;
8777       else
8778         return 1;
8779
8780       TREE_VEC_ELT (targs, idx) = arg;
8781       return 0;
8782
8783     case POINTER_TYPE:
8784       {
8785         if (TREE_CODE (arg) != POINTER_TYPE)
8786           return 1;
8787
8788         /* [temp.deduct.call]
8789
8790            A can be another pointer or pointer to member type that can
8791            be converted to the deduced A via a qualification
8792            conversion (_conv.qual_).
8793
8794            We pass down STRICT here rather than UNIFY_ALLOW_NONE.
8795            This will allow for additional cv-qualification of the
8796            pointed-to types if appropriate.  */
8797
8798         if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
8799           /* The derived-to-base conversion only persists through one
8800              level of pointers.  */
8801           strict |= (strict_in & UNIFY_ALLOW_DERIVED);
8802
8803         return unify (tparms, targs, TREE_TYPE (parm),
8804                       TREE_TYPE (arg), strict);
8805       }
8806
8807     case REFERENCE_TYPE:
8808       if (TREE_CODE (arg) != REFERENCE_TYPE)
8809         return 1;
8810       return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
8811                     strict & UNIFY_ALLOW_MORE_CV_QUAL);
8812
8813     case ARRAY_TYPE:
8814       if (TREE_CODE (arg) != ARRAY_TYPE)
8815         return 1;
8816       if ((TYPE_DOMAIN (parm) == NULL_TREE)
8817           != (TYPE_DOMAIN (arg) == NULL_TREE))
8818         return 1;
8819       if (TYPE_DOMAIN (parm) != NULL_TREE
8820           && unify (tparms, targs, TYPE_DOMAIN (parm),
8821                     TYPE_DOMAIN (arg), UNIFY_ALLOW_NONE) != 0)
8822         return 1;
8823       return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
8824                     UNIFY_ALLOW_NONE);
8825
8826     case REAL_TYPE:
8827     case COMPLEX_TYPE:
8828     case VECTOR_TYPE:
8829     case INTEGER_TYPE:
8830     case BOOLEAN_TYPE:
8831     case VOID_TYPE:
8832       if (TREE_CODE (arg) != TREE_CODE (parm))
8833         return 1;
8834
8835       if (TREE_CODE (parm) == INTEGER_TYPE
8836           && TREE_CODE (TYPE_MAX_VALUE (parm)) != INTEGER_CST)
8837         {
8838           if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg)
8839               && unify (tparms, targs, TYPE_MIN_VALUE (parm),
8840                         TYPE_MIN_VALUE (arg), UNIFY_ALLOW_INTEGER))
8841             return 1;
8842           if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg)
8843               && unify (tparms, targs, TYPE_MAX_VALUE (parm),
8844                         TYPE_MAX_VALUE (arg), UNIFY_ALLOW_INTEGER))
8845             return 1;
8846         }
8847       /* We have already checked cv-qualification at the top of the
8848          function.  */
8849       else if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
8850         return 1;
8851
8852       /* As far as unification is concerned, this wins.  Later checks
8853          will invalidate it if necessary.  */
8854       return 0;
8855
8856       /* Types INTEGER_CST and MINUS_EXPR can come from array bounds.  */
8857       /* Type INTEGER_CST can come from ordinary constant template args.  */
8858     case INTEGER_CST:
8859       while (TREE_CODE (arg) == NOP_EXPR)
8860         arg = TREE_OPERAND (arg, 0);
8861
8862       if (TREE_CODE (arg) != INTEGER_CST)
8863         return 1;
8864       return !tree_int_cst_equal (parm, arg);
8865
8866     case TREE_VEC:
8867       {
8868         int i;
8869         if (TREE_CODE (arg) != TREE_VEC)
8870           return 1;
8871         if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
8872           return 1;
8873         for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
8874           if (unify (tparms, targs,
8875                      TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
8876                      UNIFY_ALLOW_NONE))
8877             return 1;
8878         return 0;
8879       }
8880
8881     case RECORD_TYPE:
8882     case UNION_TYPE:
8883       if (TREE_CODE (arg) != TREE_CODE (parm))
8884         return 1;
8885
8886       if (TYPE_PTRMEMFUNC_P (parm))
8887         {
8888           if (!TYPE_PTRMEMFUNC_P (arg))
8889             return 1;
8890
8891           return unify (tparms, targs,
8892                         TYPE_PTRMEMFUNC_FN_TYPE (parm),
8893                         TYPE_PTRMEMFUNC_FN_TYPE (arg),
8894                         strict);
8895         }
8896
8897       if (CLASSTYPE_TEMPLATE_INFO (parm))
8898         {
8899           tree t = NULL_TREE;
8900
8901           if (strict_in & UNIFY_ALLOW_DERIVED)
8902             {
8903               /* First, we try to unify the PARM and ARG directly.  */
8904               t = try_class_unification (tparms, targs,
8905                                          parm, arg);
8906
8907               if (!t)
8908                 {
8909                   /* Fallback to the special case allowed in
8910                      [temp.deduct.call]:
8911
8912                        If P is a class, and P has the form
8913                        template-id, then A can be a derived class of
8914                        the deduced A.  Likewise, if P is a pointer to
8915                        a class of the form template-id, A can be a
8916                        pointer to a derived class pointed to by the
8917                        deduced A.  */
8918                   t = get_template_base (tparms, targs,
8919                                          parm, arg);
8920
8921                   if (! t || t == error_mark_node)
8922                     return 1;
8923                 }
8924             }
8925           else if (CLASSTYPE_TEMPLATE_INFO (arg)
8926                    && (CLASSTYPE_TI_TEMPLATE (parm)
8927                        == CLASSTYPE_TI_TEMPLATE (arg)))
8928             /* Perhaps PARM is something like S<U> and ARG is S<int>.
8929                Then, we should unify `int' and `U'.  */
8930             t = arg;
8931           else
8932             /* There's no chance of unification succeeding.  */
8933             return 1;
8934
8935           return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
8936                         CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
8937         }
8938       else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
8939         return 1;
8940       return 0;
8941
8942     case METHOD_TYPE:
8943     case FUNCTION_TYPE:
8944       if (TREE_CODE (arg) != TREE_CODE (parm))
8945         return 1;
8946
8947       if (unify (tparms, targs, TREE_TYPE (parm),
8948                  TREE_TYPE (arg), UNIFY_ALLOW_NONE))
8949         return 1;
8950       return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
8951                                     TYPE_ARG_TYPES (arg), 1,
8952                                     DEDUCE_EXACT, 0, -1);
8953
8954     case OFFSET_TYPE:
8955       if (TREE_CODE (arg) != OFFSET_TYPE)
8956         return 1;
8957       if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
8958                  TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
8959         return 1;
8960       return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
8961                     strict);
8962
8963     case CONST_DECL:
8964       if (arg != decl_constant_value (parm))
8965         return 1;
8966       return 0;
8967
8968     case TEMPLATE_DECL:
8969       /* Matched cases are handled by the ARG == PARM test above.  */
8970       return 1;
8971
8972     case MINUS_EXPR:
8973       if (TREE_CODE (TREE_OPERAND (parm, 1)) == INTEGER_CST)
8974         {
8975           /* We handle this case specially, since it comes up with
8976              arrays.  In particular, something like:
8977
8978              template <int N> void f(int (&x)[N]);
8979
8980              Here, we are trying to unify the range type, which
8981              looks like [0 ... (N - 1)].  */
8982           tree t, t1, t2;
8983           t1 = TREE_OPERAND (parm, 0);
8984           t2 = TREE_OPERAND (parm, 1);
8985
8986           t = fold (build (PLUS_EXPR, integer_type_node, arg, t2));
8987
8988           return unify (tparms, targs, t1, t, strict);
8989         }
8990       /* else fall through */
8991
8992     default:
8993       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm))))
8994         {
8995
8996           /* We're looking at an expression.  This can happen with
8997              something like:
8998
8999                template <int I>
9000                void foo(S<I>, S<I + 2>);
9001
9002              This is a "nondeduced context":
9003
9004                [deduct.type]
9005
9006                The nondeduced contexts are:
9007
9008                --A type that is a template-id in which one or more of
9009                  the template-arguments is an expression that references
9010                  a template-parameter.
9011
9012              In these cases, we assume deduction succeeded, but don't
9013              actually infer any unifications.  */
9014
9015           if (!uses_template_parms (parm)
9016               && !template_args_equal (parm, arg))
9017             return 1;
9018           else
9019             return 0;
9020         }
9021       else
9022         sorry ("use of `%s' in template type unification",
9023                tree_code_name [(int) TREE_CODE (parm)]);
9024
9025       return 1;
9026     }
9027 }
9028 \f
9029 /* Called if RESULT is explicitly instantiated, or is a member of an
9030    explicitly instantiated class, or if using -frepo and the
9031    instantiation of RESULT has been assigned to this file.  */
9032
9033 void
9034 mark_decl_instantiated (result, extern_p)
9035      tree result;
9036      int extern_p;
9037 {
9038   if (TREE_CODE (result) != FUNCTION_DECL)
9039     /* The TREE_PUBLIC flag for function declarations will have been
9040        set correctly by tsubst.  */
9041     TREE_PUBLIC (result) = 1;
9042
9043   /* We used to set this unconditionally; we moved that to
9044      do_decl_instantiation so it wouldn't get set on members of
9045      explicit class template instantiations.  But we still need to set
9046      it here for the 'extern template' case in order to suppress
9047      implicit instantiations.  */
9048   if (extern_p)
9049     SET_DECL_EXPLICIT_INSTANTIATION (result);
9050
9051   if (! extern_p)
9052     {
9053       DECL_INTERFACE_KNOWN (result) = 1;
9054       DECL_NOT_REALLY_EXTERN (result) = 1;
9055
9056       /* Always make artificials weak.  */
9057       if (DECL_ARTIFICIAL (result) && flag_weak)
9058         comdat_linkage (result);
9059       /* For WIN32 we also want to put explicit instantiations in
9060          linkonce sections.  */
9061       else if (TREE_PUBLIC (result))
9062         maybe_make_one_only (result);
9063     }
9064   else if (TREE_CODE (result) == FUNCTION_DECL)
9065     defer_fn (result);
9066 }
9067
9068 /* Given two function templates PAT1 and PAT2, return:
9069
9070    DEDUCE should be DEDUCE_EXACT or DEDUCE_ORDER.
9071
9072    1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
9073    -1 if PAT2 is more specialized than PAT1.
9074    0 if neither is more specialized.
9075
9076    LEN is passed through to fn_type_unification.  */
9077
9078 int
9079 more_specialized (pat1, pat2, deduce, len)
9080      tree pat1, pat2;
9081      int deduce;
9082      int len;
9083 {
9084   tree targs;
9085   int winner = 0;
9086
9087   targs = get_bindings_real (pat1, DECL_TEMPLATE_RESULT (pat2),
9088                              NULL_TREE, 0, deduce, len);
9089   if (targs)
9090     --winner;
9091
9092   targs = get_bindings_real (pat2, DECL_TEMPLATE_RESULT (pat1),
9093                              NULL_TREE, 0, deduce, len);
9094   if (targs)
9095     ++winner;
9096
9097   return winner;
9098 }
9099
9100 /* Given two class template specialization list nodes PAT1 and PAT2, return:
9101
9102    1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
9103    -1 if PAT2 is more specialized than PAT1.
9104    0 if neither is more specialized.  */
9105
9106 int
9107 more_specialized_class (pat1, pat2)
9108      tree pat1, pat2;
9109 {
9110   tree targs;
9111   int winner = 0;
9112
9113   targs = get_class_bindings (TREE_VALUE (pat1), TREE_PURPOSE (pat1),
9114                               TREE_PURPOSE (pat2));
9115   if (targs)
9116     --winner;
9117
9118   targs = get_class_bindings (TREE_VALUE (pat2), TREE_PURPOSE (pat2),
9119                               TREE_PURPOSE (pat1));
9120   if (targs)
9121     ++winner;
9122
9123   return winner;
9124 }
9125
9126 /* Return the template arguments that will produce the function signature
9127    DECL from the function template FN, with the explicit template
9128    arguments EXPLICIT_ARGS.  If CHECK_RETTYPE is 1, the return type must
9129    also match.  Return NULL_TREE if no satisfactory arguments could be
9130    found.  DEDUCE and LEN are passed through to fn_type_unification.  */
9131
9132 static tree
9133 get_bindings_real (fn, decl, explicit_args, check_rettype, deduce, len)
9134      tree fn, decl, explicit_args;
9135      int check_rettype, deduce, len;
9136 {
9137   int ntparms = DECL_NTPARMS (fn);
9138   tree targs = make_tree_vec (ntparms);
9139   tree decl_type;
9140   tree decl_arg_types;
9141   int i;
9142
9143   /* Substitute the explicit template arguments into the type of DECL.
9144      The call to fn_type_unification will handle substitution into the
9145      FN.  */
9146   decl_type = TREE_TYPE (decl);
9147   if (explicit_args && uses_template_parms (decl_type))
9148     {
9149       tree tmpl;
9150       tree converted_args;
9151
9152       if (DECL_TEMPLATE_INFO (decl))
9153         tmpl = DECL_TI_TEMPLATE (decl);
9154       else
9155         /* We can get here for some illegal specializations.  */
9156         return NULL_TREE;
9157
9158       converted_args
9159         = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
9160                                   explicit_args, NULL_TREE,
9161                                   /*complain=*/0,
9162                                   /*require_all_arguments=*/0));
9163       if (converted_args == error_mark_node)
9164         return NULL_TREE;
9165
9166       decl_type = tsubst (decl_type, converted_args, /*complain=*/0,
9167                           NULL_TREE);
9168       if (decl_type == error_mark_node)
9169         return NULL_TREE;
9170     }
9171
9172   decl_arg_types = TYPE_ARG_TYPES (decl_type);
9173   /* Never do unification on the 'this' parameter.  */
9174   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9175     decl_arg_types = TREE_CHAIN (decl_arg_types);
9176
9177   i = fn_type_unification (fn, explicit_args, targs,
9178                            decl_arg_types,
9179                            (check_rettype || DECL_CONV_FN_P (fn)
9180                             ? TREE_TYPE (decl_type) : NULL_TREE),
9181                            deduce, len);
9182
9183   if (i != 0)
9184     return NULL_TREE;
9185
9186   return targs;
9187 }
9188
9189 /* For most uses, we want to check the return type.  */
9190
9191 tree
9192 get_bindings (fn, decl, explicit_args)
9193      tree fn, decl, explicit_args;
9194 {
9195   return get_bindings_real (fn, decl, explicit_args, 1, DEDUCE_EXACT, -1);
9196 }
9197
9198 /* But for resolve_overloaded_unification, we only care about the parameter
9199    types.  */
9200
9201 static tree
9202 get_bindings_overload (fn, decl, explicit_args)
9203      tree fn, decl, explicit_args;
9204 {
9205   return get_bindings_real (fn, decl, explicit_args, 0, DEDUCE_EXACT, -1);
9206 }
9207
9208 /* Return the innermost template arguments that, when applied to a
9209    template specialization whose innermost template parameters are
9210    TPARMS, and whose specialization arguments are ARGS, yield the
9211    ARGS.
9212
9213    For example, suppose we have:
9214
9215      template <class T, class U> struct S {};
9216      template <class T> struct S<T*, int> {};
9217
9218    Then, suppose we want to get `S<double*, int>'.  The TPARMS will be
9219    {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
9220    int}.  The resulting vector will be {double}, indicating that `T'
9221    is bound to `double'.  */
9222
9223 static tree
9224 get_class_bindings (tparms, parms, args)
9225      tree tparms, parms, args;
9226 {
9227   int i, ntparms = TREE_VEC_LENGTH (tparms);
9228   tree vec = make_tree_vec (ntparms);
9229
9230   if (unify (tparms, vec, parms, INNERMOST_TEMPLATE_ARGS (args),
9231              UNIFY_ALLOW_NONE))
9232     return NULL_TREE;
9233
9234   for (i =  0; i < ntparms; ++i)
9235     if (! TREE_VEC_ELT (vec, i))
9236       return NULL_TREE;
9237
9238   if (verify_class_unification (vec, parms, args))
9239     return NULL_TREE;
9240
9241   return vec;
9242 }
9243
9244 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
9245    Pick the most specialized template, and return the corresponding
9246    instantiation, or if there is no corresponding instantiation, the
9247    template itself.  If there is no most specialized template,
9248    error_mark_node is returned.  If there are no templates at all,
9249    NULL_TREE is returned.  */
9250
9251 tree
9252 most_specialized_instantiation (instantiations)
9253      tree instantiations;
9254 {
9255   tree fn, champ;
9256   int fate;
9257
9258   if (!instantiations)
9259     return NULL_TREE;
9260
9261   champ = instantiations;
9262   for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn))
9263     {
9264       fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn),
9265                                DEDUCE_EXACT, -1);
9266       if (fate == 1)
9267         ;
9268       else
9269         {
9270           if (fate == 0)
9271             {
9272               fn = TREE_CHAIN (fn);
9273               if (! fn)
9274                 return error_mark_node;
9275             }
9276           champ = fn;
9277         }
9278     }
9279
9280   for (fn = instantiations; fn && fn != champ; fn = TREE_CHAIN (fn))
9281     {
9282       fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn),
9283                                DEDUCE_EXACT, -1);
9284       if (fate != 1)
9285         return error_mark_node;
9286     }
9287
9288   return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ);
9289 }
9290
9291 /* Return the most specialized of the list of templates in FNS that can
9292    produce an instantiation matching DECL, given the explicit template
9293    arguments EXPLICIT_ARGS.  */
9294
9295 static tree
9296 most_specialized (fns, decl, explicit_args)
9297      tree fns, decl, explicit_args;
9298 {
9299   tree candidates = NULL_TREE;
9300   tree fn, args;
9301
9302   for (fn = fns; fn; fn = TREE_CHAIN (fn))
9303     {
9304       tree candidate = TREE_VALUE (fn);
9305
9306       args = get_bindings (candidate, decl, explicit_args);
9307       if (args)
9308         candidates = tree_cons (NULL_TREE, candidate, candidates);
9309     }
9310
9311   return most_specialized_instantiation (candidates);
9312 }
9313
9314 /* If DECL is a specialization of some template, return the most
9315    general such template.  Otherwise, returns NULL_TREE.
9316
9317    For example, given:
9318
9319      template <class T> struct S { template <class U> void f(U); };
9320
9321    if TMPL is `template <class U> void S<int>::f(U)' this will return
9322    the full template.  This function will not trace past partial
9323    specializations, however.  For example, given in addition:
9324
9325      template <class T> struct S<T*> { template <class U> void f(U); };
9326
9327    if TMPL is `template <class U> void S<int*>::f(U)' this will return
9328    `template <class T> template <class U> S<T*>::f(U)'.  */
9329
9330 tree
9331 most_general_template (decl)
9332      tree decl;
9333 {
9334   /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
9335      an immediate specialization.  */
9336   if (TREE_CODE (decl) == FUNCTION_DECL)
9337     {
9338       if (DECL_TEMPLATE_INFO (decl)) {
9339         decl = DECL_TI_TEMPLATE (decl);
9340
9341         /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
9342            template friend.  */
9343         if (TREE_CODE (decl) != TEMPLATE_DECL)
9344           return NULL_TREE;
9345       } else
9346         return NULL_TREE;
9347     }
9348
9349   /* Look for more and more general templates.  */
9350   while (DECL_TEMPLATE_INFO (decl))
9351     {
9352       /* The DECL_TI_TEMPLATE can be a LOOKUP_EXPR or IDENTIFIER_NODE
9353          in some cases.  (See cp-tree.h for details.)  */
9354       if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
9355         break;
9356
9357       /* Stop if we run into an explicitly specialized class template.  */
9358       if (!DECL_NAMESPACE_SCOPE_P (decl)
9359           && DECL_CONTEXT (decl)
9360           && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
9361         break;
9362
9363       decl = DECL_TI_TEMPLATE (decl);
9364     }
9365
9366   return decl;
9367 }
9368
9369 /* Return the most specialized of the class template specializations
9370    of TMPL which can produce an instantiation matching ARGS, or
9371    error_mark_node if the choice is ambiguous.  */
9372
9373 static tree
9374 most_specialized_class (tmpl, args)
9375      tree tmpl;
9376      tree args;
9377 {
9378   tree list = NULL_TREE;
9379   tree t;
9380   tree champ;
9381   int fate;
9382
9383   tmpl = most_general_template (tmpl);
9384   for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
9385     {
9386       tree spec_args
9387         = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args);
9388       if (spec_args)
9389         {
9390           list = tree_cons (TREE_PURPOSE (t), TREE_VALUE (t), list);
9391           TREE_TYPE (list) = TREE_TYPE (t);
9392         }
9393     }
9394
9395   if (! list)
9396     return NULL_TREE;
9397
9398   t = list;
9399   champ = t;
9400   t = TREE_CHAIN (t);
9401   for (; t; t = TREE_CHAIN (t))
9402     {
9403       fate = more_specialized_class (champ, t);
9404       if (fate == 1)
9405         ;
9406       else
9407         {
9408           if (fate == 0)
9409             {
9410               t = TREE_CHAIN (t);
9411               if (! t)
9412                 return error_mark_node;
9413             }
9414           champ = t;
9415         }
9416     }
9417
9418   for (t = list; t && t != champ; t = TREE_CHAIN (t))
9419     {
9420       fate = more_specialized_class (champ, t);
9421       if (fate != 1)
9422         return error_mark_node;
9423     }
9424
9425   return champ;
9426 }
9427
9428 /* called from the parser.  */
9429
9430 void
9431 do_decl_instantiation (declspecs, declarator, storage)
9432      tree declspecs, declarator, storage;
9433 {
9434   tree decl = grokdeclarator (declarator, declspecs, NORMAL, 0, NULL_TREE);
9435   tree result = NULL_TREE;
9436   int extern_p = 0;
9437
9438   if (!decl)
9439     /* An error occurred, for which grokdeclarator has already issued
9440        an appropriate message.  */
9441     return;
9442   else if (! DECL_LANG_SPECIFIC (decl))
9443     {
9444       cp_error ("explicit instantiation of non-template `%#D'", decl);
9445       return;
9446     }
9447   else if (TREE_CODE (decl) == VAR_DECL)
9448     {
9449       /* There is an asymmetry here in the way VAR_DECLs and
9450          FUNCTION_DECLs are handled by grokdeclarator.  In the case of
9451          the latter, the DECL we get back will be marked as a
9452          template instantiation, and the appropriate
9453          DECL_TEMPLATE_INFO will be set up.  This does not happen for
9454          VAR_DECLs so we do the lookup here.  Probably, grokdeclarator
9455          should handle VAR_DECLs as it currently handles
9456          FUNCTION_DECLs.  */
9457       result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, 0);
9458       if (result && TREE_CODE (result) != VAR_DECL)
9459         {
9460           cp_error ("no matching template for `%D' found", result);
9461           return;
9462         }
9463     }
9464   else if (TREE_CODE (decl) != FUNCTION_DECL)
9465     {
9466       cp_error ("explicit instantiation of `%#D'", decl);
9467       return;
9468     }
9469   else
9470     result = decl;
9471
9472   /* Check for various error cases.  Note that if the explicit
9473      instantiation is legal the RESULT will currently be marked as an
9474      *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
9475      until we get here.  */
9476
9477   if (DECL_TEMPLATE_SPECIALIZATION (result))
9478     {
9479       /* [temp.spec]
9480
9481          No program shall both explicitly instantiate and explicitly
9482          specialize a template.  */
9483       cp_pedwarn ("explicit instantiation of `%#D' after", result);
9484       cp_pedwarn_at ("explicit specialization here", result);
9485       return;
9486     }
9487   else if (DECL_EXPLICIT_INSTANTIATION (result))
9488     {
9489       /* [temp.spec]
9490
9491          No program shall explicitly instantiate any template more
9492          than once.
9493
9494          We check DECL_INTERFACE_KNOWN so as not to complain when the first
9495          instantiation was `extern' and the second is not, and EXTERN_P for
9496          the opposite case.  If -frepo, chances are we already got marked
9497          as an explicit instantiation because of the repo file.  */
9498       if (DECL_INTERFACE_KNOWN (result) && !extern_p && !flag_use_repository)
9499         cp_pedwarn ("duplicate explicit instantiation of `%#D'", result);
9500
9501       /* If we've already instantiated the template, just return now.  */
9502       if (DECL_INTERFACE_KNOWN (result))
9503         return;
9504     }
9505   else if (!DECL_IMPLICIT_INSTANTIATION (result))
9506     {
9507       cp_error ("no matching template for `%D' found", result);
9508       return;
9509     }
9510   else if (!DECL_TEMPLATE_INFO (result))
9511     {
9512       cp_pedwarn ("explicit instantiation of non-template `%#D'", result);
9513       return;
9514     }
9515
9516   if (flag_external_templates)
9517     return;
9518
9519   if (storage == NULL_TREE)
9520     ;
9521   else if (storage == ridpointers[(int) RID_EXTERN])
9522     {
9523       if (pedantic)
9524         cp_pedwarn ("ISO C++ forbids the use of `extern' on explicit instantiations");
9525       extern_p = 1;
9526     }
9527   else
9528     cp_error ("storage class `%D' applied to template instantiation",
9529               storage);
9530
9531   SET_DECL_EXPLICIT_INSTANTIATION (result);
9532   mark_decl_instantiated (result, extern_p);
9533   repo_template_instantiated (result, extern_p);
9534   if (! extern_p)
9535     instantiate_decl (result, /*defer_ok=*/1);
9536 }
9537
9538 void
9539 mark_class_instantiated (t, extern_p)
9540      tree t;
9541      int extern_p;
9542 {
9543   SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
9544   SET_CLASSTYPE_INTERFACE_KNOWN (t);
9545   CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
9546   CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! extern_p;
9547   TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
9548   if (! extern_p)
9549     {
9550       CLASSTYPE_DEBUG_REQUESTED (t) = 1;
9551       rest_of_type_compilation (t, 1);
9552     }
9553 }
9554
9555 /* Perform an explicit instantiation of template class T.  STORAGE, if
9556    non-null, is the RID for extern, inline or static.  COMPLAIN is
9557    non-zero if this is called from the parser, zero if called recursively,
9558    since the standard is unclear (as detailed below).  */
9559
9560 void
9561 do_type_instantiation (t, storage, complain)
9562      tree t, storage;
9563      int complain;
9564 {
9565   int extern_p = 0;
9566   int nomem_p = 0;
9567   int static_p = 0;
9568
9569   if (TREE_CODE (t) == TYPE_DECL)
9570     t = TREE_TYPE (t);
9571
9572   if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
9573     {
9574       cp_error ("explicit instantiation of non-template type `%T'", t);
9575       return;
9576     }
9577
9578   complete_type (t);
9579
9580   /* With -fexternal-templates, explicit instantiations are treated the same
9581      as implicit ones.  */
9582   if (flag_external_templates)
9583     return;
9584
9585   if (!COMPLETE_TYPE_P (t))
9586     {
9587       if (complain)
9588         cp_error ("explicit instantiation of `%#T' before definition of template",
9589                   t);
9590       return;
9591     }
9592
9593   if (storage != NULL_TREE)
9594     {
9595       if (pedantic)
9596         cp_pedwarn("ISO C++ forbids the use of `%s' on explicit instantiations",
9597                    IDENTIFIER_POINTER (storage));
9598
9599       if (storage == ridpointers[(int) RID_INLINE])
9600         nomem_p = 1;
9601       else if (storage == ridpointers[(int) RID_EXTERN])
9602         extern_p = 1;
9603       else if (storage == ridpointers[(int) RID_STATIC])
9604         static_p = 1;
9605       else
9606         {
9607           cp_error ("storage class `%D' applied to template instantiation",
9608                     storage);
9609           extern_p = 0;
9610         }
9611     }
9612
9613   if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
9614     {
9615       /* [temp.spec]
9616
9617          No program shall both explicitly instantiate and explicitly
9618          specialize a template.  */
9619       if (complain)
9620         {
9621           cp_error ("explicit instantiation of `%#T' after", t);
9622           cp_error_at ("explicit specialization here", t);
9623         }
9624       return;
9625     }
9626   else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
9627     {
9628       /* [temp.spec]
9629
9630          No program shall explicitly instantiate any template more
9631          than once.
9632
9633          If CLASSTYPE_INTERFACE_ONLY, then the first explicit instantiation
9634          was `extern'.  If EXTERN_P then the second is.  If -frepo, chances
9635          are we already got marked as an explicit instantion because of the
9636          repo file.  All these cases are OK.  */
9637       if (!CLASSTYPE_INTERFACE_ONLY (t) && !extern_p && !flag_use_repository
9638           && complain)
9639         cp_pedwarn ("duplicate explicit instantiation of `%#T'", t);
9640
9641       /* If we've already instantiated the template, just return now.  */
9642       if (!CLASSTYPE_INTERFACE_ONLY (t))
9643         return;
9644     }
9645
9646   mark_class_instantiated (t, extern_p);
9647   repo_template_instantiated (t, extern_p);
9648
9649   if (nomem_p)
9650     return;
9651
9652   {
9653     tree tmp;
9654
9655     /* In contrast to implicit instantiation, where only the
9656        declarations, and not the definitions, of members are
9657        instantiated, we have here:
9658
9659          [temp.explicit]
9660
9661          The explicit instantiation of a class template specialization
9662          implies the instantiation of all of its members not
9663          previously explicitly specialized in the translation unit
9664          containing the explicit instantiation.
9665
9666        Of course, we can't instantiate member template classes, since
9667        we don't have any arguments for them.  Note that the standard
9668        is unclear on whether the instantiation of the members are
9669        *explicit* instantiations or not.  We choose to be generous,
9670        and not set DECL_EXPLICIT_INSTANTIATION.  Therefore, we allow
9671        the explicit instantiation of a class where some of the members
9672        have no definition in the current translation unit.  */
9673
9674     if (! static_p)
9675       for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
9676         if (TREE_CODE (tmp) == FUNCTION_DECL
9677             && DECL_TEMPLATE_INSTANTIATION (tmp))
9678           {
9679             mark_decl_instantiated (tmp, extern_p);
9680             repo_template_instantiated (tmp, extern_p);
9681             if (! extern_p)
9682               instantiate_decl (tmp, /*defer_ok=*/1);
9683           }
9684
9685     for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
9686       if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
9687         {
9688           mark_decl_instantiated (tmp, extern_p);
9689           repo_template_instantiated (tmp, extern_p);
9690           if (! extern_p)
9691             instantiate_decl (tmp, /*defer_ok=*/1);
9692         }
9693
9694     for (tmp = CLASSTYPE_TAGS (t); tmp; tmp = TREE_CHAIN (tmp))
9695       if (IS_AGGR_TYPE (TREE_VALUE (tmp))
9696           && !uses_template_parms (CLASSTYPE_TI_ARGS (TREE_VALUE (tmp))))
9697         do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp)), storage, 0);
9698   }
9699 }
9700
9701 /* Given a function DECL, which is a specialization of TMPL, modify
9702    DECL to be a re-instantiation of TMPL with the same template
9703    arguments.  TMPL should be the template into which tsubst'ing
9704    should occur for DECL, not the most general template.
9705
9706    One reason for doing this is a scenario like this:
9707
9708      template <class T>
9709      void f(const T&, int i);
9710
9711      void g() { f(3, 7); }
9712
9713      template <class T>
9714      void f(const T& t, const int i) { }
9715
9716    Note that when the template is first instantiated, with
9717    instantiate_template, the resulting DECL will have no name for the
9718    first parameter, and the wrong type for the second.  So, when we go
9719    to instantiate the DECL, we regenerate it.  */
9720
9721 static void
9722 regenerate_decl_from_template (decl, tmpl)
9723      tree decl;
9724      tree tmpl;
9725 {
9726   /* The most general version of TMPL.  */
9727   tree gen_tmpl;
9728   /* The arguments used to instantiate DECL, from the most general
9729      template.  */
9730   tree args;
9731   tree code_pattern;
9732   tree new_decl;
9733   int unregistered;
9734
9735   args = DECL_TI_ARGS (decl);
9736   code_pattern = DECL_TEMPLATE_RESULT (tmpl);
9737
9738   /* Unregister the specialization so that when we tsubst we will not
9739      just return DECL.  We don't have to unregister DECL from TMPL
9740      because if would only be registered there if it were a partial
9741      instantiation of a specialization, which it isn't: it's a full
9742      instantiation.  */
9743   gen_tmpl = most_general_template (tmpl);
9744   unregistered = unregister_specialization (decl, gen_tmpl);
9745
9746   /* If the DECL was not unregistered then something peculiar is
9747      happening: we created a specialization but did not call
9748      register_specialization for it.  */
9749   my_friendly_assert (unregistered, 0);
9750
9751   if (TREE_CODE (decl) == VAR_DECL)
9752     /* Make sure that we can see identifiers, and compute access
9753        correctly, for the class members used in the declaration of
9754        this static variable.  */
9755     pushclass (DECL_CONTEXT (decl), 2);
9756
9757   /* Do the substitution to get the new declaration.  */
9758   new_decl = tsubst (code_pattern, args, /*complain=*/1, NULL_TREE);
9759
9760   if (TREE_CODE (decl) == VAR_DECL)
9761     {
9762       /* Set up DECL_INITIAL, since tsubst doesn't.  */
9763       DECL_INITIAL (new_decl) =
9764         tsubst_expr (DECL_INITIAL (code_pattern), args,
9765                      /*complain=*/1, DECL_TI_TEMPLATE (decl));
9766       /* Pop the class context we pushed above.  */
9767       popclass ();
9768     }
9769   else if (TREE_CODE (decl) == FUNCTION_DECL)
9770     {
9771       /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
9772          new decl.  */
9773       DECL_INITIAL (new_decl) = error_mark_node;
9774       /* And don't complain about a duplicate definition.  */
9775       DECL_INITIAL (decl) = NULL_TREE;
9776     }
9777
9778   /* The immediate parent of the new template is still whatever it was
9779      before, even though tsubst sets DECL_TI_TEMPLATE up as the most
9780      general template.  We also reset the DECL_ASSEMBLER_NAME since
9781      tsubst always calculates the name as if the function in question
9782      were really a template instance, and sometimes, with friend
9783      functions, this is not so.  See tsubst_friend_function for
9784      details.  */
9785   DECL_TI_TEMPLATE (new_decl) = DECL_TI_TEMPLATE (decl);
9786   DECL_ASSEMBLER_NAME (new_decl) = DECL_ASSEMBLER_NAME (decl);
9787   DECL_RTL (new_decl) = DECL_RTL (decl);
9788   DECL_USE_TEMPLATE (new_decl) = DECL_USE_TEMPLATE (decl);
9789
9790   /* Call duplicate decls to merge the old and new declarations.  */
9791   duplicate_decls (new_decl, decl);
9792
9793   /* Now, re-register the specialization.  */
9794   register_specialization (decl, gen_tmpl, args);
9795 }
9796
9797 /* Produce the definition of D, a _DECL generated from a template.  If
9798    DEFER_OK is non-zero, then we don't have to actually do the
9799    instantiation now; we just have to do it sometime.  */
9800
9801 tree
9802 instantiate_decl (d, defer_ok)
9803      tree d;
9804      int defer_ok;
9805 {
9806   tree tmpl = DECL_TI_TEMPLATE (d);
9807   tree args = DECL_TI_ARGS (d);
9808   tree td;
9809   tree code_pattern;
9810   tree spec;
9811   tree gen_tmpl;
9812   int pattern_defined;
9813   int line = lineno;
9814   int need_push;
9815   const char *file = input_filename;
9816
9817   /* This function should only be used to instantiate templates for
9818      functions and static member variables.  */
9819   my_friendly_assert (TREE_CODE (d) == FUNCTION_DECL
9820                       || TREE_CODE (d) == VAR_DECL, 0);
9821
9822   /* Don't instantiate cloned functions.  Instead, instantiate the
9823      functions they cloned.  */
9824   if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
9825     d = DECL_CLONED_FUNCTION (d);
9826
9827   if (DECL_TEMPLATE_INSTANTIATED (d))
9828     /* D has already been instantiated.  It might seem reasonable to
9829        check whether or not D is an explicit instantiation, and, if so,
9830        stop here.  But when an explicit instantiation is deferred
9831        until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
9832        is set, even though we still need to do the instantiation.  */
9833     return d;
9834
9835   /* If we already have a specialization of this declaration, then
9836      there's no reason to instantiate it.  Note that
9837      retrieve_specialization gives us both instantiations and
9838      specializations, so we must explicitly check
9839      DECL_TEMPLATE_SPECIALIZATION.  */
9840   gen_tmpl = most_general_template (tmpl);
9841   spec = retrieve_specialization (gen_tmpl, args);
9842   if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
9843     return spec;
9844
9845   /* This needs to happen before any tsubsting.  */
9846   if (! push_tinst_level (d))
9847     return d;
9848
9849   timevar_push (TV_PARSE);
9850
9851   /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
9852      for the instantiation.  This is not always the most general
9853      template.  Consider, for example:
9854
9855         template <class T>
9856         struct S { template <class U> void f();
9857                    template <> void f<int>(); };
9858
9859      and an instantiation of S<double>::f<int>.  We want TD to be the
9860      specialization S<T>::f<int>, not the more general S<T>::f<U>.  */
9861   td = tmpl;
9862   while (/* An instantiation cannot have a definition, so we need a
9863             more general template.  */
9864          DECL_TEMPLATE_INSTANTIATION (td)
9865            /* We must also deal with friend templates.  Given:
9866
9867                 template <class T> struct S {
9868                   template <class U> friend void f() {};
9869                 };
9870
9871               S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
9872               so far as the language is concerned, but that's still
9873               where we get the pattern for the instantiation from.  On
9874               other hand, if the definition comes outside the class, say:
9875
9876                 template <class T> struct S {
9877                   template <class U> friend void f();
9878                 };
9879                 template <class U> friend void f() {}
9880
9881               we don't need to look any further.  That's what the check for
9882               DECL_INITIAL is for.  */
9883           || (TREE_CODE (d) == FUNCTION_DECL
9884               && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (td)
9885               && !DECL_INITIAL (DECL_TEMPLATE_RESULT (td))))
9886     {
9887       /* The present template, TD, should not be a definition.  If it
9888          were a definition, we should be using it!  Note that we
9889          cannot restructure the loop to just keep going until we find
9890          a template with a definition, since that might go too far if
9891          a specialization was declared, but not defined.  */
9892       my_friendly_assert (!(TREE_CODE (d) == VAR_DECL
9893                             && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (td))),
9894                           0);
9895
9896       /* Fetch the more general template.  */
9897       td = DECL_TI_TEMPLATE (td);
9898     }
9899
9900   code_pattern = DECL_TEMPLATE_RESULT (td);
9901
9902   if (TREE_CODE (d) == FUNCTION_DECL)
9903     pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
9904   else
9905     pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
9906
9907   lineno = DECL_SOURCE_LINE (d);
9908   input_filename = DECL_SOURCE_FILE (d);
9909
9910   if (pattern_defined)
9911     {
9912       repo_template_used (d);
9913
9914       if (flag_external_templates && ! DECL_INTERFACE_KNOWN (d))
9915         {
9916           if (flag_alt_external_templates)
9917             {
9918               if (interface_unknown)
9919                 warn_if_unknown_interface (d);
9920             }
9921           else if (DECL_INTERFACE_KNOWN (code_pattern))
9922             {
9923               DECL_INTERFACE_KNOWN (d) = 1;
9924               DECL_NOT_REALLY_EXTERN (d) = ! DECL_EXTERNAL (code_pattern);
9925             }
9926           else
9927             warn_if_unknown_interface (code_pattern);
9928         }
9929
9930       if (at_eof)
9931         import_export_decl (d);
9932     }
9933
9934   /* We need to set up DECL_INITIAL regardless, if
9935      the variable is initialized in the class body.  */
9936   if (TREE_CODE (d) == VAR_DECL && DECL_INITIALIZED_IN_CLASS_P (d))
9937     ;
9938   /* Reject all external templates except inline functions.  */
9939   else if (DECL_INTERFACE_KNOWN (d)
9940            && ! DECL_NOT_REALLY_EXTERN (d)
9941            && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d)))
9942     goto out;
9943   /* Defer all other templates, unless we have been explicitly
9944      forbidden from doing so.  We restore the source position here
9945      because it's used by add_pending_template.  */
9946   else if (! pattern_defined || defer_ok)
9947     {
9948       lineno = line;
9949       input_filename = file;
9950
9951       if (at_eof && !pattern_defined
9952           && DECL_EXPLICIT_INSTANTIATION (d))
9953         /* [temp.explicit]
9954
9955            The definition of a non-exported function template, a
9956            non-exported member function template, or a non-exported
9957            member function or static data member of a class template
9958            shall be present in every translation unit in which it is
9959            explicitly instantiated.  */
9960         cp_error ("explicit instantiation of `%D' but no definition available",
9961                   d);
9962
9963       add_pending_template (d);
9964       goto out;
9965     }
9966
9967   need_push = !global_bindings_p ();
9968   if (need_push)
9969     push_to_top_level ();
9970
9971   /* We're now committed to instantiating this template.  Mark it as
9972      instantiated so that recursive calls to instantiate_decl do not
9973      try to instantiate it again.  */
9974   DECL_TEMPLATE_INSTANTIATED (d) = 1;
9975
9976   /* Regenerate the declaration in case the template has been modified
9977      by a subsequent redeclaration.  */
9978   regenerate_decl_from_template (d, td);
9979
9980   /* We already set the file and line above.  Reset them now in case
9981      they changed as a result of calling regenerate_decl_from_template.  */
9982   lineno = DECL_SOURCE_LINE (d);
9983   input_filename = DECL_SOURCE_FILE (d);
9984
9985   if (TREE_CODE (d) == VAR_DECL)
9986     {
9987       DECL_IN_AGGR_P (d) = 0;
9988       if (DECL_INTERFACE_KNOWN (d))
9989         DECL_EXTERNAL (d) = ! DECL_NOT_REALLY_EXTERN (d);
9990       else
9991         {
9992           DECL_EXTERNAL (d) = 1;
9993           DECL_NOT_REALLY_EXTERN (d) = 1;
9994         }
9995       cp_finish_decl (d, DECL_INITIAL (d), NULL_TREE, 0);
9996     }
9997   else if (TREE_CODE (d) == FUNCTION_DECL)
9998     {
9999       htab_t saved_local_specializations;
10000
10001       /* Save away the current list, in case we are instantiating one
10002          template from within the body of another.  */
10003       saved_local_specializations = local_specializations;
10004
10005       /* Set up the list of local specializations.  */
10006       local_specializations = htab_create (37,
10007                                            htab_hash_pointer,
10008                                            htab_eq_pointer,
10009                                            NULL);
10010
10011       /* Set up context.  */
10012       start_function (NULL_TREE, d, NULL_TREE, SF_PRE_PARSED);
10013
10014       /* We already set up __FUNCTION__, etc., so we don't want to do
10015          it again now.  */
10016       function_name_declared_p = 1;
10017
10018       /* Substitute into the body of the function.  */
10019       tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
10020                    /*complain=*/1, tmpl);
10021
10022       /* We don't need the local specializations any more.  */
10023       htab_delete (local_specializations);
10024       local_specializations = saved_local_specializations;
10025
10026       /* Finish the function.  */
10027       expand_body (finish_function (0));
10028     }
10029
10030   /* We're not deferring instantiation any more.  */
10031   TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
10032
10033   if (need_push)
10034     pop_from_top_level ();
10035
10036 out:
10037   lineno = line;
10038   input_filename = file;
10039
10040   pop_tinst_level ();
10041
10042   timevar_pop (TV_PARSE);
10043
10044   return d;
10045 }
10046
10047 /* Run through the list of templates that we wish we could
10048    instantiate, and instantiate any we can.  */
10049
10050 int
10051 instantiate_pending_templates ()
10052 {
10053   tree *t;
10054   int instantiated_something = 0;
10055   int reconsider;
10056
10057   do
10058     {
10059       reconsider = 0;
10060
10061       t = &pending_templates;
10062       while (*t)
10063         {
10064           tree instantiation = TREE_VALUE (*t);
10065
10066           reopen_tinst_level (TREE_PURPOSE (*t));
10067
10068           if (TYPE_P (instantiation))
10069             {
10070               tree fn;
10071
10072               if (!COMPLETE_TYPE_P (instantiation))
10073                 {
10074                   instantiate_class_template (instantiation);
10075                   if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
10076                     for (fn = TYPE_METHODS (instantiation);
10077                          fn;
10078                          fn = TREE_CHAIN (fn))
10079                       if (! DECL_ARTIFICIAL (fn))
10080                         instantiate_decl (fn, /*defer_ok=*/0);
10081                   if (COMPLETE_TYPE_P (instantiation))
10082                     {
10083                       instantiated_something = 1;
10084                       reconsider = 1;
10085                     }
10086                 }
10087
10088               if (COMPLETE_TYPE_P (instantiation))
10089                 /* If INSTANTIATION has been instantiated, then we don't
10090                    need to consider it again in the future.  */
10091                 *t = TREE_CHAIN (*t);
10092               else
10093                 t = &TREE_CHAIN (*t);
10094             }
10095           else
10096             {
10097               if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
10098                   && !DECL_TEMPLATE_INSTANTIATED (instantiation))
10099                 {
10100                   instantiation = instantiate_decl (instantiation,
10101                                                     /*defer_ok=*/0);
10102                   if (DECL_TEMPLATE_INSTANTIATED (instantiation))
10103                     {
10104                       instantiated_something = 1;
10105                       reconsider = 1;
10106                     }
10107                 }
10108
10109               if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
10110                   || DECL_TEMPLATE_INSTANTIATED (instantiation))
10111                 /* If INSTANTIATION has been instantiated, then we don't
10112                    need to consider it again in the future.  */
10113                 *t = TREE_CHAIN (*t);
10114               else
10115                 t = &TREE_CHAIN (*t);
10116             }
10117           tinst_depth = 0;
10118           current_tinst_level = NULL_TREE;
10119         }
10120       template_tail = t;
10121
10122       /* Go through the things that are template instantiations if we are
10123          using guiding declarations.  */
10124       t = &maybe_templates;
10125       while (*t)
10126         {
10127           tree template;
10128           tree fn;
10129           tree args;
10130
10131           fn = TREE_VALUE (*t);
10132
10133           if (DECL_INITIAL (fn))
10134             /* If the FN is already defined, then it was either already
10135                instantiated or, even though guiding declarations were
10136                allowed, a non-template definition was provided.  */
10137             ;
10138           else
10139             {
10140               template = TREE_PURPOSE (*t);
10141               args = get_bindings (template, fn, NULL_TREE);
10142               fn = instantiate_template (template, args);
10143               instantiate_decl (fn, /*defer_ok=*/0);
10144               reconsider = 1;
10145             }
10146
10147           /* Remove this entry from the chain.  */
10148           *t = TREE_CHAIN (*t);
10149         }
10150       maybe_template_tail = t;
10151     }
10152   while (reconsider);
10153
10154   return instantiated_something;
10155 }
10156
10157 /* Substitute ARGVEC into T, which is a list of initializers for
10158    either base class or a non-static data member.  The TREE_PURPOSEs
10159    are DECLs, and the TREE_VALUEs are the initializer values.  Used by
10160    instantiate_decl.  */
10161
10162 static tree
10163 tsubst_initializer_list (t, argvec)
10164      tree t, argvec;
10165 {
10166   tree first = NULL_TREE;
10167   tree *p = &first;
10168
10169   for (; t; t = TREE_CHAIN (t))
10170     {
10171       tree decl;
10172       tree init;
10173       tree val;
10174
10175       decl = tsubst_copy (TREE_PURPOSE (t), argvec, /*complain=*/1,
10176                           NULL_TREE);
10177       init = tsubst_expr (TREE_VALUE (t), argvec, /*complain=*/1,
10178                           NULL_TREE);
10179
10180       if (!init)
10181         ;
10182       else if (TREE_CODE (init) == TREE_LIST)
10183         for (val = init; val; val = TREE_CHAIN (val))
10184           TREE_VALUE (val) = convert_from_reference (TREE_VALUE (val));
10185       else
10186         init = convert_from_reference (init);
10187
10188       *p = build_tree_list (decl, init);
10189       p = &TREE_CHAIN (*p);
10190     }
10191   return first;
10192 }
10193
10194 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL.  */
10195
10196 static void
10197 set_current_access_from_decl (decl)
10198      tree decl;
10199 {
10200   if (TREE_PRIVATE (decl))
10201     current_access_specifier = access_private_node;
10202   else if (TREE_PROTECTED (decl))
10203     current_access_specifier = access_protected_node;
10204   else
10205     current_access_specifier = access_public_node;
10206 }
10207
10208 /* Instantiate an enumerated type.  TAG is the template type, NEWTAG
10209    is the instantiation (which should have been created with
10210    start_enum) and ARGS are the template arguments to use.  */
10211
10212 static void
10213 tsubst_enum (tag, newtag, args)
10214      tree tag;
10215      tree newtag;
10216      tree args;
10217 {
10218   tree e;
10219
10220   for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
10221     {
10222       tree value;
10223
10224       /* Note that in a template enum, the TREE_VALUE is the
10225          CONST_DECL, not the corresponding INTEGER_CST.  */
10226       value = tsubst_expr (DECL_INITIAL (TREE_VALUE (e)),
10227                            args, /*complain=*/1,
10228                            NULL_TREE);
10229
10230       /* Give this enumeration constant the correct access.  */
10231       set_current_access_from_decl (TREE_VALUE (e));
10232
10233       /* Actually build the enumerator itself.  */
10234       build_enumerator (TREE_PURPOSE (e), value, newtag);
10235     }
10236
10237   finish_enum (newtag);
10238   DECL_SOURCE_LINE (TYPE_NAME (newtag)) = DECL_SOURCE_LINE (TYPE_NAME (tag));
10239   DECL_SOURCE_FILE (TYPE_NAME (newtag)) = DECL_SOURCE_FILE (TYPE_NAME (tag));
10240 }
10241
10242 /* DECL is a FUNCTION_DECL that is a template specialization.  Return
10243    its type -- but without substituting the innermost set of template
10244    arguments.  So, innermost set of template parameters will appear in
10245    the type.  If CONTEXTP is non-NULL, then the partially substituted
10246    DECL_CONTEXT (if any) will also be filled in.  Similarly, TPARMSP
10247    will be filled in with the substituted template parameters, if it
10248    is non-NULL.  */
10249
10250 tree
10251 get_mostly_instantiated_function_type (decl, contextp, tparmsp)
10252      tree decl;
10253      tree *contextp;
10254      tree *tparmsp;
10255 {
10256   tree context = NULL_TREE;
10257   tree fn_type;
10258   tree tmpl;
10259   tree targs;
10260   tree tparms;
10261   int parm_depth;
10262
10263   tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
10264   targs = DECL_TI_ARGS (decl);
10265   tparms = DECL_TEMPLATE_PARMS (tmpl);
10266   parm_depth = TMPL_PARMS_DEPTH (tparms);
10267
10268   /* There should be as many levels of arguments as there are levels
10269      of parameters.  */
10270   my_friendly_assert (parm_depth == TMPL_ARGS_DEPTH (targs), 0);
10271
10272   fn_type = TREE_TYPE (tmpl);
10273   if (DECL_STATIC_FUNCTION_P (decl))
10274     context = DECL_CONTEXT (decl);
10275
10276   if (parm_depth == 1)
10277     /* No substitution is necessary.  */
10278     ;
10279   else
10280     {
10281       int i;
10282       tree partial_args;
10283
10284       /* Replace the innermost level of the TARGS with NULL_TREEs to
10285          let tsubst know not to substitute for those parameters.  */
10286       partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
10287       for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
10288         SET_TMPL_ARGS_LEVEL (partial_args, i,
10289                              TMPL_ARGS_LEVEL (targs, i));
10290       SET_TMPL_ARGS_LEVEL (partial_args,
10291                            TMPL_ARGS_DEPTH (targs),
10292                            make_tree_vec (DECL_NTPARMS (tmpl)));
10293
10294       /* Now, do the (partial) substitution to figure out the
10295          appropriate function type.  */
10296       fn_type = tsubst (fn_type, partial_args, /*complain=*/1, NULL_TREE);
10297       if (DECL_STATIC_FUNCTION_P (decl))
10298         context = tsubst (context, partial_args, /*complain=*/1, NULL_TREE);
10299
10300       /* Substitute into the template parameters to obtain the real
10301          innermost set of parameters.  This step is important if the
10302          innermost set of template parameters contains value
10303          parameters whose types depend on outer template parameters.  */
10304       TREE_VEC_LENGTH (partial_args)--;
10305       tparms = tsubst_template_parms (tparms, partial_args, /*complain=*/1);
10306     }
10307
10308   if (contextp)
10309     *contextp = context;
10310   if (tparmsp)
10311     *tparmsp = tparms;
10312
10313   return fn_type;
10314 }
10315
10316 /* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that
10317    is either an instantiation or specialization of a template
10318    function.  */
10319
10320 static void
10321 set_mangled_name_for_template_decl (decl)
10322      tree decl;
10323 {
10324   tree context = NULL_TREE;
10325   tree fn_type;
10326   tree ret_type;
10327   tree parm_types;
10328   tree tparms;
10329   tree targs;
10330
10331   my_friendly_assert (TREE_CODE (decl) == FUNCTION_DECL, 0);
10332   my_friendly_assert (DECL_TEMPLATE_INFO (decl) != NULL_TREE, 0);
10333
10334   /* Under the new ABI, we don't need special machinery.  */
10335   if (flag_new_abi)
10336     {
10337       set_mangled_name_for_decl (decl);
10338       return;
10339     }
10340
10341   /* The names of template functions must be mangled so as to indicate
10342      what template is being specialized with what template arguments.
10343      For example, each of the following three functions must get
10344      different mangled names:
10345
10346        void f(int);
10347        template <> void f<7>(int);
10348        template <> void f<8>(int);  */
10349
10350   targs = DECL_TI_ARGS (decl);
10351   if (uses_template_parms (targs))
10352     /* This DECL is for a partial instantiation.  There's no need to
10353        mangle the name of such an entity.  */
10354     return;
10355
10356   /* We now compute the PARMS and RET_TYPE to give to
10357      build_decl_overload_real.  The PARMS and RET_TYPE are the
10358      parameter and return types of the template, after all but the
10359      innermost template arguments have been substituted, not the
10360      parameter and return types of the function DECL.  For example,
10361      given:
10362
10363        template <class T> T f(T);
10364
10365      both PARMS and RET_TYPE should be `T' even if DECL is `int f(int)'.
10366      A more subtle example is:
10367
10368        template <class T> struct S { template <class U> void f(T, U); }
10369
10370      Here, if DECL is `void S<int>::f(int, double)', PARMS should be
10371      {int, U}.  Thus, the args that we want to subsitute into the
10372      return and parameter type for the function are those in TARGS,
10373      with the innermost level omitted.  */
10374   fn_type = get_mostly_instantiated_function_type (decl, &context, &tparms);
10375
10376   /* Now, get the innermost parameters and arguments, and figure out
10377      the parameter and return types.  */
10378   tparms = INNERMOST_TEMPLATE_PARMS (tparms);
10379   targs = INNERMOST_TEMPLATE_ARGS (targs);
10380   ret_type = TREE_TYPE (fn_type);
10381   parm_types = TYPE_ARG_TYPES (fn_type);
10382
10383   /* For a static member function, we generate a fake `this' pointer,
10384      for the purposes of mangling.  This indicates of which class the
10385      function is a member.  Because of:
10386
10387        [class.static]
10388
10389        There shall not be a static and a nonstatic member function
10390        with the same name and the same parameter types
10391
10392      we don't have to worry that this will result in a clash with a
10393      non-static member function.  */
10394   if (DECL_STATIC_FUNCTION_P (decl))
10395     parm_types = hash_tree_chain (build_pointer_type (context), parm_types);
10396
10397   /* There should be the same number of template parameters as
10398      template arguments.  */
10399   my_friendly_assert (TREE_VEC_LENGTH (tparms) == TREE_VEC_LENGTH (targs),
10400                       0);
10401
10402   /* Actually set the DECL_ASSEMBLER_NAME.  */
10403   DECL_ASSEMBLER_NAME (decl)
10404     = build_decl_overload_real (decl, parm_types, ret_type,
10405                                 tparms, targs,
10406                                 DECL_FUNCTION_MEMBER_P (decl)
10407                                 + DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl));
10408 }
10409
10410 /* Return truthvalue if we're processing a template different from
10411    the last one involved in diagnostics.  */
10412 int
10413 problematic_instantiation_changed ()
10414 {
10415   return last_template_error_tick != tinst_level_tick;
10416 }
10417
10418 /* Remember current template involved in diagnostics.  */
10419 void
10420 record_last_problematic_instantiation ()
10421 {
10422   last_template_error_tick = tinst_level_tick;
10423 }
10424
10425 tree
10426 current_instantiation ()
10427 {
10428   return current_tinst_level;
10429 }
10430
10431 /* [temp.param] Check that template non-type parm TYPE is of an allowable
10432    type. Return zero for ok, non-zero for disallowed. If COMPLAIN is
10433    non-zero, then complain. */
10434
10435 static int
10436 invalid_nontype_parm_type_p (type, complain)
10437      tree type;
10438      int complain;
10439 {
10440   if (INTEGRAL_TYPE_P (type))
10441     return 0;
10442   else if (POINTER_TYPE_P (type))
10443     return 0;
10444   else if (TYPE_PTRMEM_P (type))
10445     return 0;
10446   else if (TYPE_PTRMEMFUNC_P (type))
10447     return 0;
10448   else if (!pedantic && TREE_CODE (type) == REAL_TYPE)
10449     return 0; /* GNU extension */
10450   else if (!pedantic && TREE_CODE (type) == COMPLEX_TYPE)
10451     return 0; /* GNU extension */
10452   else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10453     return 0;
10454   else if (TREE_CODE (type) == TYPENAME_TYPE)
10455     return 0;
10456
10457   if (complain)
10458     cp_error ("`%#T' is not a valid type for a template constant parameter",
10459               type);
10460   return 1;
10461 }