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

On Wed, Dec 01, 2021 at 11:16:27PM -0500, Jason Merrill wrote:
> On 12/1/21 10:16, Marek Polacek wrote:
> > 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
> 
> Agreed, that code is dead since r9-1417.
> 
> > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk and 11?
> > 
> > 	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.  Also
> > 	REF_PARENTHESIZED_P for REFERENCE_REF_P.
> > 	* 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.
> > ---
> >   gcc/cp/cp-gimplify.c                        |  3 ++-
> >   gcc/cp/pt.c                                 |  5 ++---
> >   gcc/cp/semantics.c                          | 18 ++++--------------
> >   gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C | 12 ++++++++++++
> >   gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C | 12 ++++++++++++
> >   5 files changed, 32 insertions(+), 18 deletions(-)
> >   create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C
> >   create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C
> > 
> > diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
> > index 0a002db14e7..e3ede02a48e 100644
> > --- a/gcc/cp/cp-gimplify.c
> > +++ b/gcc/cp/cp-gimplify.c
> > @@ -2421,7 +2421,8 @@ cp_fold (tree x)
> >         if (REF_PARENTHESIZED_P (x))
> >   	{
> >   	  tree p = maybe_undo_parenthesized_ref (x);
> > -	  return cp_fold (p);
> > +	  if (p != x)
> > +	    return cp_fold (p);
> >   	}
> >         goto unary;
> > diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
> > index f4b9d9673fb..c5b41b57028 100644
> > --- a/gcc/cp/pt.c
> > +++ b/gcc/cp/pt.c
> > @@ -29889,11 +29889,10 @@ do_auto_deduction (tree type, tree init, tree auto_node,
> >     else if (AUTO_IS_DECLTYPE (auto_node))
> >       {
> >         tree stripped_init = tree_strip_any_location_wrapper (init);
> > -      if (REFERENCE_REF_P (stripped_init))
> > -	stripped_init = TREE_OPERAND (stripped_init, 0);
> >         bool id = (DECL_P (stripped_init)
> >   		 || ((TREE_CODE (init) == COMPONENT_REF
> > -		      || TREE_CODE (init) == SCOPE_REF)
> > +		      || TREE_CODE (init) == SCOPE_REF
> > +		      || REFERENCE_REF_P (init))
> >   		     && !REF_PARENTHESIZED_P (init)));
> 
> This change seems wrong; not all references are id-expressions or member
> accesses.  For instance, a call to a function returning a reference is not.
> I think we still want to depend on the TREE_CODE, but we need to look at the
> TREE_CODE of stripped_init, not init.

Yes indeed, id was wrong.  I didn't notice because we still deduced to the
right type!

This version only strips REFERENCE_REF_P when they aren't REF_PARENTHESIZED_P,
so that, as the comment says, I can tell '(r)' and 'r' apart.  Since we can
deduce the correct type even with the wrong id, I tested this by using the
two functions in decltype-auto4.C, and adding gcc_assert(id) or !id so that
I can verify that id looks correct with this patch.

Also add a new test case: decltype-auto4.C.  It would still be nice to test
more; I'm not sure how well we test [dcl.type.decltype]/1.1 and /1.2.  I'm
also adding decomp-decltype1.C, which fixes decltype + structured binding.

Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk / 11?

-- >8 --
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.
---
 gcc/cp/cp-gimplify.c                          |  3 +-
 gcc/cp/pt.c                                   | 15 +++--
 gcc/cp/semantics.c                            | 18 ++---
 gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C   | 12 ++++
 gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C   | 12 ++++
 gcc/testsuite/g++.dg/cpp1y/decltype-auto4.C   | 65 +++++++++++++++++++
 gcc/testsuite/g++.dg/cpp1z/decomp-decltype1.C | 28 ++++++++
 7 files changed, 133 insertions(+), 20 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C
 create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C
 create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto4.C
 create mode 100644 gcc/testsuite/g++.dg/cpp1z/decomp-decltype1.C


base-commit: c841dc0a4dd944cf8f76f414a286aedff1e38dce

On 12/2/21 18:12, Marek Polacek wrote:
> On Wed, Dec 01, 2021 at 11:16:27PM -0500, Jason Merrill wrote:
>> On 12/1/21 10:16, Marek Polacek wrote:
>>> 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
>>
>> Agreed, that code is dead since r9-1417.
>>
>>> Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk and 11?
>>>
>>> 	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.  Also
>>> 	REF_PARENTHESIZED_P for REFERENCE_REF_P.
>>> 	* 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.
>>> ---
>>>    gcc/cp/cp-gimplify.c                        |  3 ++-
>>>    gcc/cp/pt.c                                 |  5 ++---
>>>    gcc/cp/semantics.c                          | 18 ++++--------------
>>>    gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C | 12 ++++++++++++
>>>    gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C | 12 ++++++++++++
>>>    5 files changed, 32 insertions(+), 18 deletions(-)
>>>    create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C
>>>    create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C
>>>
>>> diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
>>> index 0a002db14e7..e3ede02a48e 100644
>>> --- a/gcc/cp/cp-gimplify.c
>>> +++ b/gcc/cp/cp-gimplify.c
>>> @@ -2421,7 +2421,8 @@ cp_fold (tree x)
>>>          if (REF_PARENTHESIZED_P (x))
>>>    	{
>>>    	  tree p = maybe_undo_parenthesized_ref (x);
>>> -	  return cp_fold (p);
>>> +	  if (p != x)
>>> +	    return cp_fold (p);
>>>    	}
>>>          goto unary;
>>> diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
>>> index f4b9d9673fb..c5b41b57028 100644
>>> --- a/gcc/cp/pt.c
>>> +++ b/gcc/cp/pt.c
>>> @@ -29889,11 +29889,10 @@ do_auto_deduction (tree type, tree init, tree auto_node,
>>>      else if (AUTO_IS_DECLTYPE (auto_node))
>>>        {
>>>          tree stripped_init = tree_strip_any_location_wrapper (init);
>>> -      if (REFERENCE_REF_P (stripped_init))
>>> -	stripped_init = TREE_OPERAND (stripped_init, 0);
>>>          bool id = (DECL_P (stripped_init)
>>>    		 || ((TREE_CODE (init) == COMPONENT_REF
>>> -		      || TREE_CODE (init) == SCOPE_REF)
>>> +		      || TREE_CODE (init) == SCOPE_REF
>>> +		      || REFERENCE_REF_P (init))
>>>    		     && !REF_PARENTHESIZED_P (init)));
>>
>> This change seems wrong; not all references are id-expressions or member
>> accesses.  For instance, a call to a function returning a reference is not.
>> I think we still want to depend on the TREE_CODE, but we need to look at the
>> TREE_CODE of stripped_init, not init.
> 
> Yes indeed, id was wrong.  I didn't notice because we still deduced to the
> right type!
> 
> This version only strips REFERENCE_REF_P when they aren't REF_PARENTHESIZED_P,
> so that, as the comment says, I can tell '(r)' and 'r' apart.  Since we can
> deduce the correct type even with the wrong id, I tested this by using the
> two functions in decltype-auto4.C, and adding gcc_assert(id) or !id so that
> I can verify that id looks correct with this patch.
> 
> Also add a new test case: decltype-auto4.C.  It would still be nice to test
> more; I'm not sure how well we test [dcl.type.decltype]/1.1 and /1.2.  I'm
> also adding decomp-decltype1.C, which fixes decltype + structured binding.
> 
> Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk / 11?

OK.

> -- >8 --
> 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.
> ---
>   gcc/cp/cp-gimplify.c                          |  3 +-
>   gcc/cp/pt.c                                   | 15 +++--
>   gcc/cp/semantics.c                            | 18 ++---
>   gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C   | 12 ++++
>   gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C   | 12 ++++
>   gcc/testsuite/g++.dg/cpp1y/decltype-auto4.C   | 65 +++++++++++++++++++
>   gcc/testsuite/g++.dg/cpp1z/decomp-decltype1.C | 28 ++++++++
>   7 files changed, 133 insertions(+), 20 deletions(-)
>   create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C
>   create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C
>   create mode 100644 gcc/testsuite/g++.dg/cpp1y/decltype-auto4.C
>   create mode 100644 gcc/testsuite/g++.dg/cpp1z/decomp-decltype1.C
> 
> diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
> index 0a002db14e7..e3ede02a48e 100644
> --- a/gcc/cp/cp-gimplify.c
> +++ b/gcc/cp/cp-gimplify.c
> @@ -2421,7 +2421,8 @@ cp_fold (tree x)
>         if (REF_PARENTHESIZED_P (x))
>   	{
>   	  tree p = maybe_undo_parenthesized_ref (x);
> -	  return cp_fold (p);
> +	  if (p != x)
> +	    return cp_fold (p);
>   	}
>         goto unary;
>   
> diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
> index 6b560952639..d3efc6ea238 100644
> --- a/gcc/cp/pt.c
> +++ b/gcc/cp/pt.c
> @@ -29889,13 +29889,18 @@ do_auto_deduction (tree type, tree init, tree auto_node,
>       }
>     else if (AUTO_IS_DECLTYPE (auto_node))
>       {
> +      /* Figure out if INIT is an unparenthesized id-expression or an
> +	 unparenthesized class member access.  */
>         tree stripped_init = tree_strip_any_location_wrapper (init);
> -      if (REFERENCE_REF_P (stripped_init))
> +      /* We need to be able to tell '(r)' and 'r' apart (when it's of
> +	 reference type).  Only the latter is an id-expression.  */
> +      if (REFERENCE_REF_P (stripped_init)
> +	  && !REF_PARENTHESIZED_P (stripped_init))
>   	stripped_init = TREE_OPERAND (stripped_init, 0);
> -      bool id = (DECL_P (stripped_init)
> -		 || ((TREE_CODE (init) == COMPONENT_REF
> -		      || TREE_CODE (init) == SCOPE_REF)
> -		     && !REF_PARENTHESIZED_P (init)));
> +      const bool id = (DECL_P (stripped_init)
> +		       || ((TREE_CODE (stripped_init) == COMPONENT_REF
> +			    || TREE_CODE (stripped_init) == SCOPE_REF)
> +			   && !REF_PARENTHESIZED_P (stripped_init)));
>         tree deduced = finish_decltype_type (init, id, complain);
>         deduced = canonicalize_type_argument (deduced, complain);
>         if (deduced == error_mark_node)
> diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
> index cd1956497f8..edba4b60e10 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;
> diff --git a/gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C b/gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C
> new file mode 100644
> index 00000000000..56e011e36f4
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/cpp1y/decltype-auto2.C
> @@ -0,0 +1,12 @@
> +// PR c++/103403
> +// { dg-do compile { target c++14 } }
> +
> +template<typename T>
> +auto constexpr RtoL1(T&& r) -> decltype(auto) {
> +    return (r);
> +};
> +int main() {
> +    int t;
> +    int x{3};
> +    decltype (RtoL1(x+0)) y = t;
> +}
> diff --git a/gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C b/gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C
> new file mode 100644
> index 00000000000..914e87f5b79
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/cpp1y/decltype-auto3.C
> @@ -0,0 +1,12 @@
> +// PR c++/103403
> +// { dg-do compile { target c++14 } }
> +
> +int main()
> +{
> +  int i = 1;
> +  int&& r = 1;
> +
> +  decltype(auto) ri = (i);
> +  decltype(auto) rr = (r);
> +  decltype((r)) rr2 = (r);
> +}
> diff --git a/gcc/testsuite/g++.dg/cpp1y/decltype-auto4.C b/gcc/testsuite/g++.dg/cpp1y/decltype-auto4.C
> new file mode 100644
> index 00000000000..9765857efb1
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/cpp1y/decltype-auto4.C
> @@ -0,0 +1,65 @@
> +// PR c++/103403
> +// { dg-do compile { target c++14 } }
> +
> +struct false_type { static constexpr bool value = false; };
> +struct true_type { static constexpr bool value = true; };
> +template<class T, class U>
> +struct is_same : false_type {};
> +template<class T>
> +struct is_same<T, T> : true_type {};
> +
> +int fn ();
> +int &ref ();
> +int &&rref ();
> +
> +struct S {
> +  int i;
> +  int &r = i;
> +};
> +
> +void
> +ids ()
> +{
> +  const S *s = new S();
> +  int i;
> +  int &ir = i;
> +  decltype(auto) r1 = s->i;
> +  static_assert (is_same<decltype(r1), int>::value, "");
> +  decltype(auto) r2 = s->r;
> +  static_assert (is_same<decltype(r2), int&>::value, "");
> +  decltype(auto) r3 = i;
> +  static_assert (is_same<decltype(r3), int>::value, "");
> +  decltype(auto) r4 = ir;
> +  static_assert (is_same<decltype(r4), int&>::value, "");
> +}
> +
> +void
> +nonids ()
> +{
> +  const S *s = new S();
> +  int i;
> +  int &ir = i;
> +  int &&irr = 42;
> +  decltype(auto) r1 = fn ();
> +  static_assert (is_same<decltype(r1), int>::value, "");
> +  decltype(auto) r2 = (fn ());
> +  static_assert (is_same<decltype(r2), int>::value, "");
> +  decltype(auto) r3 = ref ();
> +  static_assert (is_same<decltype(r3), int&>::value, "");
> +  decltype(auto) r4 = (ref ());
> +  static_assert (is_same<decltype(r4), int&>::value, "");
> +  decltype(auto) r5 = rref ();
> +  static_assert (is_same<decltype(r5), int&&>::value, "");
> +  decltype(auto) r6 = (rref ());
> +  static_assert (is_same<decltype(r6), int&&>::value, "");
> +  decltype(auto) r8 = (s->i);
> +  static_assert (is_same<decltype(r8), const int&>::value, "");
> +  decltype(auto) r9 = (s->r);
> +  static_assert (is_same<decltype(r9), int&>::value, "");
> +  decltype(auto) r10 = (i);
> +  static_assert (is_same<decltype(r10), int&>::value, "");
> +  decltype(auto) r11 = (ir);
> +  static_assert (is_same<decltype(r11), int&>::value, "");
> +  decltype(auto) r12 = (irr);
> +  static_assert (is_same<decltype(r12), int&>::value, "");
> +}
> diff --git a/gcc/testsuite/g++.dg/cpp1z/decomp-decltype1.C b/gcc/testsuite/g++.dg/cpp1z/decomp-decltype1.C
> new file mode 100644
> index 00000000000..e8ca0fc0bee
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/cpp1z/decomp-decltype1.C
> @@ -0,0 +1,28 @@
> +// PR c++/81176
> +// { dg-do compile { target c++17 } }
> +
> +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 <class,class> struct same_type;
> +template <class T> struct same_type<T,T> {};
> +
> +void
> +foo (A x)
> +{
> +  auto [ a, b ] = x;
> +  decltype(auto) c = a;
> +  same_type<decltype(a), int>{};
> +  same_type<decltype(c), int>{};
> +}
> +
> 
> base-commit: c841dc0a4dd944cf8f76f414a286aedff1e38dce
>