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.
tree deduced = finish_decltype_type (init, id, complain);
deduced = canonicalize_type_argument (deduced, complain);
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);
+}
base-commit: 1e625a44f6f3001cea31e0f7c563943ecba92b68