diff options
author | Jakub Jelinek <jakub@redhat.com> | 2024-03-01 16:59:08 +0100 |
---|---|---|
committer | Jakub Jelinek <jakub@redhat.com> | 2024-03-01 17:27:58 +0100 |
commit | 867cbadb912ab75d0eaf919a3f992595e508482b (patch) | |
tree | 463ad5ee97f7b8c91ec4d83f8c9beb8fe6d122d7 | |
parent | 4f82d5a95a244d0aa4f8b2541b47a21bce8a191b (diff) |
c++: Fix up decltype of non-dependent structured binding decl in template [PR92687]
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.
The following patch fixes that by changing lookup_decomp_type, such that
it doesn't ICE when called on a DECL_DECOMPOSITION_P var which isn't in a
hash table, but returns NULL_TREE in that case, and for processing_template_decl
asserts DECL_HAS_VALUE_EXPR_P is non-NULL and just calls lookup_decomp_type.
If it returns non-NULL, it is a structured binding using tuple and its result
is returned, otherwise it falls through to returning unlowered_expr_type (expr)
because it is an array, structure etc. subobject proxy.
For !processing_template_decl it keeps doing what it did before,
DECL_HAS_VALUE_EXPR_P meaning it is an array/structure etc. subobject proxy,
otherwise the tuple case.
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.
-rw-r--r-- | gcc/cp/decl.cc | 4 | ||||
-rw-r--r-- | gcc/cp/semantics.cc | 9 | ||||
-rw-r--r-- | gcc/testsuite/g++.dg/cpp1z/decomp59.C | 63 |
3 files changed, 75 insertions, 1 deletions
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc index 05e4600c7bb..993d7ef4d2b 100644 --- a/gcc/cp/decl.cc +++ b/gcc/cp/decl.cc @@ -9262,7 +9262,9 @@ static GTY((cache)) decl_tree_cache_map *decomp_type_table; 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 diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index 57840176863..adb1ba48d29 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -11804,6 +11804,15 @@ finish_decltype_type (tree expr, bool id_expression_or_member_access_p, 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. */ diff --git a/gcc/testsuite/g++.dg/cpp1z/decomp59.C b/gcc/testsuite/g++.dg/cpp1z/decomp59.C new file mode 100644 index 00000000000..52a72fa9c08 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/decomp59.C @@ -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> (); +} |