public inbox for gcc-cvs@sourceware.org help / color / mirror / Atom feed
From: Patrick Palka <ppalka@gcc.gnu.org> To: gcc-cvs@gcc.gnu.org Subject: [gcc r15-123] c++: remove lookup_template_class's entering_scope flag Date: Fri, 3 May 2024 01:14:49 +0000 (GMT) [thread overview] Message-ID: <20240503011450.04311385E836@sourceware.org> (raw) https://gcc.gnu.org/g:f04dc89a991ddc6c08ac92c8ad29c6915c4ecafa commit r15-123-gf04dc89a991ddc6c08ac92c8ad29c6915c4ecafa Author: Patrick Palka <ppalka@redhat.com> Date: Thu May 2 21:14:30 2024 -0400 c++: remove lookup_template_class's entering_scope flag lookup_template_class's entering_scope flag controls whether to prefer returning the primary template type A<T> instead of the corresponding implicit instantiation A<T>. When we want to set this flag as part of substitution, we need to use tsubst_aggr_type which also takes this flag as a parameter. But having this separate entry point to type substitution turned out to be subtly problematic because it doesn't reuse typedefs like tsubst does, which r13-4729-gbe124477b38a71 fixed in a way that respects the flag after the fact, by adjusting the entering_scope=false result of lookup_template_class as if entering_scope=true was passed. But if that's possible then it means lookup_template_class's entering_scope flag is not necessary after all -- we can just do the after-the-fact adjustment everywhere that we currently pass entering_scope=true to it and tsubst_aggr_type. To that end, this patch replaces this flag with an adjustment function adjust_type_for_entering_scope, to be used whereever we currently need the entering_scope=true behavior. In turn we can get rid of tsubst_aggr_type since the only reason we needed this entry point was to be able to pass entering_scope=true to lookup_template_class. gcc/cp/ChangeLog: * coroutines.cc (instantiate_coro_traits): Adjust call to lookup_template_class. (instantiate_coro_handle_for_promise_type): Likewise. * cp-tree.h (adjust_type_for_entering_scope): Declare. (lookup_template_class): Adjust declaration. * decl.cc (make_typename_type): Adjust call to lookup_template_class. Likewise. (get_tuple_size): Likewise. (get_tuple_element_type): Likewise. * pt.cc (adjust_type_for_entering_scope): Define. (tsubst_entering_scope): Define. (lookup_template_class): Remove entering_scope parameter. Replace tsubst_aggr_type call with tsubst_entering_scope. (tsubst_aggr_type): Remove. (tsubst_aggr_type_1): Inline into tsubst. (tsubst_function_decl): Replace tsubst_aggr_type call with tsubst_entering_scope. (tsubst_template_decl): Likewise. (tsubst_decl): Likewise. (tsubst) <case RECORD_TYPE, UNION_TYPE, ENUMERAL_TYPE>: Inlined from tsubst_aggr_type_1. <case BOUND_TEMPLATE_TEMPLATE_PARM>: Adjust calls to lookup_template_class. <case TYPENAME_TYPE>: Replace tsubst_aggr_type call with tsubst_entering_scope. <case UNBOUND_CLASS_TEMPLATE>: Likewise. Increment processing_template_decl when substituting the context. (tsubst_expr) <case FIELD_DECL>: Replace tsubst_aggr_type call with tsubst_entering_scope. <case TEMPLATE_DECL>: Likewise. (instantiate_template): Likewise. (resolve_typename_type): Adjust lookup_template_class call and call adjust_type_for_entering_scope afterward. (listify): Adjust lookup_template_class call. (alias_ctad_tweaks): Likewise. * semantics.cc (finish_template_type): Adjust lookup_template_class call and maybe call adjust_type_for_entering_scope afterward. Reviewed-by: Jason Merrill <jason@redhat.com> Diff: --- gcc/cp/coroutines.cc | 4 +- gcc/cp/cp-tree.h | 3 +- gcc/cp/decl.cc | 4 +- gcc/cp/pt.cc | 207 ++++++++++++++++++++------------------------------- gcc/cp/semantics.cc | 4 +- 5 files changed, 88 insertions(+), 134 deletions(-) diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc index b05cb9eb330..97bc211ff67 100644 --- a/gcc/cp/coroutines.cc +++ b/gcc/cp/coroutines.cc @@ -353,7 +353,7 @@ instantiate_coro_traits (tree fndecl, location_t kw) tree traits_class = lookup_template_class (coro_traits_templ, targ, /*in_decl=*/NULL_TREE, /*context=*/NULL_TREE, - /*entering scope=*/false, tf_warning_or_error); + tf_warning_or_error); if (traits_class == error_mark_node) { @@ -400,7 +400,7 @@ instantiate_coro_handle_for_promise_type (location_t kw, tree promise_type) = lookup_template_class (coro_handle_identifier, targ, /* in_decl=*/NULL_TREE, /* context=*/std_node, - /* entering scope=*/false, tf_warning_or_error); + tf_warning_or_error); if (handle_type == error_mark_node) { diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 933504b4821..1ba7054f8bc 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -7524,8 +7524,9 @@ extern tree push_template_decl (tree, bool is_friend = false); extern tree add_inherited_template_parms (tree, tree); extern void template_parm_level_and_index (tree, int*, int*); extern bool redeclare_class_template (tree, tree, tree); +extern tree adjust_type_for_entering_scope (tree); extern tree lookup_template_class (tree, tree, tree, tree, - int, tsubst_flags_t); + tsubst_flags_t); extern tree lookup_template_function (tree, tree); extern tree lookup_template_variable (tree, tree, tsubst_flags_t); extern bool uses_template_parms (tree); diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc index 378311c0f04..71e4c2b5840 100644 --- a/gcc/cp/decl.cc +++ b/gcc/cp/decl.cc @@ -4578,7 +4578,6 @@ make_typename_type (tree context, tree name, enum tag_types tag_type, { t = lookup_template_class (t, TREE_OPERAND (fullname, 1), NULL_TREE, context, - /*entering_scope=*/0, complain | tf_user); if (t == error_mark_node) return error_mark_node; @@ -9175,7 +9174,7 @@ get_tuple_size (tree type) tree inst = lookup_template_class (tuple_size_identifier, args, /*in_decl*/NULL_TREE, /*context*/std_node, - /*entering_scope*/false, tf_none); + tf_none); inst = complete_type (inst); if (inst == error_mark_node || !COMPLETE_TYPE_P (inst) @@ -9204,7 +9203,6 @@ get_tuple_element_type (tree type, unsigned i) tree inst = lookup_template_class (tuple_element_identifier, args, /*in_decl*/NULL_TREE, /*context*/std_node, - /*entering_scope*/false, tf_warning_or_error); return make_typename_type (inst, type_identifier, none_type, tf_warning_or_error); diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 1c3eef60c06..d68d688016d 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -185,8 +185,6 @@ static int unify_pack_expansion (tree, tree, tree, static tree copy_template_args (tree); static tree tsubst_template_parms (tree, tree, tsubst_flags_t); static void tsubst_each_template_parm_constraints (tree, tree, tsubst_flags_t); -static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int); -static tree tsubst_aggr_type_1 (tree, tree, tsubst_flags_t, tree, int); static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree); static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree); static bool check_specialization_scope (void); @@ -9901,6 +9899,35 @@ maybe_get_template_decl_from_type_decl (tree decl) ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl; } +/* If TYPE is the generic implicit instantiation A<T>, return the primary + template type A<T> (which is suitable for entering into, e.g. for defining + a member of A<T>), otherwise return TYPE. */ + +tree +adjust_type_for_entering_scope (tree type) +{ + if (CLASS_TYPE_P (type) + && dependent_type_p (type) + && TYPE_TEMPLATE_INFO (type) + /* We detect the generic implicit instantiation A<T> by inspecting + TYPE_CANONICAL, which lookup_template_class sets to the primary + template type A<T>. */ + && TYPE_CANONICAL (type) == TREE_TYPE (TYPE_TI_TEMPLATE (type))) + type = TYPE_CANONICAL (type); + + return type; +} + +/* Convenience wrapper over tsubst that does adjust_type_for_entering_scope + on the result. */ + +static tree +tsubst_entering_scope (tree t, tree args, tsubst_flags_t complain, tree in_decl) +{ + t = tsubst (t, args, complain, in_decl); + return adjust_type_for_entering_scope (t); +} + /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of parameters, find the desired type. @@ -9909,9 +9936,6 @@ maybe_get_template_decl_from_type_decl (tree decl) IN_DECL, if non-NULL, is the template declaration we are trying to instantiate. - If ENTERING_SCOPE is nonzero, we are about to enter the scope of - the class we are looking up. - Issue error and warning messages under control of COMPLAIN. If the template class is really a local class in a template @@ -9927,7 +9951,7 @@ maybe_get_template_decl_from_type_decl (tree decl) tree lookup_template_class (tree d1, tree arglist, tree in_decl, tree context, - int entering_scope, tsubst_flags_t complain) + tsubst_flags_t complain) { auto_timevar tv (TV_TEMPLATE_INST); @@ -10139,9 +10163,10 @@ lookup_template_class (tree d1, tree arglist, tree in_decl, tree context, template <class T> class C { void f(C<T>); } the `C<T>' is just the same as `C'. Outside of the - class, however, such a reference is an instantiation. */ - if (entering_scope - || !PRIMARY_TEMPLATE_P (gen_tmpl) + class, however, such a reference is an instantiation. + One can use adjust_type_for_entering_scope to make + this adjustment as needed. */ + if (!PRIMARY_TEMPLATE_P (gen_tmpl) || currently_open_class (template_type)) { tree tinfo = TYPE_TEMPLATE_INFO (template_type); @@ -10207,8 +10232,8 @@ lookup_template_class (tree d1, tree arglist, tree in_decl, tree context, context = DECL_CONTEXT (templ); else { - context = tsubst_aggr_type (context, arglist, - complain, in_decl, true); + context = tsubst_entering_scope (context, arglist, + complain, in_decl); /* Try completing the enclosing context if it's not already so. */ if (context != error_mark_node && !COMPLETE_TYPE_P (context)) @@ -14148,94 +14173,6 @@ tsubst_each_template_parm_constraints (tree parms, tree args, --processing_template_decl; } -/* 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 - ENTERING_SCOPE is nonzero, T is the context for a template which - we are presently tsubst'ing. Return the substituted value. */ - -static tree -tsubst_aggr_type (tree t, - tree args, - tsubst_flags_t complain, - tree in_decl, - int entering_scope) -{ - if (t == NULL_TREE) - return NULL_TREE; - - /* Handle typedefs via tsubst so that they get consistently reused. */ - if (typedef_variant_p (t)) - { - t = tsubst (t, args, complain, in_decl); - if (t == error_mark_node) - return error_mark_node; - - /* The effect of entering_scope is that for a dependent specialization - A<T>, lookup_template_class prefers to return A's primary template - type instead of the implicit instantiation. So when entering_scope, - we mirror this behavior by inspecting TYPE_CANONICAL appropriately, - taking advantage of the fact that lookup_template_class links the two - types by setting TYPE_CANONICAL of the latter to the former. */ - if (entering_scope - && CLASS_TYPE_P (t) - && dependent_type_p (t) - && TYPE_TEMPLATE_INFO (t) - && TYPE_CANONICAL (t) == TREE_TYPE (TYPE_TI_TEMPLATE (t))) - t = TYPE_CANONICAL (t); - - return t; - } - - switch (TREE_CODE (t)) - { - case RECORD_TYPE: - case ENUMERAL_TYPE: - case UNION_TYPE: - return tsubst_aggr_type_1 (t, args, complain, in_decl, entering_scope); - - default: - return tsubst (t, args, complain, in_decl); - } -} - -/* The part of tsubst_aggr_type that's shared with the RECORD_, UNION_ - and ENUMERAL_TYPE cases of tsubst. */ - -static tree -tsubst_aggr_type_1 (tree t, - tree args, - tsubst_flags_t complain, - tree in_decl, - int entering_scope) -{ - if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t)) - { - complain &= ~tf_qualifying_scope; - - /* Figure out what arguments are appropriate for the - type we are trying to find. For example, given: - - template <class T> struct S; - template <class T, class U> void f(T, U) { S<U> su; } - - and supposing that we are instantiating f<int, double>, - then our ARGS will be {int, double}, but, when looking up - S we only want {double}. */ - tree argvec = tsubst_template_args (TYPE_TI_ARGS (t), args, - complain, in_decl); - if (argvec == error_mark_node) - return error_mark_node; - - tree r = lookup_template_class (t, argvec, in_decl, NULL_TREE, - entering_scope, complain); - return cp_build_qualified_type (r, cp_type_quals (t), complain); - } - else - /* This is not a template type, so there's nothing to do. */ - return t; -} - /* Map from a FUNCTION_DECL to a vec of default argument instantiations, indexed in reverse order of the parameters. */ @@ -14601,8 +14538,7 @@ tsubst_function_decl (tree t, tree args, tsubst_flags_t complain, lambda_fntype = static_fn_type (lambda_fntype); if (member && !closure) - ctx = tsubst_aggr_type (ctx, args, - complain, t, /*entering_scope=*/1); + ctx = tsubst_entering_scope (ctx, args, complain, t); tree type = (lambda_fntype ? lambda_fntype : tsubst (TREE_TYPE (t), args, @@ -14996,8 +14932,7 @@ tsubst_template_decl (tree t, tree args, tsubst_flags_t complain, inner = TREE_TYPE (inner); } if (class_p) - inner = tsubst_aggr_type (inner, args, complain, - in_decl, /*entering*/1); + inner = tsubst_entering_scope (inner, args, complain, in_decl); else inner = tsubst_decl (inner, args, complain, /*use_spec_table=*/false); } @@ -15501,9 +15436,7 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain, local_p = false; if (DECL_CLASS_SCOPE_P (t)) { - ctx = tsubst_aggr_type (ctx, args, - complain, - in_decl, /*entering_scope=*/1); + ctx = tsubst_entering_scope (ctx, args, complain, in_decl); if (DECL_SELF_REFERENCE_P (t)) /* The context and type of an injected-class-name are the same, so we don't need to substitute both. */ @@ -16299,8 +16232,29 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) /* Fall through. */ case UNION_TYPE: case ENUMERAL_TYPE: - return tsubst_aggr_type_1 (t, args, complain, in_decl, - /*entering_scope=*/0); + if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t)) + { + /* Figure out what arguments are appropriate for the + type we are trying to find. For example, given: + + template <class T> struct S; + template <class T, class U> void f(T, U) { S<U> su; } + + and supposing that we are instantiating f<int, double>, + then our ARGS will be {int, double}, but, when looking up + S we only want {double}. */ + tree argvec = tsubst_template_args (TYPE_TI_ARGS (t), args, + complain, in_decl); + if (argvec == error_mark_node) + return error_mark_node; + + tree r = lookup_template_class (t, argvec, in_decl, NULL_TREE, + complain); + return cp_build_qualified_type (r, cp_type_quals (t), complain); + } + else + /* This is not a template type, so there's nothing to do. */ + return t; case ERROR_MARK: case IDENTIFIER_NODE: @@ -16492,7 +16446,6 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) r = lookup_template_class (arg, argvec, in_decl, DECL_CONTEXT (arg), - /*entering_scope=*/0, complain); return cp_build_qualified_type (r, cp_type_quals (t) | cp_type_quals (r), complain); @@ -16584,7 +16537,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) if (argvec == error_mark_node) return error_mark_node; r = lookup_template_class (tmpl, argvec, in_decl, NULL_TREE, - /*entering_scope=*/false, complain); + complain); r = cp_build_qualified_type (r, cp_type_quals (t), complain); break; } @@ -16839,9 +16792,9 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) ctx = TREE_VEC_ELT (ctx, 0); } else - ctx = tsubst_aggr_type (ctx, args, - complain | tf_qualifying_scope, - in_decl, /*entering_scope=*/1); + ctx = tsubst_entering_scope (ctx, args, + complain | tf_qualifying_scope, + in_decl); if (ctx == error_mark_node) return error_mark_node; @@ -16914,8 +16867,10 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) case UNBOUND_CLASS_TEMPLATE: { - tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain, - in_decl, /*entering_scope=*/1); + ++processing_template_decl; + tree ctx = tsubst_entering_scope (TYPE_CONTEXT (t), args, + complain, in_decl); + --processing_template_decl; tree name = TYPE_IDENTIFIER (t); tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t)); @@ -21564,9 +21519,7 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl) When we instantiate f<7>::S::g(), say, lookup_name is not clever enough to find f<7>::a. */ - enum_type - = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl, - /*entering_scope=*/0); + enum_type = tsubst (DECL_CONTEXT (t), args, complain, in_decl); for (v = TYPE_VALUES (enum_type); v != NULL_TREE; @@ -21586,8 +21539,8 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl) { tree ctx; - ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl, - /*entering_scope=*/1); + ctx = tsubst_entering_scope (DECL_CONTEXT (t), args, + complain, in_decl); if (ctx != DECL_CONTEXT (t)) { tree r = lookup_field (ctx, DECL_NAME (t), 0, false); @@ -21630,8 +21583,8 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl) TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we have to substitute this with one having context `D<int>'. */ - tree context = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, - in_decl, /*entering_scope=*/true); + tree context = tsubst_entering_scope (DECL_CONTEXT (t), args, + complain, in_decl); RETURN (lookup_field (context, DECL_NAME(t), 0, false)); } else @@ -22161,8 +22114,8 @@ instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain) already non-dependent, then we might as well use it. */ ctx = DECL_CONTEXT (tmpl); else - ctx = tsubst_aggr_type (DECL_CONTEXT (gen_tmpl), targ_ptr, - complain, gen_tmpl, true); + ctx = tsubst_entering_scope (DECL_CONTEXT (gen_tmpl), targ_ptr, + complain, gen_tmpl); push_nested_class (ctx); } @@ -29324,8 +29277,8 @@ resolve_typename_type (tree type, bool only_current_p) tree args = TREE_OPERAND (fullname, 1); /* Instantiate the template. */ result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE, - /*entering_scope=*/true, tf_error | tf_user); + result = adjust_type_for_entering_scope (result); if (result == error_mark_node) result = NULL_TREE; } @@ -29564,7 +29517,7 @@ listify (tree arg) TREE_VEC_ELT (argvec, 0) = arg; return lookup_template_class (std_init_list, argvec, NULL_TREE, - NULL_TREE, 0, tf_warning_or_error); + NULL_TREE, tf_warning_or_error); } /* Replace auto in TYPE with std::initializer_list<auto>. */ @@ -30510,7 +30463,7 @@ alias_ctad_tweaks (tree tmpl, tree uguides) fprime = copy_decl (fprime); tree fntype = TREE_TYPE (fprime); ret = lookup_template_class (TPARMS_PRIMARY_TEMPLATE (atparms), targs, - in_decl, NULL_TREE, false, complain); + in_decl, NULL_TREE, complain); fntype = build_function_type (ret, TYPE_ARG_TYPES (fntype)); TREE_TYPE (fprime) = fntype; if (TREE_CODE (fprime) == TEMPLATE_DECL) diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index 2dde65a970b..d0fa324fe5c 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -4011,8 +4011,10 @@ finish_template_type (tree name, tree args, int entering_scope) tree type; type = lookup_template_class (name, args, - NULL_TREE, NULL_TREE, entering_scope, + NULL_TREE, NULL_TREE, tf_warning_or_error | tf_user); + if (entering_scope) + type = adjust_type_for_entering_scope (type); /* If we might be entering the scope of a partial specialization, find the one with the right constraints. */
reply other threads:[~2024-05-03 1:14 UTC|newest] Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20240503011450.04311385E836@sourceware.org \ --to=ppalka@gcc.gnu.org \ --cc=gcc-cvs@gcc.gnu.org \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).