diff mbox

Fix PR c++/69736

Message ID alpine.DEB.2.20.9.1602241449000.1231@idea
State New
Headers show

Commit Message

Patrick Palka Feb. 24, 2016, 7:49 p.m. UTC 
On Wed, 24 Feb 2016, Jason Merrill wrote:

> On 02/23/2016 11:24 AM, Patrick Palka wrote:
>> 1. making tsubst_copy_and_build retain the REF_PARENTHESIZED_P flag when
>> processing an INDIRECT_REF, or by
>
> This should happen in any case.
>
>> 2. moving the call to maybe_undo_parenthesized_ref in finish_call_expr 
>> before
>> the assignment of orig_fn so that orig_fn will be un-obfuscated as well, or 
>> by
>
> This would also be OK; at this point we know the expression isn't the operand 
> of decltype.

Here's an updated patch that does both these things.  Does it look OK to
commit after testing?

-- >8 --

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.
 	* pt.c (tsubst_copy_and_build) [INDIRECT_REF]: Retain the
 	REF_PARENTHESIZED_P flag.

gcc/testsuite/ChangeLog:

 	PR c++/69736
 	* g++.dg/cpp1y/paren2.C: New test.
---
  gcc/cp/cp-tree.h                    |  3 ++-
  gcc/cp/pt.c                         |  4 ++++
  gcc/cp/semantics.c                  | 28 ++++++++++++++++++++++++++++
  gcc/cp/typeck.c                     | 12 +-----------
  gcc/testsuite/g++.dg/cpp1y/paren2.C | 31 +++++++++++++++++++++++++++++++
  5 files changed, 66 insertions(+), 12 deletions(-)
  create mode 100644 gcc/testsuite/g++.dg/cpp1y/paren2.C

Comments

Jason Merrill Feb. 24, 2016, 9:13 p.m. UTC | #1 
OK.

Jason
diff mbox

Patch

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/pt.c b/gcc/cp/pt.c
index 4785aa4..f74e9bb 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -15965,6 +15965,10 @@  tsubst_copy_and_build (tree t,
  	else
  	  r = build_x_indirect_ref (input_location, r, RO_UNARY_STAR,
  				    complain|decltype_flag);
+
+	if (TREE_CODE (r) == INDIRECT_REF)
+	  REF_PARENTHESIZED_P (r) = REF_PARENTHESIZED_P (t);
+
  	RETURN (r);
        }

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 38c7516..109f82a 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
@@ -2263,6 +2287,10 @@  finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,

    gcc_assert (!TYPE_P (fn));

+  /* 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);
+
    orig_fn = fn;

    if (processing_template_decl)
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..b4a721f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/paren2.C
@@ -0,0 +1,31 @@ 
+// PR c++/69736
+// { dg-do compile { target c++14 } }
+
+void fn1(bool = true)
+{
+  (fn1)();
+}
+
+template <typename T>
+void fn2(T a = true)
+{
+  (fn1)();
+}
+
+void foo ()
+{
+  (fn2<bool>)();
+}
+
+struct X
+{
+  static void fn3(bool = true)
+  {
+    (X::fn3)();
+  }
+
+  void fn4(bool = true)
+  {
+    (X::fn4)();
+  }
+};