finish_call_expr thinks that a call to a function which has been
obfuscated by force_paren_expr is a call to an unknown function. This
eventually leads us to not make use of the function's default arguments
when processing the argument list. So a function call like f() may
compile and yet (f)() may not, if f has defaulted arguments.
This patch fixes this inconsistency by making finish_call_expr undo the
obfuscation performed by force_paren_expr.
Bootstrapped + regtested + boost-tested on x86_64-pc-linux-gnu, does
this look OK to commit?
gcc/cp/ChangeLog:
PR c++/69736
* cp-tree.h (REF_PARENTHESIZED_P): Adjust documentation.
(maybe_undo_parenthesized_ref): Declare.
* semantics.c (maybe_undo_parenthesized_ref): Split out from
check_return_expr.
(finish_call_expr): Use it.
* typeck.c (check_return_expr): Use it.
gcc/testsuite/ChangeLog:
PR c++/69736
* g++.dg/cpp1y/paren2.C: New test.
---
gcc/cp/cp-tree.h | 3 ++-
gcc/cp/semantics.c | 28 ++++++++++++++++++++++++++++
gcc/cp/typeck.c | 12 +-----------
gcc/testsuite/g++.dg/cpp1y/paren2.C | 25 +++++++++++++++++++++++++
4 files changed, 56 insertions(+), 12 deletions(-)
create mode 100644 gcc/testsuite/g++.dg/cpp1y/paren2.C
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 3c23a83a..88c6367 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -3393,7 +3393,7 @@ extern void decl_shadowed_for_var_insert (tree, tree);
TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE))
/* Indicates whether a COMPONENT_REF has been parenthesized, or an
- INDIRECT_REF comes from parenthesizing a VAR_DECL. Currently only set
+ INDIRECT_REF comes from parenthesizing a _DECL. Currently only set
some of the time in C++14 mode. */
#define REF_PARENTHESIZED_P(NODE) \
@@ -6361,6 +6361,7 @@ extern tree finish_label_stmt (tree);
extern void finish_label_decl (tree);
extern cp_expr finish_parenthesized_expr (cp_expr);
extern tree force_paren_expr (tree);
+extern tree maybe_undo_parenthesized_ref (tree);
extern tree finish_non_static_data_member (tree, tree, tree);
extern tree begin_stmt_expr (void);
extern tree finish_stmt_expr_expr (tree, tree);
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 38c7516..e7f2e8b 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -1673,6 +1673,30 @@ force_paren_expr (tree expr)
return expr;
}
+/* If T is an id-expression obfuscated by force_paren_expr, undo the
+ obfuscation and return the underlying id-expression. Otherwise
+ return T. */
+
+tree
+maybe_undo_parenthesized_ref (tree t)
+{
+ if (cxx_dialect >= cxx14
+ && 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);
+ }
+
+ return t;
+}
+
/* Finish a parenthesized expression EXPR. */
cp_expr
@@ -2332,6 +2356,10 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args, bool
disallow_virtual,
&& TREE_CODE (TREE_OPERAND (fn, 0)) == OVERLOAD)
fn = TREE_OPERAND (fn, 0);
+ /* If FN is a FUNCTION_DECL obfuscated by force_paren_expr, undo
+ it so that we can tell this is a call to a known function. */
+ fn = maybe_undo_parenthesized_ref (fn);
+
if (is_overloaded_fn (fn))
fn = baselink_for_fns (fn);
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index d7ce327..3da6ea1 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -8929,17 +8929,7 @@ check_return_expr (tree retval, bool *no_warning)
/* If we had an id-expression obfuscated by force_paren_expr, we need
to undo it so we can try to treat it as an rvalue below. */
- if (cxx_dialect >= cxx14
- && INDIRECT_REF_P (retval)
- && REF_PARENTHESIZED_P (retval))
- {
- retval = TREE_OPERAND (retval, 0);
- while (TREE_CODE (retval) == NON_LVALUE_EXPR
- || TREE_CODE (retval) == NOP_EXPR)
- retval = TREE_OPERAND (retval, 0);
- gcc_assert (TREE_CODE (retval) == ADDR_EXPR);
- retval = TREE_OPERAND (retval, 0);
- }
+ retval = maybe_undo_parenthesized_ref (retval);
/* Under C++11 [12.8/32 class.copy], a returned lvalue is sometimes
treated as an rvalue for the purposes of overload resolution to
diff --git a/gcc/testsuite/g++.dg/cpp1y/paren2.C
b/gcc/testsuite/g++.dg/cpp1y/paren2.C
new file mode 100644
index 0000000..12462be
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/paren2.C
@@ -0,0 +1,25 @@
+// PR c++/69736
+
+void fn1(bool = true)
+{
+ (fn1)();
+}
+
+template <typename>
+void fn2()
+{
+ (fn1)();
+}
+
+struct X
+{
+ static void fn3(bool = true)
+ {
+ (X::fn3)();
+ }
+
+ void fn4(bool = true)
+ {
+ (X::fn4)();
+ }
+};
--
2.7.1.348.gb763790
