From patchwork Wed Oct 6 18:52:43 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dodji Seketeli X-Patchwork-Id: 66961 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 774BCB70DE for ; Thu, 7 Oct 2010 05:53:16 +1100 (EST) Received: (qmail 23116 invoked by alias); 6 Oct 2010 18:53:13 -0000 Received: (qmail 23081 invoked by uid 22791); 6 Oct 2010 18:52:59 -0000 X-SWARE-Spam-Status: No, hits=-5.3 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_HI, SPF_HELO_PASS, TW_CX, TW_RG, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 06 Oct 2010 18:52:49 +0000 Received: from int-mx08.intmail.prod.int.phx2.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id o96IqmJh002765 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Wed, 6 Oct 2010 14:52:48 -0400 Received: from adjoa.redhat.com (ovpn-113-77.phx2.redhat.com [10.3.113.77]) by int-mx08.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id o96IqjEv016020; Wed, 6 Oct 2010 14:52:47 -0400 From: Dodji Seketeli To: Jason Merrill Cc: "H.J. Lu" , Paolo Carlini , GCC Patches Subject: Re: Require canonical type comparison for typedefs again. References: <4C630F87.9060303@redhat.com> <4C640257.4080804@redhat.com> <4C9673B7.5010505@oracle.com> <4C97C9E5.2090907@redhat.com> <4C9E863C.30208@redhat.com> <4CA1F184.4080708@redhat.com> <4CA397D0.3000100@redhat.com> X-URL: http://www.seketeli.net/~dodji Date: Wed, 06 Oct 2010 20:52:43 +0200 In-Reply-To: <4CA397D0.3000100@redhat.com> (Jason Merrill's message of "Wed, 29 Sep 2010 15:47:28 -0400") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.2 (gnu/linux) MIME-Version: 1.0 X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Hello, Following your comments here is a new version of the patch. The main changes are the following: * the list of template parms is walked only once for the fixup. * following our discussion offline I moved the sibbling parms number moved to TEMPLATE_PARM_INDEX. I created a new field in struct template_parm_index_s for that because I couldn't find another free slot. Maybe you'd have an idea to avoid adding this field here. * to substitute fixed-up template type parameters into parameters of template template parameters, I tried hard to build the full set of template parameters to avoid triggering partial instantiation. E,g: template //#0 struct S { template class TPL> void foo(T t); // #1<-- here }; When substituting the fixed up T of #0 into the a parameter in #1, I use the following set of template parms as argument to tsubst: {{T}, {TPL}, {U, T}}. This is similar to what is done in lookup_template_class when the D1 parameter of that function is a template template parm. This way I could do away with the tf_no_tpl_reduce flag I introduced in the previous version of the patch. * when fixing up a template type parms T, make sure subsequent name lookups of T return the fixed up T. Not the pre-fixup one. That basically means that I set the TREE_TYPE of of the TYPE_NAME of the pre-fixup T to the fixedup T. I do a similar trick for non-type template parms too. E,g, consider this: template //#0 auto foo(T t) -> decltype(u); //#1 After fixup, I want lookups of u at #1 to return references to the fixedup T, not to the pre-fixup one. * canonical_type_parameter doesn't return NULL_TREE anymore. Tested on x86_64-unknown-linux-gnu against trunk. diff --git a/gcc/cp/class.c b/gcc/cp/class.c index b093ce0..1c4e368 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -6671,7 +6671,7 @@ build_self_reference (void) DECL_CONTEXT (value) = current_class_type; DECL_ARTIFICIAL (value) = 1; SET_DECL_SELF_REFERENCE_P (value); - cp_set_underlying_type (value); + set_underlying_type (value); if (processing_template_decl) value = push_template_decl (value); diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index aa1fe4d..0703a89 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -236,6 +236,7 @@ struct GTY(()) template_parm_index_s { int index; int level; int orig_level; + int num_siblings; tree decl; }; typedef struct template_parm_index_s template_parm_index; @@ -4300,6 +4301,9 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, TYPENAME_FLAG }; ((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE)) #define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index) #define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level) +/* The Number of sibling parms this template parm has. */ +#define TEMPLATE_PARM_NUM_SIBLINGS(NODE) \ + (TEMPLATE_PARM_INDEX_CAST (NODE)->num_siblings) #define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE)) #define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level) #define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl) @@ -4321,10 +4325,6 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, TYPENAME_FLAG }; (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE))) #define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \ (TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE))) -/* The list of template parms that a given template parameter of type - TEMPLATE_TYPE_PARM belongs to.*/ -#define TEMPLATE_TYPE_PARM_SIBLING_PARMS(NODE) \ - (TREE_CHECK ((NODE), TEMPLATE_TYPE_PARM))->type.maxval /* These constants can used as bit flags in the process of tree formatting. @@ -5005,7 +5005,7 @@ extern void append_type_to_template_for_access_check (tree, tree, tree, extern tree splice_late_return_type (tree, tree); extern bool is_auto (const_tree); extern tree process_template_parm (tree, location_t, tree, - bool, bool); + bool, bool, unsigned); extern tree end_template_parm_list (tree); extern void end_template_decl (void); extern tree maybe_update_decl_type (tree, tree); @@ -5091,6 +5091,8 @@ extern tree get_template_innermost_arguments (const_tree); extern tree get_template_argument_pack_elems (const_tree); extern tree get_function_template_decl (const_tree); extern tree resolve_nondeduced_context (tree); +extern int get_template_parms_num_siblings (tree); +extern void set_template_parms_num_siblings (tree, int); /* in repo.c */ extern void init_repo (void); @@ -5341,7 +5343,6 @@ extern bool type_has_nontrivial_copy_init (const_tree); extern bool class_tmpl_impl_spec_p (const_tree); extern int zero_init_p (const_tree); extern tree strip_typedefs (tree); -extern void cp_set_underlying_type (tree); extern tree copy_binfo (tree, tree, tree, tree *, int); extern int member_p (const_tree); diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index fcc83fb..3ba2a28 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -879,7 +879,7 @@ grokfield (const cp_declarator *declarator, if (declspecs->specs[(int)ds_typedef] && TREE_TYPE (value) != error_mark_node && TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value) - cp_set_underlying_type (value); + set_underlying_type (value); return value; } diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c index e980cb6..5889adc 100644 --- a/gcc/cp/name-lookup.c +++ b/gcc/cp/name-lookup.c @@ -872,7 +872,7 @@ pushdecl_maybe_friend (tree x, bool is_friend) inlining. */ && (!TYPE_NAME (type) || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))) - cp_set_underlying_type (x); + set_underlying_type (x); if (type != error_mark_node && TYPE_NAME (type) diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 82026b1..240d546 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -11011,6 +11011,13 @@ cp_parser_template_parameter_list (cp_parser* parser) tree parameter_list = NULL_TREE; begin_template_parm_list (); + + /* The loop below parses the template parms. We first need to know + the total number of template parms to be able to compute proper + canonical types of each dependent type. So after the loop, when + we know the total number of template parms, + end_template_parm_list computes the proper canonical types and + fixes up the dependent types accordingly. */ while (true) { tree parameter; @@ -11029,11 +11036,11 @@ cp_parser_template_parameter_list (cp_parser* parser) parm_loc, parameter, is_non_type, - is_parameter_pack); + is_parameter_pack, + 0); else { tree err_parm = build_tree_list (parameter, parameter); - TREE_VALUE (err_parm) = error_mark_node; parameter_list = chainon (parameter_list, err_parm); } diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index eabd11b..c6e8798 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -93,10 +93,14 @@ static GTY ((param_is (spec_entry))) static GTY ((param_is (spec_entry))) htab_t type_specializations; -/* Contains canonical template parameter types. The vector is indexed by - the TEMPLATE_TYPE_IDX of the template parameter. Each element is a - TREE_LIST, whose TREE_VALUEs contain the canonical template - parameters of various types and levels. */ +/* Contains canonical template parameter types. The vector is indexed + by the TEMPLATE_TYPE_IDX of the template parameter. Each element is + a TREE_LIST, whose TREE_PURPOSE is a INT_CST tree representing a + total size of the template parameter list a given template + parameter would belong too, and whose TREE_VALUEs contain the + canonical template parameters of various types and levels, + belonging to a set of template parameters which size is + TREE_PURPOSE. */ static GTY(()) VEC(tree,gc) *canonical_template_parms; #define UNIFY_ALLOW_NONE 0 @@ -190,6 +194,12 @@ static void append_type_to_template_for_access_check_1 (tree, tree, tree, static hashval_t iterative_hash_template_arg (tree arg, hashval_t val); static tree listify (tree); static tree listify_autos (tree, tree); +static tree template_parm_to_arg (tree t); +static tree current_template_args (void); +static tree fixup_template_type_parm_type (tree, int); +static tree fixup_template_parm_index (tree, tree, int); +static void fixup_template_parms (void); +static tree tsubst_template_parm (tree, tree, tsubst_flags_t); /* Make the current scope suitable for access checking when we are processing T. T can be FUNCTION_DECL for instantiated function @@ -3369,9 +3379,19 @@ build_template_parm_index (int index, /* Find the canonical type parameter for the given template type parameter. Returns the canonical type parameter, which may be TYPE - if no such parameter existed. */ + if no such parameter existed. TOTAL_NUM_PARMS is the number of + template parameters carried by the considered template. + + If TYPE is the template parameter at position P in a + template, this function won't return the same canonical type as for + a another TYPE that would be a template parameter at position Q, + with Q != P. + + If TOTAL_NUM_PARMS is 0, it means the number of template parms is + not known yet, e.g, we are still parsing the template parms list. */ + static tree -canonical_type_parameter (tree type) +canonical_type_parameter (tree type, unsigned total_num_parms) { tree list; int idx = TEMPLATE_TYPE_IDX (type); @@ -3382,15 +3402,20 @@ canonical_type_parameter (tree type) VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE); list = VEC_index (tree, canonical_template_parms, idx); - while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL)) - list = TREE_CHAIN (list); + while (list) + { + if (TREE_INT_CST_LOW (TREE_PURPOSE (list)) == total_num_parms + && comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL)) + break; + list = TREE_CHAIN (list); + } if (list) return TREE_VALUE (list); else { VEC_replace(tree, canonical_template_parms, idx, - tree_cons (NULL_TREE, type, + tree_cons (size_int (total_num_parms), type, VEC_index (tree, canonical_template_parms, idx))); return type; } @@ -3425,6 +3450,7 @@ reduce_template_parm_level (tree index, tree type, int levels, tree args, TEMPLATE_PARM_ORIG_LEVEL (index), decl, type); TEMPLATE_PARM_DESCENDANTS (index) = t; + TEMPLATE_PARM_NUM_SIBLINGS (t) = TEMPLATE_PARM_NUM_SIBLINGS (index); TEMPLATE_PARM_PARAMETER_PACK (t) = TEMPLATE_PARM_PARAMETER_PACK (index); @@ -3438,15 +3464,21 @@ reduce_template_parm_level (tree index, tree type, int levels, tree args, return TEMPLATE_PARM_DESCENDANTS (index); } -/* Process information from new template parameter PARM and append it to the - LIST being built. This new parameter is a non-type parameter iff - IS_NON_TYPE is true. This new parameter is a parameter - pack iff IS_PARAMETER_PACK is true. The location of PARM is in - PARM_LOC. */ +/* Process information from new template parameter PARM and append it + to the LIST being built. This new parameter is a non-type + parameter iff IS_NON_TYPE is true. This new parameter is a + parameter pack iff IS_PARAMETER_PACK is true. The location of PARM + is in PARM_LOC. NUM_TEMPLATE_PARMS is the size of the template + parameter list PARM belongs to. This is used used to create a + proper canonical type for the type of PARM that is to be created, + iff PARM is a type. If the size is not known, this parameter can + be set to 0. Setting it to zero would create a template type + parameter with no canonical type. */ tree -process_template_parm (tree list, location_t parm_loc, tree parm, bool is_non_type, - bool is_parameter_pack) +process_template_parm (tree list, location_t parm_loc, tree parm, + bool is_non_type, bool is_parameter_pack, + unsigned num_template_parms) { tree decl = 0; tree defval; @@ -3556,8 +3588,9 @@ process_template_parm (tree list, location_t parm_loc, tree parm, bool is_non_ty processing_template_decl, decl, TREE_TYPE (parm)); TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack; - TYPE_CANONICAL (t) = canonical_type_parameter (t); - } + TYPE_CANONICAL (t) = + canonical_type_parameter (t, num_template_parms); + } DECL_ARTIFICIAL (decl) = 1; SET_DECL_TEMPLATE_PARM_P (decl); pushdecl (decl); @@ -3573,9 +3606,9 @@ process_template_parm (tree list, location_t parm_loc, tree parm, bool is_non_ty tree end_template_parm_list (tree parms) { - int nparms; + int nparms, length = list_length (parms); tree parm, next; - tree saved_parmlist = make_tree_vec (list_length (parms)); + tree saved_parmlist = make_tree_vec (length); current_template_parms = tree_cons (size_int (processing_template_decl), @@ -3586,16 +3619,305 @@ end_template_parm_list (tree parms) next = TREE_CHAIN (parm); TREE_VEC_ELT (saved_parmlist, nparms) = parm; TREE_CHAIN (parm) = NULL_TREE; - if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL) - TEMPLATE_TYPE_PARM_SIBLING_PARMS (TREE_TYPE (TREE_VALUE (parm))) = - current_template_parms; } + fixup_template_parms (); + --processing_template_parmlist; return saved_parmlist; } +/* Create a new type almost identical to TYPE but which has the + following differences: + + 1/ T has a new TEMPLATE_PARM_INDEX that carries the new number of + template sibling parameters of T. + + 2/ T has a new canonical type that matches the new number + of sibling parms. + + 3/ From now on, T is going to be what lookups referring to the + name of TYPE will return. No lookup should return TYPE anymore. + + NUM_PARMS is the new number of sibling parms TYPE belongs to. + + This is a subroutine of fixup_template_parms. */ + +static tree +fixup_template_type_parm_type (tree type, int num_parms) +{ + tree orig_idx = TEMPLATE_TYPE_PARM_INDEX (type), idx; + tree t = copy_type (type); + /* This is the decl which name is inserted into the symbol table for + the template parm type. So whenever we lookup the type name, this + is the DECL we get. */ + tree decl = TYPE_NAME (t); + + TYPE_MAIN_VARIANT (t) = t; + TYPE_NEXT_VARIANT (t)= NULL_TREE; + TYPE_POINTER_TO (t) = 0; + TYPE_REFERENCE_TO (t) = 0; + + idx = build_template_parm_index (TEMPLATE_PARM_IDX (orig_idx), + TEMPLATE_PARM_LEVEL (orig_idx), + TEMPLATE_PARM_ORIG_LEVEL (orig_idx), + decl, t); + TEMPLATE_PARM_DESCENDANTS (idx) = TEMPLATE_PARM_DESCENDANTS (orig_idx); + TEMPLATE_PARM_PARAMETER_PACK (idx) = TEMPLATE_PARM_PARAMETER_PACK (orig_idx); + set_template_parms_num_siblings (idx, num_parms); + TEMPLATE_TYPE_PARM_INDEX (t) = idx; + + TYPE_STUB_DECL (t) = decl; + TEMPLATE_TYPE_DECL (t) = decl; + if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM) + TREE_TYPE (DECL_TEMPLATE_RESULT (decl)) = t; + + /* Update the type associated to the type name stored in the symbol + table. Now, whenever the type name is looked up, the resulting + type is properly fixed up. */ + TREE_TYPE (decl) = t; + + TYPE_CANONICAL (t) = canonical_type_parameter (t, num_parms); + + return t; +} + +/* Create and return a new TEMPLATE_PARM_INDEX that is almost + identical to I, but that is fixed up as to: + + 1/ carry the number of sibling parms (NUM_PARMS) of the template + parm represented by I. + + 2/ replace all references to template parm types declared before I + (in the same template parm list as I) by references to template + parm types contained in ARGS. ARGS should contain the list of + template parms that have been fixed up so far, in a form suitable + to be passed to tsubst. + + This is a subroutine of fixup_template_parms. */ + +static tree +fixup_template_parm_index (tree i, tree args, int num_parms) +{ + tree index, decl, type; + + if (i == NULL_TREE + || TREE_CODE (i) != TEMPLATE_PARM_INDEX) + return i; + + decl = TEMPLATE_PARM_DECL (i); + type = TREE_TYPE (decl); + + index = build_template_parm_index (TEMPLATE_PARM_IDX (i), + TEMPLATE_PARM_LEVEL (i), + TEMPLATE_PARM_ORIG_LEVEL (i), + decl, type); + + TEMPLATE_PARM_DESCENDANTS (index) = TEMPLATE_PARM_DESCENDANTS (i); + TEMPLATE_PARM_PARAMETER_PACK (index) = TEMPLATE_PARM_PARAMETER_PACK (i); + set_template_parms_num_siblings (index, num_parms); + + type = tsubst (type, args, tf_none, NULL_TREE); + + TREE_TYPE (decl) = type; + TREE_TYPE (index) = type; + + return index; +} + +/* Walk current the template parms and properly compute the canonical + types of the dependent types created during + cp_parser_template_parameter_list. */ + +static void +fixup_template_parms (void) +{ + tree parm; + tree arglist; + tree parameter_vec; + tree fixedup_args; + int i, num_parms; + + parameter_vec = INNERMOST_TEMPLATE_PARMS (current_template_parms); + if (parameter_vec == NULL_TREE) + return; + + num_parms = TREE_VEC_LENGTH (parameter_vec); + + /* This vector contains the current innermost template parms that + have been fixed up so far. The form of FIXEDUP_ARGS is suitable + to be passed to tsubst* functions as their ARGS argument. */ + fixedup_args = make_tree_vec (num_parms); + + /* This vector contains the full set of template parms in a form + suitable to be passed to substs functions as their ARGS + argument. */ + arglist = current_template_args (); + arglist = add_outermost_template_args (arglist, fixedup_args); + + fixedup_args = INNERMOST_TEMPLATE_ARGS (arglist); + + /* Let's do the proper fixup now. */ + for (i = 0; i < num_parms; ++i) + { + tree cur = TREE_VEC_ELT (parameter_vec, i); + + /* This is the current template parameter we need to fix up. */ + parm = TREE_VALUE (cur); + + if (TREE_CODE (parm) == TYPE_DECL) + { + /* PARM is a template type parameter. Fix up its type, add + the fixed-up template parm to the vector of fixed-up + template parms so far, and substitute the fixed-up + template parms into the default argument of this + parameter. */ + + tree t = + fixup_template_type_parm_type (TREE_TYPE (parm), num_parms); + TREE_TYPE (parm) = t; + + TREE_VEC_ELT (fixedup_args, i) = template_parm_to_arg (cur); + + if (TREE_PURPOSE (cur)) + { + /* So the current template type parameter has a default + argument. Substitute the so far fixed-up template + parms into it. */ + tree default_arg = TREE_PURPOSE (cur); + + if (TYPE_P (default_arg) + && !dependent_type_p (default_arg)) + continue; + + arglist = current_template_args (); + ++cp_unevaluated_operand; + TREE_PURPOSE (cur) = + tsubst_expr (default_arg, arglist, + tf_none, default_arg, false); + --cp_unevaluated_operand; + } + } + else if (TREE_CODE (parm) == TEMPLATE_DECL) + { + /* PARM is a template template parameter. This is going to + be interesting. */ + tree tparms, targs, innermost_args; + int j; + + /* First, fix up the type of the parm. */ + + tree t = + fixup_template_type_parm_type (TREE_TYPE (parm), num_parms); + TREE_TYPE (parm) = t; + + TREE_VEC_ELT (fixedup_args, i) = template_parm_to_arg (cur); + + /* Now we need to substitute the template parm types that + have been fixed up so far into the non-type template + parms of this template template parm. E.g, consider this: + + template class TT> class S; + + In this case we want to substitute T into the + template parameters of TT. + + Sot let's walk the template parms of PARM here, and + tsubst ARGLIST into into each of the template + parms. */ + + /* For this substitution we need to build the full set of + template parameters and use that as arguments for the + tsubsting function. */ + tparms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm)); + + /* This will contain the innermost parms of PARM into which + we have substituted so far. */ + innermost_args = make_tree_vec (TREE_VEC_LENGTH (tparms)); + targs = add_to_template_args (arglist, innermost_args); + for (j = 0; j < TREE_VEC_LENGTH (tparms); ++j) + { + tree substed_parm, parameter; + + parameter = TREE_VEC_ELT (tparms, j); + + /* INNERMOST_ARGS needs to have at least the same number + of elements as the index PARAMETER, ortherwise + tsubsting into PARAMETER will result in partially + instantiating it, reducing its tempate parm + level. Let's tactically fill INNERMOST_ARGS for that + purpose. */ + TREE_VEC_ELT (innermost_args, j) = template_parm_to_arg (parameter); + + /* Only substitute into template non-type parms. */ + if (parameter != NULL_TREE + && TREE_CODE (parameter) == TREE_LIST + && (TREE_CODE (TREE_VALUE (parameter)) == TYPE_DECL + || TREE_CODE (TREE_VALUE (parameter)) == TEMPLATE_DECL)) + continue; + + if (!dependent_type_p (TREE_TYPE (TREE_VALUE (parameter)))) + continue; + + ++cp_unevaluated_operand; + substed_parm = tsubst_template_parm (parameter, targs, tf_none); + --cp_unevaluated_operand; + + /* Update the template parameters of PARM. */ + TREE_VEC_ELT (tparms, j) = substed_parm; + + /* Update the vector of parms we have tsubsted into so + far. */ + TREE_VEC_ELT (innermost_args, j) = + template_parm_to_arg (substed_parm); + } + } + else if (TREE_CODE (parm) == PARM_DECL) + { + /* PARM is a non-type template parameter. We need to: + + * Fix up its TEMPLATE_PARM_INDEX to make it carry the + proper number of sibling parameters. + + * Make lookups of the template parameter return a reference + to the fixed-up index. No lookup should return references + to the former index anymore. + + * Substitute the template parms that got fixed up so far + + * into the type of PARM. */ + + tree index = DECL_INITIAL (parm); + + /* PUSHED_DECL is the decl added to the symbol table with + the name of the parameter. E,g: + + template //#0 + auto my_function(T t) -> decltype(u); //#1 + + Here, when looking up u at //#1, we get the decl of u + resulting from the declaration in #0. This is what + PUSHED_DECL is. We need to replace the reference to the + old TEMPLATE_PARM_INDEX carried by PUSHED_DECL by the + fixed-up TEMPLATE_PARM_INDEX. */ + tree pushed_decl = TEMPLATE_PARM_DECL (index); + tree fixed_up_index = + fixup_template_parm_index (index, arglist, num_parms); + + DECL_INITIAL (pushed_decl) = DECL_INITIAL (parm) = fixed_up_index; + + /* Add this fixed up PARM to the template parms we've fixed + up so far and use that to substitute the fixed-up + template parms into the type of PARM. */ + TREE_VEC_ELT (fixedup_args, i) = template_parm_to_arg (cur); + TREE_TYPE (parm) = tsubst (TREE_TYPE (parm), arglist, + tf_none, NULL_TREE); + TREE_VALUE (cur) = parm; + } + } +} + /* end_template_decl is called after a template declaration is seen. */ void @@ -3613,6 +3935,65 @@ end_template_decl (void) current_template_parms = TREE_CHAIN (current_template_parms); } +/* Takes a TREE_LIST representing a template parameter and convert it + into an argument suitable to be passed to the type substitution + functions. */ + +static tree +template_parm_to_arg (tree t) +{ + + if (t == NULL_TREE + || TREE_CODE (t) != TREE_LIST + || error_operand_p (TREE_VALUE (t))) + return t; + + t = TREE_VALUE (t); + + if (TREE_CODE (t) == TYPE_DECL + || TREE_CODE (t) == TEMPLATE_DECL) + { + t = TREE_TYPE (t); + + if (TEMPLATE_TYPE_PARAMETER_PACK (t)) + { + /* Turn this argument into a TYPE_ARGUMENT_PACK + with a single element, which expands T. */ + tree vec = make_tree_vec (1); +#ifdef ENABLE_CHECKING + SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT + (vec, TREE_VEC_LENGTH (vec)); +#endif + TREE_VEC_ELT (vec, 0) = make_pack_expansion (t); + + t = cxx_make_type (TYPE_ARGUMENT_PACK); + SET_ARGUMENT_PACK_ARGS (t, vec); + } + } + else + { + t = DECL_INITIAL (t); + + if (TEMPLATE_PARM_PARAMETER_PACK (t)) + { + /* Turn this argument into a NONTYPE_ARGUMENT_PACK + with a single element, which expands T. */ + tree vec = make_tree_vec (1); + tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t)); +#ifdef ENABLE_CHECKING + SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT + (vec, TREE_VEC_LENGTH (vec)); +#endif + TREE_VEC_ELT (vec, 0) = make_pack_expansion (t); + + t = make_node (NONTYPE_ARGUMENT_PACK); + SET_ARGUMENT_PACK_ARGS (t, vec); + TREE_TYPE (t) = type; + } + } + return t; +} + /* Within the declaration of a template, return all levels of template parameters that apply. The template parameters are represented as a TREE_VEC, in the form documented in cp-tree.h for template @@ -3639,63 +4020,7 @@ current_template_args (void) TREE_TYPE (a) = NULL_TREE; for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i) - { - tree t = TREE_VEC_ELT (a, i); - - /* T will be a list if we are called from within a - begin/end_template_parm_list pair, but a vector directly - if within a begin/end_member_template_processing pair. */ - if (TREE_CODE (t) == TREE_LIST) - { - t = TREE_VALUE (t); - - if (!error_operand_p (t)) - { - if (TREE_CODE (t) == TYPE_DECL - || TREE_CODE (t) == TEMPLATE_DECL) - { - t = TREE_TYPE (t); - - if (TEMPLATE_TYPE_PARAMETER_PACK (t)) - { - /* Turn this argument into a TYPE_ARGUMENT_PACK - with a single element, which expands T. */ - tree vec = make_tree_vec (1); -#ifdef ENABLE_CHECKING - SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT - (vec, TREE_VEC_LENGTH (vec)); -#endif - TREE_VEC_ELT (vec, 0) = make_pack_expansion (t); - - t = cxx_make_type (TYPE_ARGUMENT_PACK); - SET_ARGUMENT_PACK_ARGS (t, vec); - } - } - else - { - t = DECL_INITIAL (t); - - if (TEMPLATE_PARM_PARAMETER_PACK (t)) - { - /* Turn this argument into a NONTYPE_ARGUMENT_PACK - with a single element, which expands T. */ - tree vec = make_tree_vec (1); - tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t)); -#ifdef ENABLE_CHECKING - SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT - (vec, TREE_VEC_LENGTH (vec)); -#endif - TREE_VEC_ELT (vec, 0) = make_pack_expansion (t); - - t = make_node (NONTYPE_ARGUMENT_PACK); - SET_ARGUMENT_PACK_ARGS (t, vec); - TREE_TYPE (t) = type; - } - } - TREE_VEC_ELT (a, i) = t; - } - } - } + TREE_VEC_ELT (a, i) = template_parm_to_arg (TREE_VEC_ELT (a, i)); #ifdef ENABLE_CHECKING SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a, TREE_VEC_LENGTH (a)); @@ -3706,7 +4031,23 @@ current_template_args (void) else args = a; } - + + if (length > 1 && TREE_VEC_ELT (args, 0) == NULL_TREE) + /* This can happen for template parms of a template template + parameter, e.g: + + template class TT> struct S; + + Consider the level of the parms of TT; T and U both have + level 2; TT has no template parm of level 1. So in this case + the first element of full_template_args is NULL_TREE. If we + leave it like this TMPL_ARG_DEPTH on args returns 1 instead + of 2. This will make tsubst wrongly consider that T and U + have level 1. Instead, let's create a dummy vector as the + first element of full_template_args so that TMPL_ARG_DEPTH + returns the correct depth for args. + */ + TREE_VEC_ELT (args, 0) = make_tree_vec (1); return args; } @@ -8740,8 +9081,6 @@ tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain) for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i) { tree tuple; - tree default_value; - tree parm_decl; if (parms == error_mark_node) continue; @@ -8751,18 +9090,8 @@ tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain) if (tuple == error_mark_node) continue; - default_value = TREE_PURPOSE (tuple); - parm_decl = TREE_VALUE (tuple); - - parm_decl = tsubst (parm_decl, args, complain, NULL_TREE); - if (TREE_CODE (parm_decl) == PARM_DECL - && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain)) - parm_decl = error_mark_node; - default_value = tsubst_template_arg (default_value, args, - complain, NULL_TREE); - - tuple = build_tree_list (default_value, parm_decl); - TREE_VEC_ELT (new_vec, i) = tuple; + TREE_VEC_ELT (new_vec, i) = + tsubst_template_parm (tuple, args, complain); } *new_parms = @@ -8776,6 +9105,100 @@ tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain) return r; } +/* Return the result of substituting ARGS into one template parameter + given by T. T Must be a TREE_LIST which TREE_VALUE is the template + parameter and which TREE_PURPOSE is the default argument of the + template parameter. */ + +static tree +tsubst_template_parm (tree t, tree args, tsubst_flags_t complain) +{ + tree default_value, parm_decl; + + if (args == NULL_TREE + || t == NULL_TREE + || t == error_mark_node) + return t; + + gcc_assert (TREE_CODE (t) == TREE_LIST); + + default_value = TREE_PURPOSE (t); + parm_decl = TREE_VALUE (t); + + parm_decl = tsubst (parm_decl, args, complain, NULL_TREE); + if (TREE_CODE (parm_decl) == PARM_DECL + && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain)) + parm_decl = error_mark_node; + default_value = tsubst_template_arg (default_value, args, + complain, NULL_TREE); + + return build_tree_list (default_value, parm_decl); +} + +/* Return the size of template of the parameters list T belongs to. T + is either a template parameter type, a template non-type parameter + or a template parameter index. */ + +int +get_template_parms_num_siblings (tree t) +{ + unsigned result; + + gcc_assert (t != NULL_TREE + && (TREE_CODE (t) == TEMPLATE_PARM_INDEX + || TREE_CODE (t) == TEMPLATE_TYPE_PARM + || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM + || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM + || (TREE_CODE (t) == PARM_DECL + && DECL_TEMPLATE_PARM_P (t)))); + + switch (TREE_CODE (t)) + { + case TEMPLATE_PARM_INDEX: + result = TEMPLATE_PARM_NUM_SIBLINGS (t); + break; + case PARM_DECL: + result = get_template_parms_num_siblings (DECL_INITIAL (t)); + break; + default: + result = + get_template_parms_num_siblings (TEMPLATE_TYPE_PARM_INDEX (t)); + break; + } + return result; +} + +/* Set the size of template of the parameters list T belongs to. T is + either a template parameter type, a template non-type parameter or + a template parameter index. */ + +void +set_template_parms_num_siblings (tree t, int num_parms) +{ + gcc_assert (t != NULL_TREE + && (TREE_CODE (t) == TEMPLATE_PARM_INDEX + || TREE_CODE (t) == TEMPLATE_TYPE_PARM + || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM + || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM + || (TREE_CODE (t) == PARM_DECL + && DECL_TEMPLATE_PARM_P (t)))); + + switch (TREE_CODE (t)) + { + case TEMPLATE_PARM_INDEX: + TEMPLATE_PARM_NUM_SIBLINGS (t) = num_parms; + break; + case PARM_DECL: + set_template_parms_num_siblings (DECL_INITIAL (t), num_parms); + break; + default: + set_template_parms_num_siblings (TEMPLATE_TYPE_PARM_INDEX (t), + num_parms); + break; + } +} + + /* Substitute the ARGS into the indicated aggregate (or enumeration) type T. If T is not an aggregate or enumeration type, it is handled as if by tsubst. IN_DECL is as for tsubst. If @@ -10291,7 +10714,12 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) else if (TYPE_STRUCTURAL_EQUALITY_P (t)) SET_TYPE_STRUCTURAL_EQUALITY (r); else - TYPE_CANONICAL (r) = canonical_type_parameter (r); + { + int num_parms = + get_template_parms_num_siblings (t); + TYPE_CANONICAL (r) = + canonical_type_parameter (r, num_parms); + } if (code == BOUND_TEMPLATE_TEMPLATE_PARM) { @@ -14701,6 +15129,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict) { tree parmvec = TYPE_TI_ARGS (parm); tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg)); + tree full_argvec = add_to_template_args (targs, argvec); tree parm_parms = DECL_INNERMOST_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm)); @@ -14735,7 +15164,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict) the global operator+ will be used; if they are not, the Lvalue_proxy will be converted to float. */ if (coerce_template_parms (parm_parms, - argvec, + full_argvec, TYPE_TI_TEMPLATE (parm), tf_none, /*require_all_args=*/true, @@ -17781,7 +18210,8 @@ type_dependent_expression_p (tree expression) if (!processing_template_decl) return false; - if (expression == error_mark_node) + if (expression == error_mark_node + || expression == NULL_TREE) return false; /* An unresolved name is always dependent. */ @@ -18401,7 +18831,7 @@ make_auto (void) TEMPLATE_TYPE_PARM_INDEX (au) = build_template_parm_index (0, processing_template_decl + 1, processing_template_decl + 1, TYPE_NAME (au), NULL_TREE); - TYPE_CANONICAL (au) = canonical_type_parameter (au); + TYPE_CANONICAL (au) = canonical_type_parameter (au, 0); DECL_ARTIFICIAL (TYPE_NAME (au)) = 1; SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au)); diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index ddfb354..f238f5a 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -1062,22 +1062,6 @@ strip_typedefs (tree t) return cp_build_qualified_type (result, cp_type_quals (t)); } -/* Setup a TYPE_DECL node as a typedef representation. - See comments of set_underlying_type in c-common.c. */ - -void -cp_set_underlying_type (tree t) -{ - set_underlying_type (t); - /* If T is a template type parm, make it require structural equality. - This is useful when comparing two template type parms, - because it forces the comparison of the template parameters of their - decls. */ - if (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM) - SET_TYPE_STRUCTURAL_EQUALITY (TREE_TYPE (t)); -} - - /* Makes a copy of BINFO and TYPE, which is to be inherited into a graph dominated by T. If BINFO is NULL, TYPE is a dependent base, and we do a shallow copy. If BINFO is non-NULL, we do a deep copy. diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index eff6704..13d1ae1 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -1143,114 +1143,20 @@ comp_template_parms_position (tree t1, tree t2) || TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM || TREE_CODE (t1) == TEMPLATE_TYPE_PARM)); - if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2) - || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2) - || (TEMPLATE_TYPE_PARAMETER_PACK (t1) - != TEMPLATE_TYPE_PARAMETER_PACK (t2))) - return false; - - return true; -} - -/* Subroutine of incompatible_dependent_types_p. - Return the template parameter of the dependent type T. - If T is a typedef, return the template parameters of - the _decl_ of the typedef. T must be a dependent type. */ - -static tree -get_template_parms_of_dependent_type (tree t) -{ - tree tinfo = NULL_TREE, tparms = NULL_TREE; - - /* First, try the obvious case of getting the - template info from T itself. */ - if ((tinfo = get_template_info (t))) - ; - else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM) - return TEMPLATE_TYPE_PARM_SIBLING_PARMS (t); - else if (typedef_variant_p (t) - && !NAMESPACE_SCOPE_P (TYPE_NAME (t))) - tinfo = get_template_info (DECL_CONTEXT (TYPE_NAME (t))); - /* If T is a TYPENAME_TYPE which context is a template type - parameter, get the template parameters from that context. */ - else if (TYPE_CONTEXT (t) - && TREE_CODE (TYPE_CONTEXT (t)) == TEMPLATE_TYPE_PARM) - return TEMPLATE_TYPE_PARM_SIBLING_PARMS (TYPE_CONTEXT (t)); - else if (TYPE_CONTEXT (t) - && !NAMESPACE_SCOPE_P (t)) - tinfo = get_template_info (TYPE_CONTEXT (t)); - - if (tinfo) - tparms = DECL_TEMPLATE_PARMS (TI_TEMPLATE (tinfo)); - - return tparms; -} - -/* Subroutine of structural_comptypes. - Compare the dependent types T1 and T2. - Return TRUE if we are sure they can't be equal, FALSE otherwise. - The whole point of this function is to support cases where either T1 or - T2 is a typedef. In those cases, we need to compare the template parameters - of the _decl_ of the typedef. If those don't match then we know T1 - and T2 cannot be equal. */ - -static bool -incompatible_dependent_types_p (tree t1, tree t2) -{ - tree tparms1 = NULL_TREE, tparms2 = NULL_TREE; - bool t1_typedef_variant_p, t2_typedef_variant_p; - - if (!uses_template_parms (t1) || !uses_template_parms (t2)) - return false; - - if (TREE_CODE (t1) == TEMPLATE_TYPE_PARM) - { - /* If T1 and T2 don't have the same relative position in their - template parameters set, they can't be equal. */ - if (!comp_template_parms_position (t1, t2)) - return true; - } - - t1_typedef_variant_p = typedef_variant_p (t1); - t2_typedef_variant_p = typedef_variant_p (t2); - - /* Either T1 or T2 must be a typedef. */ - if (!t1_typedef_variant_p && !t2_typedef_variant_p) + /* If T1 and T2 belong to template parm lists of different size, + let's assume they are different. */ + if (get_template_parms_num_siblings (TYPE_MAIN_VARIANT (t1)) + != get_template_parms_num_siblings (TYPE_MAIN_VARIANT (t2))) return false; - if (!t1_typedef_variant_p || !t2_typedef_variant_p) - /* Either T1 or T2 is not a typedef so we cannot compare the - template parms of the typedefs of T1 and T2. - At this point, if the main variant type of T1 and T2 are equal - it means the two types can't be incompatible, from the perspective - of this function. */ - if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) - return false; - - /* So if we reach this point, it means either T1 or T2 is a typedef variant. - Let's compare their template parameters. */ - - tparms1 = get_template_parms_of_dependent_type (t1); - tparms2 = get_template_parms_of_dependent_type (t2); - - /* If T2 is a template type parm and if we could not get the template - parms it belongs to, that means we have not finished parsing the - full set of template parameters of the template declaration it - belongs to yet. If we could get the template parms T1 belongs to, - that mostly means T1 and T2 belongs to templates that are - different and incompatible. */ - if (TREE_CODE (t1) == TEMPLATE_TYPE_PARM - && (tparms1 == NULL_TREE || tparms2 == NULL_TREE) - && tparms1 != tparms2) - return true; - - if (tparms1 == NULL_TREE - || tparms2 == NULL_TREE - || tparms1 == tparms2) + /* Then compare their relative position. */ + if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2) + || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2) + || (TEMPLATE_TYPE_PARAMETER_PACK (t1) + != TEMPLATE_TYPE_PARAMETER_PACK (t2))) return false; - /* And now compare the mighty template parms! */ - return !comp_template_parms (tparms1, tparms2); + return true; } /* Subroutine in comptypes. */ @@ -1295,12 +1201,6 @@ structural_comptypes (tree t1, tree t2, int strict) if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2)) return false; - /* If T1 and T2 are dependent typedefs then check upfront that - the template parameters of their typedef DECLs match before - going down checking their subtypes. */ - if (incompatible_dependent_types_p (t1, t2)) - return false; - /* Allow for two different type nodes which have essentially the same definition. Note that we already checked for equality of the type qualifiers (just above). */ @@ -1345,6 +1245,7 @@ structural_comptypes (tree t1, tree t2, int strict) (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)), DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2)))) return false; + if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM) break; /* Don't check inheritance. */ @@ -1401,8 +1302,10 @@ structural_comptypes (tree t1, tree t2, int strict) break; case TEMPLATE_TYPE_PARM: - /* If incompatible_dependent_types_p called earlier didn't decide - T1 and T2 were different, they might be equal. */ + /* If T1 and T2 don't have the same relative position in their + template parameters set, they can't be equal. */ + if (!comp_template_parms_position (t1, t2)) + return false; break; case TYPENAME_TYPE: diff --git a/gcc/testsuite/g++.dg/template/typedef36.C b/gcc/testsuite/g++.dg/template/typedef36.C new file mode 100644 index 0000000..f6155c1 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/typedef36.C @@ -0,0 +1,23 @@ +// Origin: PR c++/45606 +// { dg-do compile } + +#include + +template +class Test +{ +protected: + typedef std::list ListAlias; + ListAlias list; +public: + typedef typename ListAlias::const_iterator const_iterator; + inline const_iterator begin() const; + +}; + +template +inline typename std::list::const_iterator Test::begin() const +{ + return list.begin(); +} +