Studying note of GCC-3.4.6 source (124)

5.12.4.2.2.2.3.          Finish template-id

If template-name is an IDENTIFER_NODE, it maybe a member template; and if it is a TEMPLATE_DECL of class template, the template-id itself is a class-name; and if it is FUNCTION_DECL, OVERLOAD or METHOD_DECL, the template-id is a function-name.

So if template-name is a class template, the template-id may name a new class, for which case we should create corresponding class type by finish_template_type . It is a very complex procedure, later section will give an example to go through the function.

 

cp_parser_template_id (continue)

 

7991   /* Build a representation of the specialization.  */

7992   if (TREE_CODE (template) == IDENTIFIER_NODE)

7993     template_id = build_min_nt (TEMPLATE_ID_EXPR, template, arguments);

7994   else if (DECL_CLASS_TEMPLATE_P (template)

7995         || DECL_TEMPLATE_TEMPLATE_PARM_P (template))

7996     template_id

7997       = finish_template_type (template, arguments,

7998                           cp_lexer_next_token_is (parser->lexer,

7999                                               CPP_SCOPE));

8000   else

8001   {

8002     /* If it's not a class-template or a template-template, it should be

8003       a function-template.  */

8004     my_friendly_assert ((DECL_FUNCTION_TEMPLATE_P (template)

8005                      || TREE_CODE (template) == OVERLOAD

8006                      || BASELINK_P (template)),

8007                       20010716);

8008      

8009     template_id = lookup_template_function (template, arguments);

8010   }

8011  

8012   /* Retrieve any deferred checks. Do not pop this access checks yet

8013     so the memory will not be reclaimed during token replacing below.  */

8014   access_check = get_deferred_access_checks ();

 

If template-name is an IDNETIFIER_NODE, the resulting TEMPLATE_ID_EXPR is built by build_min_nt . The function builds a tree node of tree_exp.

 

4069 tree

4070 build_min_nt (enum tree_code code, ...)                                                            in tree.c

4071 {

4072    tree t;

4073    int length;

4074    int i;

4075    va_list p;

4076

4077    va_start (p, code);

4078

4079    t = make_node (code);

4080    length = TREE_CODE_LENGTH (code);

4081    TREE_COMPLEXITY (t) = input_line;

4082

4083    for (i = 0; i < length; i++)

4084    {

4085      tree x = va_arg (p, tree);

4086      TREE_OPERAND (t, i) = x;

4087    }

4088

4089    va_end (p);

4090    return t;

4091 }

 

If the template-name names a function template, the TEMPLATE_ID_EXPR node is created by lookup_template_function . A BASELINK node is a reference to a member function or member functions from a base class. Note that in this case in the TEMPLATE_ID_EXPR generated, its type is unknonw_type_node , which will force the front-end to invoke instantiate_type later to resolve its type.

 

4069 tree

4070 lookup_template_function (tree fns, tree arglist)                                                  in pt.c

4071 {

4072    tree type;

4073

4074    if (fns == error_mark_node || arglist == error_mark_node)

4075      return error_mark_node;

4076

4077    my_friendly_assert (!arglist || TREE_CODE (arglist) == TREE_VEC, 20030726);

4078    my_friendly_assert (fns && (is_overloaded_fn (fns)

4079                            || TREE_CODE (fns) == IDENTIFIER_NODE),

4080                    20050608);

4081

4082    if (BASELINK_P (fns))

4083    {

4084      BASELINK_FUNCTIONS (fns) = build (TEMPLATE_ID_EXPR,

4085                                         unknown_type_node,

4086                                        BASELINK_FUNCTIONS (fns),

4087                                        arglist);

4088      return fns;

4089    }

4090

4091    type = TREE_TYPE (fns);

4092    if (TREE_CODE (fns) == OVERLOAD || !type)

4093      type = unknown_type_node;

4094   

4095    return build (TEMPLATE_ID_EXPR, type, fns, arglist);

4096 }

 

Then corresponding tokens are grouped as CPP_TEMPLATE_ID; similarly there is another group - NESTED_NAME_SPECFIER.

 

cp_parser_template_id (continue)

 

8016    /* If parsing tentatively, replace the sequence of tokens that makes

8017      up the template-id with a CPP_TEMPLATE_ID token. That way,

8018      should we re-parse the token stream, we will not have to repeat

8019      the effort required to do the parse, nor will we issue duplicate

8020      error messages about problems during instantiation of the

8021      template.  */

8022    if (start_of_id >= 0)

8023    {

8024      cp_token *token;

8025

8026      /* Find the token that corresponds to the start of the

8027        template-id.  */

8028      token = cp_lexer_advance_token (parser->lexer,

8029                                  parser->lexer->first_token,

8030                                  start_of_id);

8031

8032      /* Reset the contents of the START_OF_ID token.  */

8033      token->type = CPP_TEMPLATE_ID;

8034      token->value = build_tree_list (access_check, template_id);

8035      token->keyword = RID_MAX;

8036      /* Purge all subsequent tokens.  */

8037      cp_lexer_purge_tokens_after (parser->lexer, token);

8038

8039      /* ??? Can we actually assume that, if template_id ==

8040        error_mark_node, we will have issued a diagnostic to the

8041        user, as opposed to simply marking the tentative parse as

8042        failed?  */

8043      if (cp_parser_error_occurred (parser) && template_id != error_mark_node)

8044        error ("parse error in template argument list");

8045    }

8046

8047    pop_deferring_access_checks ();

8048    return template_id;

8049 }

5.12.4.2.2.3.  Finish lookup class name

When get decl for the identifier , as indicated by the grammar, it must be an identifier or template-id. If argument typename_p is true, it means keyword typename has been seen. So invoke make_typename_type to resolve “typename CONTEXT::NAME" and return appropriate type.

 

cp_parser_class_name (continue)

 

11812    decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p);

11813

11814     /* If this is a typename, create a TYPENAME_TYPE.  */

11815    if (typename_p && decl != error_mark_node)

11816    {

11817      decl = make_typename_type (scope, decl, /*complain=* /1);

11818      if (decl != error_mark_node)

11819        decl = TYPE_NAME (decl);

11820    }

11821

11822    /* Check to see that it is really the name of a class.  */

11823    if (TREE_CODE (decl) == TEMPLATE_ID_EXPR

11824        && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE

11825        && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))

11826        /* Situations like this:

11827

11828           template <typename T> struct A {

11829               typename T::template X<int>::I i;

11830           };

11831

11832           are problematic. Is `T::template X<int>' a class-name? The

11833           standard does not seem to be definitive, but there is no other

11834            valid interpretation of the following `::'. Therefore, those

11835           names are considered class-names.  */

11836      decl = TYPE_NAME (make_typename_type (scope, decl, tf_error));

11837    else if (decl == error_mark_node

11838          || TREE_CODE (decl) != TYPE_DECL

11839           || !IS_AGGR_TYPE (TREE_TYPE (decl)))

11840    {

11841      cp_parser_error (parser, "expected class-name");

11842      return error_mark_node;

11843    }

11844

11845    return decl;

11846 }

 

Refer to maybe_get_template_decl_from_type_decl that invoked in cp_parser_template_id , it can better understand cp_parser_maybe_treat_template_as_class . Argument tag_name_p if true, decl indicates the class being defined in a class-head, or declared in an elaborated-type-specifier.

 

13901 static tree

13902 cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p)              in parser.c

13903 {

13904   /* If the TEMPLATE_DECL is being declared as part of a class-head,

13905     the translation from TEMPLATE_DECL to TYPE_DECL occurs:

13906

13907        struct A {

13908          template <typename T> struct B;

13909        };

13910

13911        template <typename T> struct A::B {};

13912   

13913     Similarly, in a elaborated-type-specifier:

13914

13915        namespace N { struct X{}; }

13916

13917        struct A {

13918          template <typename T> friend struct N::X;

13919        };

13920

13921     However, if the DECL refers to a class type, and we are in

13922     the scope of the class, then the name lookup automatically

13923     finds the TYPE_DECL created by build_self_reference rather

13924     than a TEMPLATE_DECL. For example, in:

13925

13926        template <class T> struct S {

13927          S s;

13928        };

13929

13930     there is no need to handle such case.  */

13931

13932   if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p)

13933     return DECL_TEMPLATE_RESULT (decl);

13934

13935   return decl;

13936 }

 

The effect of the routine is if decl is a TEMPLATE_DECL that can be treated like a TYPE_DECL in the current context, returns the TYPE_DECL.

Below if name is a template class (by CLASSTYPE_IS_TEMPLATE) or a template instantiation or specialization (by CLASSTYPE_USE_TEMPLATE), a TMEPLATE_ID_EXPR is built. Its processing involves lookup_template_class which is a complex function and we will see it later with example.

 

2608 tree

2609 make_typename_type (tree context, tree name, tsubst_flags_t complain)               in decl.c

2610 {

2611    tree fullname;

2612

2613    if (name == error_mark_node

2614        || context == NULL_TREE

2615        || context == error_mark_node)

2616      return error_mark_node;

2617

2618    if (TYPE_P (name))

2619    {

2620      if (!(TYPE_LANG_SPECIFIC (name)

2621          && (CLASSTYPE_IS_TEMPLATE (name)

2622              || CLASSTYPE_USE_TEMPLATE (name))))

2623         name = TYPE_IDENTIFIER (name);

2624      else

2625         /* Create a TEMPLATE_ID_EXPR for the type.  */

2626         name = build_nt (TEMPLATE_ID_EXPR,

2627                       CLASSTYPE_TI_TEMPLATE (name),

2628                        CLASSTYPE_TI_ARGS (name));

2629    }

2630    else if (TREE_CODE (name) == TYPE_DECL)

2631      name = DECL_NAME (name);

2632

2633    fullname = name;

2634

2635    if (TREE_CODE (name) == TEMPLATE_ID_EXPR)

2636    {

2637      name = TREE_OPERAND (name, 0);

2638      if (TREE_CODE (name) == TEMPLATE_DECL)

2639         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);

2640    }

2641    if (TREE_CODE (name) == TEMPLATE_DECL)

2642    {

2643      error ("`%D' used without template parameters", name);

2644      return error_mark_node;

2645    }

2646    my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 20030802);

2647    my_friendly_assert (TYPE_P (context), 20050905);

2648

2649    if (!dependent_type_p (context)

2650         || currently_open_class (context))

2651    {

2652      if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)

2653      {

2654          tree tmpl = NULL_TREE;

2655        if (IS_AGGR_TYPE (context))

2656            tmpl = lookup_field (context, name, 0, false);

2657        if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))

2658        {

2659          if (complain & tf_error)

2660             error ("no class template named `%#T' in `%#T'",

2661                  name, context);

2662          return error_mark_node;

2663        }

2664

2665        if (complain & tf_error)

2666            perform_or_defer_access_check (TYPE_BINFO (context), tmpl);

2667

2668        return lookup_template_class (tmpl,

2669                                  TREE_OPERAND (fullname, 1),

2670                                  NULL_TREE, context,

2671                                  /*entering_scope=*/ 0,

2672                                 tf_error | tf_warning | tf_user);

2673      }

2674      else

2675      {

2676        tree t;

2677

2678         if (!IS_AGGR_TYPE (context))

2679         {

2680           if (complain & tf_error)

2681            error ("no type named `%#T' in `%#T'", name, context);

2682            return error_mark_node;

2683         }

2684

2685         t = lookup_field (context, name, 0, true);

2686         if (t)

2687         {

2688           if (TREE_CODE (t) != TYPE_DECL)

2689          {

2690             if (complain & tf_error)

2691               error ("no type named `%#T' in `%#T'", name, context);

2692             return error_mark_node;

2693          }

2694

2695           if (complain & tf_error)

2696            perform_or_defer_access_check (TYPE_BINFO (context), t);

2697

2698           if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))

2699            t = TREE_TYPE (t);

2700      

2701          return t;

2702         }

2703      }

2704    }

2705

2706    /* If the CONTEXT is not a template type, then either the field is

2707      there now or its never going to be.  */

2708    if (!dependent_type_p (context))

2709    {

2710      if (complain & tf_error)

2711        error ("no type named `%#T' in `%#T'", name, context);

2712      return error_mark_node;

2713    }

2714

2715    return build_typename_type (context, name, fullname);

2716 }

 

And for expression “typename CONTEXT::NAME”, if CONTEXT is non-dependent, or is currently opened class, NAME is first looked up within the class by lookup_field .

 

1372 tree

1373 lookup_field (tree xbasetype, tree name, int protect, bool want_type)             in search.c

1374 {

1375    tree rval = lookup_member (xbasetype, name, protect, want_type);

1376   

1377    /* Ignore functions.  */

1378    if (rval && BASELINK_P (rval))

1379      return NULL_TREE;

1380

1381    return rval;

1382 }

 

See that argument want_type in invocation at line 2656 is false for template-id; and invocation at line 2685 is true for normal type. And want_type is true, indicates we only accept TYPE_DECL.

If nothing found and the scope is dependent, it must build a placeholder for the type. It is the node of TYPENAME_TYPE .

 

2566 static tree

2567 build_typename_type (tree context, tree name, tree fullname)                        in decl.c

2568 {

2569    tree t;

2570    tree d;

2571    void **e;

2572

2573    if (typename_htab == NULL)

2574    {

2575      typename_htab = htab_create_ggc (61, &typename_hash,

2576                                    &typename_compare, NULL);

2577    }

2578

2579    /* Build the TYPENAME_TYPE.  */

2580    t = make_aggr_type (TYPENAME_TYPE);

2581    TYPE_CONTEXT (t) = FROB_CONTEXT (context);

2582    TYPENAME_TYPE_FULLNAME (t) = fullname;

2583

2584    /* Build the corresponding TYPE_DECL.  */

2585    d = build_decl (TYPE_DECL, name, t);

2586    TYPE_NAME (TREE_TYPE (d)) = d;

2587    TYPE_STUB_DECL (TREE_TYPE (d)) = d;

2588    DECL_CONTEXT (d) = FROB_CONTEXT (context);

2589    DECL_ARTIFICIAL (d) = 1;

2590

2591    /* See if we already have this type.  */

2592    e = htab_find_slot (typename_htab , t, INSERT);

2593    if (*e)

2594      t = (tree) *e;

2595    else

2596      *e = t;

2597

2598    return t;

2599 }

 

Node of TYPENAME_TYPE represents structure “typename T::t”. In the node, its TYPE_CONTEXT is `T', TYPE_NAME is an IDENTIFIER_NODE for `t'. If the type was named via template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.

Note that handling “typename T::t” here, ‘T’ has been resolved in previous step, it may be a template or template parameter, and with a subtree already built. So in fact “typename T::t” under different context ‘T’ stands for different structure. To ensure unique instance of such structure within the translation-unit, these nodes are stored within the hashtable of typename_htab .