On 2/10/20 2:20 PM, Patrick Palka wrote:
This patch fixes two issues with return type deduction in the presence of an
abbreviated function template.
The first issue (PR 69448) is that if a placeholder auto return type contains
any modifiers such as & or *, then the abbreviated-function-template
compensation in splice_late_return_type does not get performed for the
underlying auto node, leading to incorrect return type deduction. This happens
because splice_late_return_type checks for a placeholder auto with is_auto,
which does not look through modifiers. This patch replaces the use of is_auto
with find_type_usage, but it first refactors find_type_usage to return a pointer
to the matched tree so that we next subsequently replace it.
The second issue (PR 80471) is that the AUTO_IS_DECLTYPE flag is not being
preserved in splice_late_return_type when compensating for an abbreviated
function template, leading to us treating a decltype(auto) return type as if it
was an auto return type. Fixed by propagating AUTO_IS_DECLTYPE. The test for
PR 80471 is adjusted to expect the correct behavior.
The comment in make_constrained_decltype_auto suggests that we should
set AUTO_IS_DECLTYPE in make_auto_1 if name == decltype_auto_identifier;
then callers won't need to worry about it.
Bootstrapped and regtested on x86_64-pc-linux-gnu, is this OK to commit?
gcc/cp/ChangeLog:
PR c++/69448
PR c++/80471
* type-utils.h (find_type_usage): Refactor to take a tree * and to
return a tree *, and update documentation accordingly.
* pt.c (splice_late_return_type): Use find_type_usage to find and
replace a possibly nested auto node. Preserve the AUTO_IS_DECLTYPE
flag when replacing the node.
(type_uses_auto): Adjust the call to find_type_usage.
gcc/testsuite/ChangeLog:
PR c++/69448
PR c++/80471
* g++.dg/concepts/abbrev3.C: New test.
* g++.dg/cpp2a/concepts-pr80471.C: Adjust a static_assert to expect the
correct behavior.
---
gcc/cp/pt.c | 26 ++++++++++++-------
gcc/cp/type-utils.h | 26 +++++++++----------
gcc/testsuite/g++.dg/concepts/abbrev3.C | 11 ++++++++
gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C | 2 +-
4 files changed, 41 insertions(+), 24 deletions(-)
create mode 100644 gcc/testsuite/g++.dg/concepts/abbrev3.C
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 2fb52caa5d4..c83aaa7c7e1 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -28904,17 +28904,21 @@ do_auto_deduction (tree type, tree init, tree
auto_node,
tree
splice_late_return_type (tree type, tree late_return_type)
{
- if (is_auto (type))
- {
- if (late_return_type)
- return late_return_type;
+ if (is_auto (type) && late_return_type)
+ return late_return_type;
It occurs to me that we could just check late_return_type here, maybe
change the is_auto test to an assert.
- tree idx = get_template_parm_index (type);
+ if (tree *auto_node = find_type_usage (&type, is_auto))
+ {
+ tree idx = get_template_parm_index (*auto_node);
if (TEMPLATE_PARM_LEVEL (idx) <= processing_template_decl)
- /* In an abbreviated function template we didn't know we were dealing
- with a function template when we saw the auto return type, so update
- it to have the correct level. */
- return make_auto_1 (TYPE_IDENTIFIER (type), true);
+ {
+ /* In an abbreviated function template we didn't know we were dealing
+ with a function template when we saw the auto return type, so
+ update it to have the correct level. */
+ tree new_node = make_auto_1 (TYPE_IDENTIFIER (*auto_node), true);
+ AUTO_IS_DECLTYPE (new_node) = AUTO_IS_DECLTYPE (*auto_node);
+ *auto_node = new_node;
+ }
}
return type;
}
@@ -28960,8 +28964,10 @@ type_uses_auto (tree type)
else
return NULL_TREE;
}
+ else if (tree *tp = find_type_usage (&type, is_auto))
+ return *tp;
else
- return find_type_usage (type, is_auto);
+ return NULL_TREE;
}
/* Report ill-formed occurrences of auto types in ARGUMENTS. If
diff --git a/gcc/cp/type-utils.h b/gcc/cp/type-utils.h
index 680b2497a36..4ad0d822119 100644
--- a/gcc/cp/type-utils.h
+++ b/gcc/cp/type-utils.h
@@ -20,36 +20,36 @@ along with GCC; see the file COPYING3. If not see
#ifndef GCC_CP_TYPE_UTILS_H
#define GCC_CP_TYPE_UTILS_H
-/* Returns the first tree within T that is directly matched by PRED. T may be a
- type or PARM_DECL and is incrementally decomposed toward its type-specifier
- until a match is found. NULL_TREE is returned if PRED does not match any
- part of T.
+/* Returns a pointer to the first tree within *TP that is directly matched by
+ PRED. *TP may be a type or PARM_DECL and is incrementally decomposed toward
+ its type-specifier until a match is found. NULL is returned if PRED does
not
+ match any part of *TP.
- This is primarily intended for detecting whether T uses `auto' or a concept
+ This is primarily intended for detecting whether *TP uses `auto' or a
concept
identifier. Since either of these can only appear as a type-specifier for
the declaration in question, only top-level qualifications are traversed;
find_type_usage does not look through the whole type. */
-inline tree
-find_type_usage (tree t, bool (*pred) (const_tree))
+inline tree *
+find_type_usage (tree *tp, bool (*pred) (const_tree))
{
- enum tree_code code;
+ tree t = *tp;
if (pred (t))
- return t;
+ return tp;
- code = TREE_CODE (t);
+ enum tree_code code = TREE_CODE (t);
if (code == POINTER_TYPE || code == REFERENCE_TYPE
|| code == PARM_DECL || code == OFFSET_TYPE
|| code == FUNCTION_TYPE || code == METHOD_TYPE
|| code == ARRAY_TYPE)
- return find_type_usage (TREE_TYPE (t), pred);
+ return find_type_usage (&TREE_TYPE (t), pred);
if (TYPE_PTRMEMFUNC_P (t))
return find_type_usage
- (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (t)), pred);
+ (&TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (t)), pred);
- return NULL_TREE;
+ return NULL;
}
#endif // GCC_CP_TYPE_UTILS_H
diff --git a/gcc/testsuite/g++.dg/concepts/abbrev3.C
b/gcc/testsuite/g++.dg/concepts/abbrev3.C
new file mode 100644
index 00000000000..ba2a648156e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/concepts/abbrev3.C
@@ -0,0 +1,11 @@
+// PR c++/69448
+// { dg-do compile { target c++14 } }
+// { dg-additional-options "-fconcepts" }
+
+long x;
+
+auto& f(auto) { return x; }
+auto* g(auto) { return &x; }
+
+long& r = f(1);
+long* p = g(1);
diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C
b/gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C
index d5fa5a536d3..6ea6164b417 100644
--- a/gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-pr80471.C
@@ -18,6 +18,6 @@ int main()
{
int i;
static_assert(is_same< decltype(f(i)), int& >, "");
- static_assert(is_same< decltype(g(i)), int >, "");
+ static_assert(is_same< decltype(g(i)), int& >, "");
static_assert(is_same< decltype(z(i)), int& >, "");
}
