If capturing a variable fails, add a capture anyway (and mark it

invalid) so that we can avoid repeated diagnostics for the same capture.

llvm-svn: 361891

4 files changed, 20 insertions, 5 deletions

diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/blocks.mm b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/blocks.mm
index 96e8fcd8d37..cb56f6816ad 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/blocks.mm
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/blocks.mm
@@ -50,6 +50,13 @@ void nesting() {
     [=] () mutable {
       ^ {
         int i = array[2]; // expected-error{{cannot refer to declaration with an array type inside block}}
+        i += array[3];
+      }();
+    }();
+
+    [=] () mutable {
+      ^ {
+        int i = 0;
         i += array[3]; // expected-error{{cannot refer to declaration with an array type inside block}}
       }();
     }();
diff --git a/clang/test/Sema/captured-statements.c b/clang/test/Sema/captured-statements.c
index 86e9273944b..ac04915097e 100644
--- a/clang/test/Sema/captured-statements.c
+++ b/clang/test/Sema/captured-statements.c
@@ -65,11 +65,18 @@ void test_nest_block() {
   int b;
   #pragma clang __debug captured
   {
-    __block int c;
     int d;
     ^{
       a = b; // expected-error{{__block variable 'a' cannot be captured in a captured statement}}
+      a = b; // (duplicate diagnostic suppressed)
       b = d; // OK - Consistent with block inside a lambda
+    }();
+  }
+  #pragma clang __debug captured
+  {
+    __block int c;
+    int d;
+    ^{
       c = a; // expected-error{{__block variable 'a' cannot be captured in a captured statement}}
       c = d; // OK
       d = b; // expected-error{{variable is not assignable (missing __block type specifier)}}
diff --git a/clang/test/SemaCXX/lambda-expressions.cpp b/clang/test/SemaCXX/lambda-expressions.cpp
index 1833400be3d..8b0b83078b0 100644
--- a/clang/test/SemaCXX/lambda-expressions.cpp
+++ b/clang/test/SemaCXX/lambda-expressions.cpp
@@ -65,9 +65,9 @@ namespace ImplicitCapture {
     d = 3;
     [=]() { return c; }; // expected-error {{unnamed variable cannot be implicitly captured in a lambda expression}}
 
-    __block int e; // expected-note 3 {{declared}}
+    __block int e; // expected-note 2{{declared}}
     [&]() { return e; }; // expected-error {{__block variable 'e' cannot be captured in a lambda expression}}
-    [&e]() { return e; }; // expected-error 2 {{__block variable 'e' cannot be captured in a lambda expression}}
+    [&e]() { return e; }; // expected-error {{__block variable 'e' cannot be captured in a lambda expression}}
 
     int f[10]; // expected-note {{declared}}
     [&]() { return f[2]; };
diff --git a/clang/test/SemaObjCXX/capturing-flexible-array-in-block.mm b/clang/test/SemaObjCXX/capturing-flexible-array-in-block.mm
index d7d888564c1..cf88d4684c5 100644
--- a/clang/test/SemaObjCXX/capturing-flexible-array-in-block.mm
+++ b/clang/test/SemaObjCXX/capturing-flexible-array-in-block.mm
@@ -2,7 +2,8 @@
 // rdar://12655829
 
 void f() {
-  struct { int x; int y[]; } a; // expected-note 2 {{'a' declared here}}
+  struct { int x; int y[]; } a; // expected-note 3 {{'a' declared here}}
   ^{return a.x;}(); // expected-error {{cannot refer to declaration of structure variable with flexible array member inside block}}
-  [] {return a.x;}(); // expected-error {{variable 'a' with flexible array member cannot be captured in a lambda expression}}
+  [=] {return a.x;}(); // expected-error {{variable 'a' with flexible array member cannot be captured in a lambda expression}}
+  [] {return a.x;}(); // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default}} expected-note {{here}}
 }