Various interrelated cleanups for lambdas:

  - Complete the lambda class when we finish the lambda expression
    (previously, it was left in the "being completed" state)
  - Actually return the LambdaExpr object and bind to the resulting
  temporary when needed.
  - Detect when cleanups are needed while capturing a variable into a
  lambda (e.g., due to default arguments in the copy constructor), and
  make sure those cleanups apply for the whole of the lambda
  expression.
    

llvm-svn: 150123

8 files changed, 46 insertions, 28 deletions

diff --git a/clang/test/CXX/class/class.local/p1-0x.cpp b/clang/test/CXX/class/class.local/p1-0x.cpp
index 89162958252..b8e1f680005 100644
--- a/clang/test/CXX/class/class.local/p1-0x.cpp
+++ b/clang/test/CXX/class/class.local/p1-0x.cpp
@@ -7,12 +7,12 @@ void f() {
     int& x2 = x; // expected-error{{reference to local variable 'x' declared in enclosing function 'f'}}
     int cc = c;
   };
-  []() mutable { // expected-error {{not supported yet}}
+  (void)[]() mutable { // expected-error {{not supported yet}}
     int x = 3; // expected-note{{'x' declared here}}
     struct C {
       int& x2 = x; // expected-error{{reference to local variable 'x' declared in enclosing lambda expression}}
     };
-  }
+  };
   C();
 }
 
diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p10.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p10.cpp
index 497307ff755..6f09c53e576 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p10.cpp
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p10.cpp
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -std=c++11 %s -verify
 
-int GlobalVar; // expected-note 2{{declared here}}
+int GlobalVar; // expected-note {{declared here}}
 
 namespace N {
   int AmbiguousVar; // expected-note {{candidate}}
@@ -16,9 +16,11 @@ class X0 {
   virtual X0& Overload(float);
 
   void explicit_capture() {
-    [&Overload] () {}; // expected-error {{does not name a variable}} expected-error {{not supported yet}}
-    [&GlobalVar] () {}; // expected-error {{does not have automatic storage duration}} expected-error {{not supported yet}}
-    [&AmbiguousVar] () {} // expected-error {{reference to 'AmbiguousVar' is ambiguous}} expected-error {{not supported yet}}
-    [&Globalvar] () {}; // expected-error {{use of undeclared identifier 'Globalvar'; did you mean 'GlobalVar}}
+    int variable; // expected-note {{declared here}}
+    (void)[&Overload] () {}; // expected-error {{does not name a variable}} expected-error {{not supported yet}}
+    (void)[&GlobalVar] () {}; // expected-error {{does not have automatic storage duration}} expected-error {{not supported yet}}
+    (void)[&AmbiguousVar] () {}; // expected-error {{reference to 'AmbiguousVar' is ambiguous}} expected-error {{not supported yet}}
+    (void)[&Variable] () {}; // expected-error {{use of undeclared identifier 'Variable'; did you mean 'variable'}} \
+    // expected-error{{lambda expressions are not supported yet}}
   }
 };
diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p14.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p14.cpp
index 0bbb9ae7440..4c876d7480d 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p14.cpp
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p14.cpp
@@ -6,10 +6,26 @@ class NonCopyable {
 
 void capture_by_copy(NonCopyable nc, NonCopyable &ncr) {
   // FIXME: error messages should talk about capture
-  [nc] { }; // expected-error{{field of type 'NonCopyable' has private copy constructor}} \
+  (void)[nc] { }; // expected-error{{field of type 'NonCopyable' has private copy constructor}} \
              // expected-error{{lambda expressions are not supported yet}}
-  [ncr] { }; // expected-error{{field of type 'NonCopyable' has private copy constructor}} \
+  (void)[ncr] { }; // expected-error{{field of type 'NonCopyable' has private copy constructor}} \
              // expected-error{{lambda expressions are not supported yet}}
 }
 
+struct NonTrivial {
+  NonTrivial();
+  NonTrivial(const NonTrivial &);
+  ~NonTrivial();
+};
+
+struct CopyCtorDefault {
+  CopyCtorDefault(const CopyCtorDefault&, NonTrivial nt = NonTrivial());
+
+  void foo() const;
+};
+
+void capture_with_default_args(CopyCtorDefault cct) {
+  (void)[=] () -> void { cct.foo(); }; // expected-error{{lambda expressions are not supported yet}}
+}
+
 // FIXME: arrays!
diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p15.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p15.cpp
index 7264fa18d06..e17d8b5101a 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p15.cpp
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p15.cpp
@@ -5,6 +5,6 @@ class NonCopyable {
 };
 
 void capture_by_ref(NonCopyable nc, NonCopyable &ncr) {
-  [&nc] () -> void {}; // expected-error{{lambda expressions are not supported yet}}
-  [&ncr] () -> void {}; // expected-error{{lambda expressions are not supported yet}}
+  (void)[&nc] () -> void {}; // expected-error{{lambda expressions are not supported yet}}
+  (void)[&ncr] () -> void {}; // expected-error{{lambda expressions are not supported yet}}
 }
diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p5.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p5.cpp
index a6fca9b2c46..93ba6f61c75 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p5.cpp
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p5.cpp
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -std=c++11 %s -verify
 
 int test_default_args() {
-  [](int i = 5,  // expected-error{{default arguments can only be specified for parameters in a function declaration}} \
+  (void)[](int i = 5,  // expected-error{{default arguments can only be specified for parameters in a function declaration}} \
                  // expected-error{{lambda expressions are not supported yet}}
      int j = 17) {}; // expected-error{{default arguments can only be specified for parameters in a function declaration}}
 }
diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p7.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p7.cpp
index 3c5ac220a1e..e816426cbf9 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p7.cpp
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p7.cpp
@@ -2,7 +2,7 @@
 
 // Check that analysis-based warnings work in lambda bodies.
 void analysis_based_warnings() {
-  []() -> int { }; // expected-warning{{control reaches end of non-void function}} \
+  (void)[]() -> int { }; // expected-warning{{control reaches end of non-void function}} \
   // expected-error{{lambda expressions are not supported yet}}
 }
 
@@ -12,32 +12,32 @@ int &check_const_int(int&);
 float &check_const_int(const int&);
 
 void test_capture_constness(int i, const int ic) {
-  [i,ic] ()->void { // expected-error{{lambda expressions are not supported yet}}
+  (void)[i,ic] ()->void { // expected-error{{lambda expressions are not supported yet}}
     float &fr1 = check_const_int(i);
     float &fr2 = check_const_int(ic);
   }; 
 
-  [=] ()->void { // expected-error{{lambda expressions are not supported yet}}
+  (void)[=] ()->void { // expected-error{{lambda expressions are not supported yet}}
     float &fr1 = check_const_int(i);
     float &fr2 = check_const_int(ic);
   }; 
 
-  [i,ic] () mutable ->void { // expected-error{{lambda expressions are not supported yet}}
+  (void)[i,ic] () mutable ->void { // expected-error{{lambda expressions are not supported yet}}
     int &ir = check_const_int(i);
     float &fr = check_const_int(ic);
   };
 
-  [=] () mutable ->void { // expected-error{{lambda expressions are not supported yet}}
+  (void)[=] () mutable ->void { // expected-error{{lambda expressions are not supported yet}}
     int &ir = check_const_int(i);
     float &fr = check_const_int(ic);
   };
 
-  [&i,&ic] ()->void { // expected-error{{lambda expressions are not supported yet}}
+  (void)[&i,&ic] ()->void { // expected-error{{lambda expressions are not supported yet}}
     int &ir = check_const_int(i);
     float &fr = check_const_int(ic);
   };
 
-  [&] ()->void { // expected-error{{lambda expressions are not supported yet}}
+  (void)[&] ()->void { // expected-error{{lambda expressions are not supported yet}}
     int &ir = check_const_int(i);
     float &fr = check_const_int(ic);
   };
diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p8.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p8.cpp
index 4bd5760bc43..53d2c757721 100644
--- a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p8.cpp
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p8.cpp
@@ -4,13 +4,13 @@ class X0 {
   void explicit_capture() {
     int foo;
 
-    [foo, foo] () {}; // expected-error {{'foo' can appear only once}} expected-error {{not supported yet}}
-    [this, this] () {}; // expected-error {{'this' can appear only once}} expected-error {{not supported yet}}
-    [=, foo] () {}; // expected-error {{'&' must precede a capture when}} expected-error {{not supported yet}}
-    [=, &foo] () {}; // expected-error {{not supported yet}}
-    [=, this] () {}; // expected-error {{'this' cannot appear}} expected-error {{not supported yet}}
-    [&, foo] () {}; // expected-error {{not supported yet}}
-    [&, &foo] () {}; // expected-error {{'&' cannot precede a capture when}} expected-error {{not supported yet}}
-    [&, this] () {}; // expected-error {{not supported yet}}
+    (void)[foo, foo] () {}; // expected-error {{'foo' can appear only once}} expected-error {{not supported yet}}
+    (void)[this, this] () {}; // expected-error {{'this' can appear only once}} expected-error {{not supported yet}}
+    (void)[=, foo] () {}; // expected-error {{'&' must precede a capture when}} expected-error {{not supported yet}}
+    (void)[=, &foo] () {}; // expected-error {{not supported yet}}
+    (void)[=, this] () {}; // expected-error {{'this' cannot appear}} expected-error {{not supported yet}}
+    (void)[&, foo] () {}; // expected-error {{not supported yet}}
+    (void)[&, &foo] () {}; // expected-error {{'&' cannot precede a capture when}} expected-error {{not supported yet}}
+    (void)[&, this] () {}; // expected-error {{not supported yet}}
   }
 };
diff --git a/clang/test/SemaCXX/lambda-expressions.cpp b/clang/test/SemaCXX/lambda-expressions.cpp
index 46c74c3c74e..a414fc98e7c 100644
--- a/clang/test/SemaCXX/lambda-expressions.cpp
+++ b/clang/test/SemaCXX/lambda-expressions.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify -fblocks %s
+// RUN: %clang_cc1 -std=c++0x -Wno-unused-value -fsyntax-only -verify -fblocks %s
 
 namespace std { class type_info; };