Message ID | ZeGJ/wYbYVMu5JWz@tucnak |
---|---|
State | New |
Headers | show |
Series | c++, v2: Fix up decltype of non-dependent structured binding decl in template [PR92687] | expand |
On 3/1/24 02:55, Jakub Jelinek wrote: > On Thu, Feb 29, 2024 at 12:50:47PM +0100, Jakub Jelinek wrote: >> finish_decltype_type uses DECL_HAS_VALUE_EXPR_P (expr) check for >> DECL_DECOMPOSITION_P (expr) to determine if it is >> array/struct/vector/complex etc. subobject proxy case vs. structured >> binding using std::tuple_{size,element}. >> For non-templates or when templates are already instantiated, that works >> correctly, finalized DECL_DECOMPOSITION_P non-base vars indeed have >> DECL_VALUE_EXPR in the former case and don't have it in the latter. >> It works fine for dependent structured bindings as well, cp_finish_decomp in >> that case creates DECLTYPE_TYPE tree and defers the handling until >> instantiation. >> As the testcase shows, this doesn't work for the non-dependent structured >> binding case in templates, because DECL_HAS_VALUE_EXPR_P is set in that case >> always; cp_finish_decomp ends with: >> if (processing_template_decl) >> { >> for (unsigned int i = 0; i < count; i++) >> if (!DECL_HAS_VALUE_EXPR_P (v[i])) >> { >> tree a = build_nt (ARRAY_REF, decl, size_int (i), >> NULL_TREE, NULL_TREE); >> SET_DECL_VALUE_EXPR (v[i], a); >> DECL_HAS_VALUE_EXPR_P (v[i]) = 1; >> } >> } >> and those artificial ARRAY_REFs are used in various places during >> instantiation to find out what base the DECL_DECOMPOSITION_P VAR_DECLs >> have and their positions. > >> Another option would be to change >> tree >> lookup_decomp_type (tree v) >> { >> - return *decomp_type_table->get (v); >> + if (tree *slot = decomp_type_table->get (v)) >> + return *slot; >> + return NULL_TREE; >> } >> >> and in finish_decl_decomp either just in the ptds.saved case or always >> try to lookup_decomp_type, if it returns non-NULL, return what it returned, >> otherwise return unlowered_expr_type (expr). I guess it would be cleaner, >> I thought it would be more costly due to the hash table lookup, but now that >> I think about it again, DECL_VALUE_EXPR is a hash table lookup as well. >> So maybe then >> + if (ptds.saved) >> + { >> + gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (expr)); >> + /* DECL_HAS_VALUE_EXPR_P is always set if >> + processing_template_decl. If lookup_decomp_type >> + returns non-NULL, it is the tuple case. */ >> + if (tree ret = lookup_decomp_type (expr)) >> + return ret; >> + } >> if (DECL_HAS_VALUE_EXPR_P (expr)) >> /* Expr is an array or struct subobject proxy, handle >> bit-fields properly. */ >> return unlowered_expr_type (expr); >> else >> /* Expr is a reference variable for the tuple case. */ >> return lookup_decomp_type (expr); > > Here is a variant of the patch which does that. > > Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk? OK. > Or the other version, or adding some flag to the DECL_DECOMPOSITION_P > decls? > > 2024-03-01 Jakub Jelinek <jakub@redhat.com> > > PR c++/92687 > * decl.cc (lookup_decomp_type): Return NULL_TREE if decomp_type_table > doesn't have entry for V. > * semantics.cc (finish_decltype_type): If ptds.saved, assert > DECL_HAS_VALUE_EXPR_P is true and decide on tuple vs. non-tuple based > on if lookup_decomp_type is NULL or not. > > * g++.dg/cpp1z/decomp59.C: New test. > > --- gcc/cp/decl.cc.jj 2024-02-28 23:20:01.004751204 +0100 > +++ gcc/cp/decl.cc 2024-02-29 20:03:11.087218176 +0100 > @@ -9262,7 +9262,9 @@ static GTY((cache)) decl_tree_cache_map > tree > lookup_decomp_type (tree v) > { > - return *decomp_type_table->get (v); > + if (tree *slot = decomp_type_table->get (v)) > + return *slot; > + return NULL_TREE; > } > > /* Mangle a decomposition declaration if needed. Arguments like > --- gcc/cp/semantics.cc.jj 2024-02-28 22:57:08.101800588 +0100 > +++ gcc/cp/semantics.cc 2024-02-29 20:04:51.936880622 +0100 > @@ -11804,6 +11804,15 @@ finish_decltype_type (tree expr, bool id > access expression). */ > if (DECL_DECOMPOSITION_P (expr)) > { > + if (ptds.saved) > + { > + gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (expr)); > + /* DECL_HAS_VALUE_EXPR_P is always set if > + processing_template_decl. If lookup_decomp_type > + returns non-NULL, it is the tuple case. */ > + if (tree ret = lookup_decomp_type (expr)) > + return ret; > + } > if (DECL_HAS_VALUE_EXPR_P (expr)) > /* Expr is an array or struct subobject proxy, handle > bit-fields properly. */ > --- gcc/testsuite/g++.dg/cpp1z/decomp59.C.jj 2024-02-29 20:02:17.467929327 +0100 > +++ gcc/testsuite/g++.dg/cpp1z/decomp59.C 2024-02-29 20:02:17.467929327 +0100 > @@ -0,0 +1,63 @@ > +// PR c++/92687 > +// { dg-do compile { target c++11 } } > +// { dg-options "" } > + > +namespace std { > + template<typename T> struct tuple_size; > + template<int, typename> struct tuple_element; > +} > + > +struct A { > + int i; > + template <int I> int& get() { return i; } > +}; > + > +template<> struct std::tuple_size<A> { static const int value = 2; }; > +template<int I> struct std::tuple_element<I,A> { using type = int; }; > + > +template<typename T> > +struct is_reference { > + static const bool value = false; > +}; > + > +template<typename T> > +struct is_reference<T&> > +{ > + static const bool value = true; > +}; > + > +template<typename T> > +struct is_reference<T&&> > +{ > + static const bool value = true; > +}; > + > +template<int N> > +void > +foo () > +{ > + auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } } > + static_assert (!is_reference<decltype (x)>::value, ""); > +} > + > +void > +bar () > +{ > + auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } } > + static_assert (!is_reference<decltype (x)>::value, ""); > +} > + > +template<typename T> > +void > +baz () > +{ > + auto [x, y] = T {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } } > + static_assert (!is_reference<decltype (x)>::value, ""); > +} > + > +void > +qux () > +{ > + foo<0> (); > + baz<A> (); > +} > > > Jakub >
--- gcc/cp/decl.cc.jj 2024-02-28 23:20:01.004751204 +0100 +++ gcc/cp/decl.cc 2024-02-29 20:03:11.087218176 +0100 @@ -9262,7 +9262,9 @@ static GTY((cache)) decl_tree_cache_map tree lookup_decomp_type (tree v) { - return *decomp_type_table->get (v); + if (tree *slot = decomp_type_table->get (v)) + return *slot; + return NULL_TREE; } /* Mangle a decomposition declaration if needed. Arguments like --- gcc/cp/semantics.cc.jj 2024-02-28 22:57:08.101800588 +0100 +++ gcc/cp/semantics.cc 2024-02-29 20:04:51.936880622 +0100 @@ -11804,6 +11804,15 @@ finish_decltype_type (tree expr, bool id access expression). */ if (DECL_DECOMPOSITION_P (expr)) { + if (ptds.saved) + { + gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (expr)); + /* DECL_HAS_VALUE_EXPR_P is always set if + processing_template_decl. If lookup_decomp_type + returns non-NULL, it is the tuple case. */ + if (tree ret = lookup_decomp_type (expr)) + return ret; + } if (DECL_HAS_VALUE_EXPR_P (expr)) /* Expr is an array or struct subobject proxy, handle bit-fields properly. */ --- gcc/testsuite/g++.dg/cpp1z/decomp59.C.jj 2024-02-29 20:02:17.467929327 +0100 +++ gcc/testsuite/g++.dg/cpp1z/decomp59.C 2024-02-29 20:02:17.467929327 +0100 @@ -0,0 +1,63 @@ +// PR c++/92687 +// { dg-do compile { target c++11 } } +// { dg-options "" } + +namespace std { + template<typename T> struct tuple_size; + template<int, typename> struct tuple_element; +} + +struct A { + int i; + template <int I> int& get() { return i; } +}; + +template<> struct std::tuple_size<A> { static const int value = 2; }; +template<int I> struct std::tuple_element<I,A> { using type = int; }; + +template<typename T> +struct is_reference { + static const bool value = false; +}; + +template<typename T> +struct is_reference<T&> +{ + static const bool value = true; +}; + +template<typename T> +struct is_reference<T&&> +{ + static const bool value = true; +}; + +template<int N> +void +foo () +{ + auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } } + static_assert (!is_reference<decltype (x)>::value, ""); +} + +void +bar () +{ + auto [x, y] = A {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } } + static_assert (!is_reference<decltype (x)>::value, ""); +} + +template<typename T> +void +baz () +{ + auto [x, y] = T {}; // { dg-warning "structured bindings only available with" "" { target c++14_down } } + static_assert (!is_reference<decltype (x)>::value, ""); +} + +void +qux () +{ + foo<0> (); + baz<A> (); +}