• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -fblocks
2 
test_nest_lambda()3 void test_nest_lambda() {
4   int x;
5   int y;
6   [&,y]() {
7     int z;
8     #pragma clang __debug captured
9     {
10       x = y; // OK
11       y = z; // expected-error{{cannot assign to a variable captured by copy in a non-mutable lambda}}
12       z = y; // OK
13     }
14   }();
15 
16   int a;
17   #pragma clang __debug captured
18   {
19     int b;
20     int c;
21     [&,c]() {
22       a = b; // OK
23       b = c; // OK
24       c = a; // expected-error{{cannot assign to a variable captured by copy in a non-mutable lambda}}
25     }();
26   }
27 }
28 
29 class test_obj_capture {
30   int a;
31   void b();
test()32   static void test() {
33     test_obj_capture c;
34     #pragma clang __debug captured
35     { (void)c.a; }  // OK
36     #pragma clang __debug captured
37     { c.b(); }      // OK
38   }
39 };
40 
41 class test_this_capture {
42   int a;
43   void b();
test()44   void test() {
45     #pragma clang __debug captured
46     { (void)this; } // OK
47     #pragma clang __debug captured
48     { (void)a; }    // OK
49     #pragma clang __debug captured
50     { b(); }        // OK
51   }
52 };
53 
54 template <typename T>
template_capture_var()55 void template_capture_var() {
56   T x; // expected-error{{declaration of reference variable 'x' requires an initializer}}
57   #pragma clang _debug captured
58   {
59     (void)x;
60   }
61 }
62 
63 template <typename T>
64 class Val {
65   T v;
66 public:
set(const T & v0)67   void set(const T &v0) {
68     #pragma clang __debug captured
69     {
70       v = v0;
71     }
72   }
73 };
74 
test_capture_var()75 void test_capture_var() {
76   template_capture_var<int>(); // OK
77   template_capture_var<int&>(); // expected-note{{in instantiation of function template specialization 'template_capture_var<int &>' requested here}}
78 
79   Val<float> Obj;
80   Obj.set(0.0f); // OK
81 }
82 
83 template <typename S, typename T>
template_capture_var(S x,T y)84 S template_capture_var(S x, T y) {  // expected-note{{variable 'y' declared const here}}
85   #pragma clang _debug captured
86   {
87     x++;
88     y++;  // expected-error{{cannot assign to variable 'y' with const-qualified type 'const int'}}
89   }
90 
91   return x;
92 }
93 
94 // Check if can recover from a template error.
test_capture_var_error()95 void test_capture_var_error() {
96   template_capture_var<int, int>(0, 1); // OK
97   template_capture_var<int, const int>(0, 1); // expected-note{{in instantiation of function template specialization 'template_capture_var<int, const int>' requested here}}
98   template_capture_var<int, int>(0, 1); // OK
99 }
100 
101 template <typename T>
template_capture_in_lambda()102 void template_capture_in_lambda() {
103   T x, y;
104   [=, &y]() {
105     #pragma clang __debug captured
106     {
107       y += x;
108     }
109   }();
110 }
111 
test_lambda()112 void test_lambda() {
113   template_capture_in_lambda<int>(); // OK
114 }
115 
116 struct Foo {
fooFoo117   void foo() { }
barFoo118   static void bar() { }
119 };
120 
121 template <typename T>
template_capture_func(T & t)122 void template_capture_func(T &t) {
123   #pragma clang __debug captured
124   {
125     t.foo();
126   }
127 
128   #pragma clang __debug captured
129   {
130     T::bar();
131   }
132 }
133 
test_template_capture_func()134 void test_template_capture_func() {
135   Foo Obj;
136   template_capture_func(Obj);
137 }
138 
139 template <typename T>
captured_sum(const T & a,const T & b)140 T captured_sum(const T &a, const T &b) {
141   T result;
142 
143   #pragma clang __debug captured
144   {
145     result = a + b;
146   }
147 
148   return result;
149 }
150 
151 template <typename T, typename... Args>
captured_sum(const T & a,const Args &...args)152 T captured_sum(const T &a, const Args&... args) {
153   T result;
154 
155   #pragma clang __debug captured
156   {
157     result = a + captured_sum(args...);
158   }
159 
160   return result;
161 }
162 
test_capture_variadic()163 void test_capture_variadic() {
164   (void)captured_sum(1, 2, 3); // OK
165   (void)captured_sum(1, 2, 3, 4, 5); // OK
166 }
167 
test_capture_with_attributes()168 void test_capture_with_attributes() {
169   [[]] // expected-error {{an attribute list cannot appear here}}
170   #pragma clang __debug captured
171   {
172   }
173 }
174