[PATCH] c++: nested lambda capturing a capture proxy, part 2 [PR94376]

[Patrick Palka via Gcc-patches]

The r12-5403 fix apparently doesn't handle the case where the inner
lambda explicitly rather implicitly captures the capture proxy from
the outer lambda, and so we still reject the first example in the
testcase below.

The reason is that compared to an implicit capture, the effective
initializer for an explicit capture is wrapped in a location wrapper
(pointing to the source location of the explicit capture), and this
wrapper foils the is_capture_proxy check.  The simplest fix appears to
be to strip location wrappers accordingly.

Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK for
trunk?

        PR c++/94376

gcc/cp/ChangeLog:

        * lambda.c (lambda_capture_field_type): Strip location wrappers
        before checking for a capture proxy.

gcc/testsuite/ChangeLog:

        * g++.dg/cpp0x/lambda/lambda-nested9a.C: New test.
---
 gcc/cp/lambda.c                               |  1 +
 .../g++.dg/cpp0x/lambda/lambda-nested9a.C     | 42 +++++++++++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested9a.C

diff --git a/gcc/cp/lambda.c b/gcc/cp/lambda.c
index c39a2bca416..7f2f927bda2 100644
--- a/gcc/cp/lambda.c
+++ b/gcc/cp/lambda.c
@@ -221,6 +221,7 @@ lambda_capture_field_type (tree expr, bool explicit_init_p,
     }
   else
     {
+      STRIP_ANY_LOCATION_WRAPPER (expr);
       if (!by_reference_p && is_capture_proxy (expr))
        {
          /* When capturing by-value another capture proxy from an enclosing
diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested9a.C 
b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested9a.C
new file mode 100644
index 00000000000..d62f8f0c952
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested9a.C
@@ -0,0 +1,42 @@
+// PR c++/94376
+// Like lambda-nested9.C but using explicit captures in the inner lambda.
+// { dg-do compile { target c++11 } }
+
+int main() {
+  // We used to incorrectly reject the first two cases.
+  int i = 0;
+  [=] () {
+    [i] () mutable {
+      ++i;
+    };
+  };
+
+#if __cpp_init_captures
+  [j=0] () {
+    [j] () mutable {
+      ++j;
+    };
+  };
+#endif
+
+  [=] () {
+    [&i] () mutable {
+      ++i; // { dg-error "read-only" }
+    };
+  };
+
+  const int j = 0;
+  [=] () {
+    [j] () mutable {
+      ++j; // { dg-error "read-only" }
+    };
+  };
+
+#if __cpp_init_captures
+  [j=0] () {
+    [&j] () mutable {
+      ++j; // { dg-error "read-only" "" { target c++14 } }
+    };
+  };
+#endif
+}
-- 
2.34.1.182.ge773545c7f