Within the body of a lambda expression, decltype((x)) for an

id-expression 'x' will compute the type based on the assumption that
'x' will be captured, even if it isn't captured, per C++11
[expr.prim.lambda]p18. There are two related refactors that go into
implementing this:

  1) Split out the check that determines whether we should capture a
  particular variable reference, along with the computation of the
  type of the field, from the actual act of capturing the
  variable. 
  2) Always compute the result of decltype() within Sema, rather than
  AST, because the decltype() computation is now context-sensitive.

llvm-svn: 150347

1 files changed, 41 insertions, 0 deletions

diff --git a/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p18.cpp b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p18.cpp
new file mode 100644
index 00000000000..561ead1271e
--- /dev/null
+++ b/clang/test/CXX/expr/expr.prim/expr.prim.lambda/p18.cpp
@@ -0,0 +1,41 @@
+// RUN: %clang_cc1 -std=c++11 %s -Wunused -verify
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+void f3() {
+  float x, &r = x;
+  int i;
+  int &ir = i;
+  const int &irc = i;
+
+  [=,&irc,&ir] {
+    static_assert(is_same<decltype(x), float>::value, "should be float");
+    static_assert(is_same<decltype((x)), const float&>::value, 
+                  "should be const float&");
+    static_assert(is_same<decltype(r), float&>::value, "should be float&");
+    static_assert(is_same<decltype(((r))), float const&>::value, 
+                  "should be const float&");
+    static_assert(is_same<decltype(ir), int&>::value, "should be int&");
+    static_assert(is_same<decltype((ir)), int&>::value, "should be int&");
+    static_assert(is_same<decltype(irc), const int&>::value, 
+                  "should be const int&");
+    static_assert(is_same<decltype((irc)), const int&>::value, 
+                  "should be const int&");
+  }();
+
+  [=] {
+    [=] () mutable {
+      static_assert(is_same<decltype(x), float>::value, "should be float");
+      static_assert(is_same<decltype((x)), const float&>::value, 
+                    "should be const float&");
+    }();
+  }();
+}