c++: Fix for decltype(auto) and parenthesized expr [PR103403]

In r11-4758, I tried to fix this problem:

  int &&i = 0;
  decltype(auto) j = i; // should behave like int &&j = i; error

wherein do_auto_deduction was getting confused with a REFERENCE_REF_P
and it didn't realize its operand was a name, not an expression, and
deduced the wrong type.

Unfortunately that fix broke this:

  int&& r = 1;
  decltype(auto) rr = (r);

where 'rr' should be 'int &' since '(r)' is an expression, not a name.  But
because I stripped the INDIRECT_REF with the r11-4758 change, we deduced
'rr's type as if decltype had gotten a name, resulting in 'int &&'.

I suspect I thought that the REF_PARENTHESIZED_P check when setting
'bool id' in do_auto_deduction would handle the (r) case, but that's not
the case; while the documentation for REF_PARENTHESIZED_P specifically says
it can be set in INDIRECT_REF, we don't actually do so.

This patch sets REF_PARENTHESIZED_P even on REFERENCE_REF_P, so that
do_auto_deduction can use it.

It also removes code in maybe_undo_parenthesized_ref that I think is
dead -- and we don't hit it while running dg.exp.  To adduce more data,
it also looks dead here:
https://splichal.eu/lcov/gcc/cp/semantics.c.gcov.html
(It's dead since r9-1417.)

Also add a fixed test for c++/81176.

	PR c++/103403

gcc/cp/ChangeLog:

	* cp-gimplify.c (cp_fold): Don't recurse if maybe_undo_parenthesized_ref
	doesn't change its argument.
	* pt.c (do_auto_deduction): Don't strip REFERENCE_REF_P trees if they
	are REF_PARENTHESIZED_P.  Use stripped_init when checking for
	id-expression.
	* semantics.c (force_paren_expr): Set REF_PARENTHESIZED_P on
	REFERENCE_REF_P trees too.
	(maybe_undo_parenthesized_ref): Remove dead code.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp1y/decltype-auto2.C: New test.
	* g++.dg/cpp1y/decltype-auto3.C: New test.
	* g++.dg/cpp1y/decltype-auto4.C: New test.
	* g++.dg/cpp1z/decomp-decltype1.C: New test.

1 files changed, 4 insertions, 14 deletions

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index cd19564..edba4b6 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -2049,7 +2049,8 @@ force_paren_expr (tree expr, bool even_uneval)
     return expr;
 
   if (TREE_CODE (expr) == COMPONENT_REF
-      || TREE_CODE (expr) == SCOPE_REF)
+      || TREE_CODE (expr) == SCOPE_REF
+      || REFERENCE_REF_P (expr))
     REF_PARENTHESIZED_P (expr) = true;
   else if (DECL_P (tree_strip_any_location_wrapper (expr)))
     {
@@ -2072,19 +2073,8 @@ maybe_undo_parenthesized_ref (tree t)
   if (cxx_dialect < cxx14)
     return t;
 
-  if (INDIRECT_REF_P (t) && REF_PARENTHESIZED_P (t))
-    {
-      t = TREE_OPERAND (t, 0);
-      while (TREE_CODE (t) == NON_LVALUE_EXPR
-	     || TREE_CODE (t) == NOP_EXPR)
-	t = TREE_OPERAND (t, 0);
-
-      gcc_assert (TREE_CODE (t) == ADDR_EXPR
-		  || TREE_CODE (t) == STATIC_CAST_EXPR);
-      t = TREE_OPERAND (t, 0);
-    }
-  else if ((TREE_CODE (t) == PAREN_EXPR || TREE_CODE (t) == VIEW_CONVERT_EXPR)
-	     && REF_PARENTHESIZED_P (t))
+  if ((TREE_CODE (t) == PAREN_EXPR || TREE_CODE (t) == VIEW_CONVERT_EXPR)
+      && REF_PARENTHESIZED_P (t))
     t = TREE_OPERAND (t, 0);
 
   return t;