gcc/cp/pt.c

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