[PATCH] Fix PR c++/69736

[Patrick Palka]

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