@@ -9384,6 +9384,7 @@ cp_finish_decomp (tree decl, cp_decomp *
tree eltype = NULL_TREE;
unsigned HOST_WIDE_INT eltscnt = 0;
+ bool tuple_p = false;
if (TREE_CODE (type) == ARRAY_TYPE)
{
tree nelts;
@@ -9535,6 +9536,7 @@ cp_finish_decomp (tree decl, cp_decomp *
of the individual variables. If those will be read, we'll mark
the underlying decl as read at that point. */
DECL_READ_P (decl) = save_read;
+ tuple_p = true;
}
else if (TREE_CODE (type) == UNION_TYPE)
{
@@ -9607,14 +9609,25 @@ cp_finish_decomp (tree decl, cp_decomp *
}
if (processing_template_decl)
{
+ /* For non-dependent structured bindings using std::tuple_size
+ and std::tuple_element, remember that in third operand of
+ the DECL_VALUE_EXPR ARRAY_REF for finish_decltype_type purposes. */
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);
+ tuple_p ? size_zero_node : NULL_TREE,
+ NULL_TREE);
SET_DECL_VALUE_EXPR (v[i], a);
DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
}
+ else
+ {
+ tree vexpr = DECL_VALUE_EXPR (v[i]);
+ gcc_checking_assert (TREE_CODE (vexpr) == ARRAY_REF
+ && TREE_OPERAND (vexpr, 0) == decl);
+ TREE_OPERAND (vexpr, 2) = tuple_p ? size_zero_node : NULL_TREE;
+ }
}
}
@@ -11804,7 +11804,22 @@ finish_decltype_type (tree expr, bool id
access expression). */
if (DECL_DECOMPOSITION_P (expr))
{
- if (DECL_HAS_VALUE_EXPR_P (expr))
+ bool non_tuple_p = DECL_HAS_VALUE_EXPR_P (expr);
+ if (non_tuple_p && ptds.saved)
+ {
+ /* cp_finish_decl sets DECL_VALUE_EXPR on all
+ DECL_DECOMPOSITION_P decls, not just ones for
+ array, struct, vector, complex etc. subobject proxies.
+ The ARRAY_REFs for the tuple cases are marked with
+ non-NULL third argument. */
+ tree vexpr = DECL_VALUE_EXPR (expr);
+ if (TREE_CODE (vexpr) == ARRAY_REF
+ && DECL_P (TREE_OPERAND (vexpr, 0))
+ && DECL_DECOMPOSITION_P (TREE_OPERAND (vexpr, 0))
+ && TREE_OPERAND (vexpr, 2) == size_zero_node)
+ non_tuple_p = false;
+ }
+ if (non_tuple_p)
/* Expr is an array or struct subobject proxy, handle
bit-fields properly. */
return unlowered_expr_type (expr);
@@ -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> ();
+}
Hi! 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 it by remembering from cp_finish_decomp in the processing_template_decl case whether the structured binding uses std::tuple_{size,element} or not in a flag, which then finish_decltype_type can use. Rather than wasting a lang_decl_base bit on it or growing the size of lang_decl_decomp for it, I chose to abuse the ARRAY_REF operands; the ARRAY_REF in that case is completely artificial, will never be emitted (when the cp_finish_decomp is called on the instantiated version of it with !processing_template_decl, DECL_VALUE_EXPR/DECL_HAS_VALUE_EXPR_P is cleared), so I chose to use size_zero_node for the TREE_OPERAND (array_ref, 2) as a flag this structured binding is the tuple case (per ARRAY_REF documentation the third operand is an optional copy of TYPE_MIN_VALUE of the index type; and AFAIK everything in the C++ FE uses NULL there, it is mainly there for Ada (and the 4th argument for arrays of non-constant length elements), but all these ARRAY_REFs aren't even folded or something similar). Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk? 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); 2024-02-29 Jakub Jelinek <jakub@redhat.com> PR c++/92687 * decl.cc (cp_finish_decomp): If processing_template_decl, remember whether std::tuple_{size,element} will be used or not in third operand of DECL_VALUE_EXPR ARRAY_REF. * semantics.cc (finish_decltype_type): Use that if ptds.saved to see if lookup_decomp_type should be used. * g++.dg/cpp1z/decomp59.C: New test. Jakub