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