c++: decltype of (by-value captured reference) [PR79620]

The capture_decltype handling in finish_decltype_type wasn't looking
through implicit INDIRECT_REF (added by convert_from_reference), which
caused us to incorrectly resolve decltype((r)) to float& below.  This
patch fixes this, and adds an assert to outer_automatic_var_p to help
prevent against such bugs.

We still don't fully accept the example ultimately because for the
decltype inside the lambda's trailing return type, at that point we're
in lambda type scope but not yet in lambda function scope that the
capture_decltype handling looks for (which is an orthogonal bug).

	PR c++/79620

gcc/cp/ChangeLog:

	* cp-tree.h (STRIP_REFERENCE_REF): Define.
	* semantics.cc (outer_var_p): Assert REFERENCE_REF_P is false.
	(finish_decltype_type): Look through implicit INDIRECT_REF when
	deciding whether to call capture_decltype.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp0x/lambda/lambda-decltype3.C: New test.

Reviewed-by: Jason Merrill <jason@redhat.com>

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index b2603d4830ea23382f9b9b282aabe82e1eb2fc96..1fa710d71543d226bc37efe0a21eb4e5568192ba 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -4084,6 +4084,10 @@ struct GTY(()) lang_decl {
    && TREE_TYPE (TREE_OPERAND (NODE, 0))               \
    && TYPE_REF_P (TREE_TYPE (TREE_OPERAND ((NODE), 0))))
 
+/* Look through an implicit INDIRECT_REF from convert_from_reference.  */
+#define STRIP_REFERENCE_REF(NODE)                      \
+  (REFERENCE_REF_P (NODE) ? TREE_OPERAND (NODE, 0) : NODE)
+
 /* True iff this represents an lvalue being treated as an rvalue during return
    or throw as per [class.copy.elision].  */
 #define IMPLICIT_RVALUE_P(NODE) \

diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
index f5ae8b5af85a9bee5fa563ebb913c906963d9b34..8090c71809fefc6de4e3acf1722e4cd2318b6478 100644 (file)
--- a/gcc/cp/semantics.cc
+++ b/gcc/cp/semantics.cc
@@ -3932,6 +3932,9 @@ baselink_for_fns (tree fns)
 static bool
 outer_var_p (tree decl)
 {
+  /* These should have been stripped or otherwise handled by the caller.  */
+  gcc_checking_assert (!REFERENCE_REF_P (decl));
+
   return ((VAR_P (decl) || TREE_CODE (decl) == PARM_DECL)
          && DECL_FUNCTION_SCOPE_P (decl)
          /* Don't get confused by temporaries.  */
@@ -11719,10 +11722,10 @@ finish_decltype_type (tree expr, bool id_expression_or_member_access_p,
         transformed into an access to a corresponding data member
         of the closure type that would have been declared if x
         were a use of the denoted entity.  */
-      if (outer_automatic_var_p (expr)
+      if (outer_automatic_var_p (STRIP_REFERENCE_REF (expr))
          && current_function_decl
          && LAMBDA_FUNCTION_P (current_function_decl))
-       type = capture_decltype (expr);
+       type = capture_decltype (STRIP_REFERENCE_REF (expr));
       else if (error_operand_p (expr))
        type = error_mark_node;
       else if (expr == current_class_ptr)

diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-decltype3.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-decltype3.C
new file mode 100644 (file)
index 0000000..7fc157a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-decltype3.C
@@ -0,0 +1,28 @@
+// PR c++/79620
+// [expr.prim.id.unqual] example 1
+// { dg-do compile { target c++11 } }
+
+void f() {
+  float x, &r = x;
+
+  [=]() -> decltype((x)) {      // lambda returns float const& because this lambda is not mutable and
+                                // x is an lvalue
+    decltype(x) y1;             // y1 has type float
+    decltype((x)) y2 = y1;      // y2 has type float const&
+    decltype(r) r1 = y1;        // r1 has type float&
+    decltype((r)) r2 = y2;      // r2 has type float const&
+    return y2;                  // { dg-bogus "'float&' to 'const float'" "" { xfail *-*-* } }
+  };
+
+  [=](decltype((x)) y) {
+    decltype((x)) z = x;        // OK, y has type float&, z has type float const&
+  };
+
+  [=] {
+    [](decltype((x)) y) {};     // OK, lambda takes a parameter of type float const&
+
+    [x=1](decltype((x)) y) {
+      decltype((x)) z = x;      // OK, y has type int&, z has type int const&
+    };
+  };
+}