c++: Fix up decltype of non-dependent structured binding decl in template [PR92687]

Message ID ZeBvly7jWPZV4YRW@tucnak
State Unresolved
Headers
Series c++: Fix up decltype of non-dependent structured binding decl in template [PR92687] |

Checks

Context Check Description
snail/gcc-patch-check warning Git am fail log

Commit Message

Jakub Jelinek Feb. 29, 2024, 11:50 a.m. UTC
  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
  

Patch

--- gcc/cp/decl.cc.jj	2024-02-28 08:41:18.486493565 +0100
+++ gcc/cp/decl.cc	2024-02-28 15:10:47.555186301 +0100
@@ -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;
+	  }
     }
 }
 
--- gcc/cp/semantics.cc.jj	2024-02-10 09:38:25.871982914 +0100
+++ gcc/cp/semantics.cc	2024-02-28 15:08:01.026496157 +0100
@@ -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);
--- gcc/testsuite/g++.dg/cpp1z/decomp59.C.jj	2024-02-28 15:14:38.846978129 +0100
+++ gcc/testsuite/g++.dg/cpp1z/decomp59.C	2024-02-28 15:22:45.611226413 +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> ();
+}