]>
Commit | Line | Data |
---|---|---|
b7449926 | 1 | // run-pass |
abe05a73 XL |
2 | // ignore-wasm32-bare compiled with panic=abort by default |
3 | ||
29967ef6 | 4 | #![feature(generators, generator_trait)] |
74b04a01 | 5 | #![feature(bindings_after_at)] |
dfeec247 XL |
6 | |
7 | #![allow(unused_assignments)] | |
8 | #![allow(unused_variables)] | |
3157f602 XL |
9 | |
10 | use std::cell::{Cell, RefCell}; | |
e74abb32 | 11 | use std::mem::ManuallyDrop; |
abe05a73 | 12 | use std::ops::Generator; |
3157f602 | 13 | use std::panic; |
9fa01778 | 14 | use std::pin::Pin; |
3157f602 XL |
15 | |
16 | struct InjectedFailure; | |
17 | ||
18 | struct Allocator { | |
19 | data: RefCell<Vec<bool>>, | |
20 | failing_op: usize, | |
21 | cur_ops: Cell<usize>, | |
22 | } | |
23 | ||
24 | impl panic::UnwindSafe for Allocator {} | |
25 | impl panic::RefUnwindSafe for Allocator {} | |
26 | ||
27 | impl Drop for Allocator { | |
28 | fn drop(&mut self) { | |
29 | let data = self.data.borrow(); | |
30 | if data.iter().any(|d| *d) { | |
31 | panic!("missing free: {:?}", data); | |
32 | } | |
33 | } | |
34 | } | |
35 | ||
36 | impl Allocator { | |
37 | fn new(failing_op: usize) -> Self { | |
38 | Allocator { | |
39 | failing_op: failing_op, | |
40 | cur_ops: Cell::new(0), | |
41 | data: RefCell::new(vec![]) | |
42 | } | |
43 | } | |
dc9dc135 | 44 | fn alloc(&self) -> Ptr<'_> { |
3157f602 XL |
45 | self.cur_ops.set(self.cur_ops.get() + 1); |
46 | ||
47 | if self.cur_ops.get() == self.failing_op { | |
5869c6ff | 48 | panic::panic_any(InjectedFailure); |
3157f602 XL |
49 | } |
50 | ||
51 | let mut data = self.data.borrow_mut(); | |
52 | let addr = data.len(); | |
53 | data.push(true); | |
54 | Ptr(addr, self) | |
55 | } | |
dc9dc135 XL |
56 | // FIXME(#47949) Any use of this indicates a bug in rustc: we should never |
57 | // be leaking values in the cases here. | |
58 | // | |
59 | // Creates a `Ptr<'_>` and checks that the allocated value is leaked if the | |
60 | // `failing_op` is in the list of exception. | |
61 | fn alloc_leaked(&self, exceptions: Vec<usize>) -> Ptr<'_> { | |
62 | let ptr = self.alloc(); | |
63 | ||
64 | if exceptions.iter().any(|operation| *operation == self.failing_op) { | |
65 | let mut data = self.data.borrow_mut(); | |
66 | data[ptr.0] = false; | |
67 | } | |
68 | ptr | |
69 | } | |
3157f602 XL |
70 | } |
71 | ||
72 | struct Ptr<'a>(usize, &'a Allocator); | |
73 | impl<'a> Drop for Ptr<'a> { | |
74 | fn drop(&mut self) { | |
75 | match self.1.data.borrow_mut()[self.0] { | |
76 | false => { | |
77 | panic!("double free at index {:?}", self.0) | |
78 | } | |
79 | ref mut d => *d = false | |
80 | } | |
81 | ||
82 | self.1.cur_ops.set(self.1.cur_ops.get()+1); | |
83 | ||
84 | if self.1.cur_ops.get() == self.1.failing_op { | |
5869c6ff | 85 | panic::panic_any(InjectedFailure); |
3157f602 XL |
86 | } |
87 | } | |
88 | } | |
89 | ||
3157f602 XL |
90 | fn dynamic_init(a: &Allocator, c: bool) { |
91 | let _x; | |
92 | if c { | |
93 | _x = Some(a.alloc()); | |
94 | } | |
95 | } | |
96 | ||
3157f602 XL |
97 | fn dynamic_drop(a: &Allocator, c: bool) { |
98 | let x = a.alloc(); | |
99 | if c { | |
100 | Some(x) | |
101 | } else { | |
102 | None | |
103 | }; | |
104 | } | |
105 | ||
7cac9316 XL |
106 | struct TwoPtrs<'a>(Ptr<'a>, Ptr<'a>); |
107 | fn struct_dynamic_drop(a: &Allocator, c0: bool, c1: bool, c: bool) { | |
108 | for i in 0..2 { | |
109 | let x; | |
110 | let y; | |
111 | if (c0 && i == 0) || (c1 && i == 1) { | |
112 | x = (a.alloc(), a.alloc(), a.alloc()); | |
113 | y = TwoPtrs(a.alloc(), a.alloc()); | |
114 | if c { | |
115 | drop(x.1); | |
116 | drop(y.0); | |
117 | } | |
118 | } | |
119 | } | |
120 | } | |
121 | ||
041b39d2 XL |
122 | fn field_assignment(a: &Allocator, c0: bool) { |
123 | let mut x = (TwoPtrs(a.alloc(), a.alloc()), a.alloc()); | |
124 | ||
125 | x.1 = a.alloc(); | |
126 | x.1 = a.alloc(); | |
127 | ||
128 | let f = (x.0).0; | |
129 | if c0 { | |
130 | (x.0).0 = f; | |
131 | } | |
132 | } | |
133 | ||
3157f602 XL |
134 | fn assignment2(a: &Allocator, c0: bool, c1: bool) { |
135 | let mut _v = a.alloc(); | |
136 | let mut _w = a.alloc(); | |
137 | if c0 { | |
138 | drop(_v); | |
139 | } | |
140 | _v = _w; | |
141 | if c1 { | |
142 | _w = a.alloc(); | |
143 | } | |
144 | } | |
145 | ||
3157f602 XL |
146 | fn assignment1(a: &Allocator, c0: bool) { |
147 | let mut _v = a.alloc(); | |
148 | let mut _w = a.alloc(); | |
149 | if c0 { | |
150 | drop(_v); | |
151 | } | |
152 | _v = _w; | |
153 | } | |
154 | ||
9e0c209e | 155 | union Boxy<T> { |
e74abb32 XL |
156 | a: ManuallyDrop<T>, |
157 | b: ManuallyDrop<T>, | |
9e0c209e SL |
158 | } |
159 | ||
160 | fn union1(a: &Allocator) { | |
161 | unsafe { | |
e74abb32 XL |
162 | let mut u = Boxy { a: ManuallyDrop::new(a.alloc()) }; |
163 | *u.b = a.alloc(); // drops first alloc | |
164 | drop(ManuallyDrop::into_inner(u.a)); | |
9e0c209e SL |
165 | } |
166 | } | |
167 | ||
7cac9316 XL |
168 | fn array_simple(a: &Allocator) { |
169 | let _x = [a.alloc(), a.alloc(), a.alloc(), a.alloc()]; | |
170 | } | |
171 | ||
172 | fn vec_simple(a: &Allocator) { | |
173 | let _x = vec![a.alloc(), a.alloc(), a.alloc(), a.alloc()]; | |
174 | } | |
175 | ||
abe05a73 XL |
176 | fn generator(a: &Allocator, run_count: usize) { |
177 | assert!(run_count < 4); | |
178 | ||
179 | let mut gen = || { | |
180 | (a.alloc(), | |
181 | yield a.alloc(), | |
182 | a.alloc(), | |
183 | yield a.alloc() | |
184 | ); | |
185 | }; | |
186 | for _ in 0..run_count { | |
74b04a01 | 187 | Pin::new(&mut gen).resume(()); |
abe05a73 XL |
188 | } |
189 | } | |
190 | ||
191 | fn mixed_drop_and_nondrop(a: &Allocator) { | |
192 | // check that destructor panics handle drop | |
193 | // and non-drop blocks in the same scope correctly. | |
194 | // | |
195 | // Surprisingly enough, this used to not work. | |
196 | let (x, y, z); | |
197 | x = a.alloc(); | |
198 | y = 5; | |
199 | z = a.alloc(); | |
200 | } | |
201 | ||
3b2f2976 XL |
202 | #[allow(unreachable_code)] |
203 | fn vec_unreachable(a: &Allocator) { | |
204 | let _x = vec![a.alloc(), a.alloc(), a.alloc(), return]; | |
205 | } | |
206 | ||
ff7c6d11 XL |
207 | fn slice_pattern_first(a: &Allocator) { |
208 | let[_x, ..] = [a.alloc(), a.alloc(), a.alloc()]; | |
209 | } | |
210 | ||
211 | fn slice_pattern_middle(a: &Allocator) { | |
212 | let[_, _x, _] = [a.alloc(), a.alloc(), a.alloc()]; | |
213 | } | |
214 | ||
215 | fn slice_pattern_two(a: &Allocator) { | |
216 | let[_x, _, _y, _] = [a.alloc(), a.alloc(), a.alloc(), a.alloc()]; | |
217 | } | |
218 | ||
219 | fn slice_pattern_last(a: &Allocator) { | |
220 | let[.., _y] = [a.alloc(), a.alloc(), a.alloc(), a.alloc()]; | |
221 | } | |
222 | ||
223 | fn slice_pattern_one_of(a: &Allocator, i: usize) { | |
224 | let array = [a.alloc(), a.alloc(), a.alloc(), a.alloc()]; | |
225 | let _x = match i { | |
226 | 0 => { let [a, ..] = array; a } | |
227 | 1 => { let [_, a, ..] = array; a } | |
228 | 2 => { let [_, _, a, _] = array; a } | |
229 | 3 => { let [_, _, _, a] = array; a } | |
230 | _ => panic!("unmatched"), | |
231 | }; | |
232 | } | |
233 | ||
0531ce1d XL |
234 | fn subslice_pattern_from_end(a: &Allocator, arg: bool) { |
235 | let a = [a.alloc(), a.alloc(), a.alloc()]; | |
236 | if arg { | |
237 | let[.., _x, _] = a; | |
238 | } else { | |
416331ca | 239 | let[_, _y @ ..] = a; |
0531ce1d XL |
240 | } |
241 | } | |
242 | ||
243 | fn subslice_pattern_from_end_with_drop(a: &Allocator, arg: bool, arg2: bool) { | |
244 | let a = [a.alloc(), a.alloc(), a.alloc(), a.alloc(), a.alloc()]; | |
245 | if arg2 { | |
246 | drop(a); | |
247 | return; | |
248 | } | |
249 | ||
250 | if arg { | |
251 | let[.., _x, _] = a; | |
252 | } else { | |
416331ca | 253 | let[_, _y @ ..] = a; |
0531ce1d XL |
254 | } |
255 | } | |
256 | ||
257 | fn slice_pattern_reassign(a: &Allocator) { | |
258 | let mut ar = [a.alloc(), a.alloc()]; | |
259 | let[_, _x] = ar; | |
260 | ar = [a.alloc(), a.alloc()]; | |
261 | let[.., _y] = ar; | |
262 | } | |
263 | ||
264 | fn subslice_pattern_reassign(a: &Allocator) { | |
265 | let mut ar = [a.alloc(), a.alloc(), a.alloc()]; | |
266 | let[_, _, _x] = ar; | |
267 | ar = [a.alloc(), a.alloc(), a.alloc()]; | |
416331ca | 268 | let[_, _y @ ..] = ar; |
0531ce1d XL |
269 | } |
270 | ||
60c5eb7d XL |
271 | fn index_field_mixed_ends(a: &Allocator) { |
272 | let ar = [(a.alloc(), a.alloc()), (a.alloc(), a.alloc())]; | |
273 | let[(_x, _), ..] = ar; | |
274 | let[(_, _y), _] = ar; | |
275 | let[_, (_, _w)] = ar; | |
276 | let[.., (_z, _)] = ar; | |
277 | } | |
278 | ||
279 | fn subslice_mixed_min_lengths(a: &Allocator, c: i32) { | |
280 | let ar = [(a.alloc(), a.alloc()), (a.alloc(), a.alloc())]; | |
281 | match c { | |
282 | 0 => { let[_x, ..] = ar; } | |
283 | 1 => { let[_x, _, ..] = ar; } | |
284 | 2 => { let[_x, _] = ar; } | |
285 | 3 => { let[(_x, _), _, ..] = ar; } | |
286 | 4 => { let[.., (_x, _)] = ar; } | |
287 | 5 => { let[.., (_x, _), _] = ar; } | |
288 | 6 => { let [_y @ ..] = ar; } | |
289 | _ => { let [_y @ .., _] = ar; } | |
290 | } | |
291 | } | |
292 | ||
74b04a01 XL |
293 | fn bindings_after_at_dynamic_init_move(a: &Allocator, c: bool) { |
294 | let foo = if c { Some(a.alloc()) } else { None }; | |
295 | let _x; | |
296 | ||
297 | if let bar @ Some(_) = foo { | |
298 | _x = bar; | |
299 | } | |
300 | } | |
301 | ||
302 | fn bindings_after_at_dynamic_init_ref(a: &Allocator, c: bool) { | |
303 | let foo = if c { Some(a.alloc()) } else { None }; | |
304 | let _x; | |
305 | ||
306 | if let bar @ Some(_baz) = &foo { | |
307 | _x = bar; | |
308 | } | |
309 | } | |
310 | ||
311 | fn bindings_after_at_dynamic_drop_move(a: &Allocator, c: bool) { | |
312 | let foo = if c { Some(a.alloc()) } else { None }; | |
313 | ||
314 | if let bar @ Some(_) = foo { | |
315 | bar | |
316 | } else { | |
317 | None | |
318 | }; | |
319 | } | |
320 | ||
321 | fn bindings_after_at_dynamic_drop_ref(a: &Allocator, c: bool) { | |
322 | let foo = if c { Some(a.alloc()) } else { None }; | |
323 | ||
324 | if let bar @ Some(_baz) = &foo { | |
325 | bar | |
326 | } else { | |
327 | &None | |
328 | }; | |
329 | } | |
330 | ||
331 | fn move_ref_pattern(a: &Allocator) { | |
332 | let mut tup = (a.alloc(), a.alloc(), a.alloc(), a.alloc()); | |
333 | let (ref _a, ref mut _b, _c, mut _d) = tup; | |
334 | } | |
335 | ||
dc9dc135 XL |
336 | fn panic_after_return(a: &Allocator) -> Ptr<'_> { |
337 | // Panic in the drop of `p` or `q` can leak | |
338 | let exceptions = vec![8, 9]; | |
339 | a.alloc(); | |
340 | let p = a.alloc(); | |
341 | { | |
342 | a.alloc(); | |
343 | let p = a.alloc(); | |
344 | // FIXME (#47949) We leak values when we panic in a destructor after | |
345 | // evaluating an expression with `rustc_mir::build::Builder::into`. | |
346 | a.alloc_leaked(exceptions) | |
347 | } | |
348 | } | |
349 | ||
350 | fn panic_after_return_expr(a: &Allocator) -> Ptr<'_> { | |
351 | // Panic in the drop of `p` or `q` can leak | |
352 | let exceptions = vec![8, 9]; | |
353 | a.alloc(); | |
354 | let p = a.alloc(); | |
355 | { | |
356 | a.alloc(); | |
357 | let q = a.alloc(); | |
358 | // FIXME (#47949) | |
359 | return a.alloc_leaked(exceptions); | |
360 | } | |
361 | } | |
362 | ||
363 | fn panic_after_init(a: &Allocator) { | |
364 | // Panic in the drop of `r` can leak | |
365 | let exceptions = vec![8]; | |
366 | a.alloc(); | |
367 | let p = a.alloc(); | |
368 | let q = { | |
369 | a.alloc(); | |
370 | let r = a.alloc(); | |
371 | // FIXME (#47949) | |
372 | a.alloc_leaked(exceptions) | |
373 | }; | |
374 | } | |
375 | ||
376 | fn panic_after_init_temp(a: &Allocator) { | |
377 | // Panic in the drop of `r` can leak | |
378 | let exceptions = vec![8]; | |
379 | a.alloc(); | |
380 | let p = a.alloc(); | |
381 | { | |
382 | a.alloc(); | |
383 | let r = a.alloc(); | |
384 | // FIXME (#47949) | |
385 | a.alloc_leaked(exceptions) | |
386 | }; | |
387 | } | |
388 | ||
389 | fn panic_after_init_by_loop(a: &Allocator) { | |
390 | // Panic in the drop of `r` can leak | |
391 | let exceptions = vec![8]; | |
392 | a.alloc(); | |
393 | let p = a.alloc(); | |
394 | let q = loop { | |
395 | a.alloc(); | |
396 | let r = a.alloc(); | |
397 | // FIXME (#47949) | |
398 | break a.alloc_leaked(exceptions); | |
399 | }; | |
400 | } | |
401 | ||
3157f602 XL |
402 | fn run_test<F>(mut f: F) |
403 | where F: FnMut(&Allocator) | |
404 | { | |
405 | let first_alloc = Allocator::new(usize::MAX); | |
406 | f(&first_alloc); | |
407 | ||
408 | for failing_op in 1..first_alloc.cur_ops.get()+1 { | |
409 | let alloc = Allocator::new(failing_op); | |
410 | let alloc = &alloc; | |
411 | let f = panic::AssertUnwindSafe(&mut f); | |
412 | let result = panic::catch_unwind(move || { | |
413 | f.0(alloc); | |
414 | }); | |
415 | match result { | |
416 | Ok(..) => panic!("test executed {} ops but now {}", | |
417 | first_alloc.cur_ops.get(), alloc.cur_ops.get()), | |
418 | Err(e) => { | |
419 | if e.downcast_ref::<InjectedFailure>().is_none() { | |
420 | panic::resume_unwind(e); | |
421 | } | |
422 | } | |
423 | } | |
424 | } | |
425 | } | |
426 | ||
9e0c209e SL |
427 | fn run_test_nopanic<F>(mut f: F) |
428 | where F: FnMut(&Allocator) | |
429 | { | |
430 | let first_alloc = Allocator::new(usize::MAX); | |
431 | f(&first_alloc); | |
432 | } | |
433 | ||
3157f602 XL |
434 | fn main() { |
435 | run_test(|a| dynamic_init(a, false)); | |
436 | run_test(|a| dynamic_init(a, true)); | |
437 | run_test(|a| dynamic_drop(a, false)); | |
438 | run_test(|a| dynamic_drop(a, true)); | |
439 | ||
440 | run_test(|a| assignment2(a, false, false)); | |
441 | run_test(|a| assignment2(a, false, true)); | |
442 | run_test(|a| assignment2(a, true, false)); | |
443 | run_test(|a| assignment2(a, true, true)); | |
444 | ||
445 | run_test(|a| assignment1(a, false)); | |
446 | run_test(|a| assignment1(a, true)); | |
9e0c209e | 447 | |
7cac9316 XL |
448 | run_test(|a| array_simple(a)); |
449 | run_test(|a| vec_simple(a)); | |
3b2f2976 | 450 | run_test(|a| vec_unreachable(a)); |
7cac9316 XL |
451 | |
452 | run_test(|a| struct_dynamic_drop(a, false, false, false)); | |
453 | run_test(|a| struct_dynamic_drop(a, false, false, true)); | |
454 | run_test(|a| struct_dynamic_drop(a, false, true, false)); | |
455 | run_test(|a| struct_dynamic_drop(a, false, true, true)); | |
456 | run_test(|a| struct_dynamic_drop(a, true, false, false)); | |
457 | run_test(|a| struct_dynamic_drop(a, true, false, true)); | |
458 | run_test(|a| struct_dynamic_drop(a, true, true, false)); | |
459 | run_test(|a| struct_dynamic_drop(a, true, true, true)); | |
460 | ||
041b39d2 XL |
461 | run_test(|a| field_assignment(a, false)); |
462 | run_test(|a| field_assignment(a, true)); | |
463 | ||
abe05a73 XL |
464 | run_test(|a| generator(a, 0)); |
465 | run_test(|a| generator(a, 1)); | |
466 | run_test(|a| generator(a, 2)); | |
467 | run_test(|a| generator(a, 3)); | |
468 | ||
469 | run_test(|a| mixed_drop_and_nondrop(a)); | |
470 | ||
ff7c6d11 XL |
471 | run_test(|a| slice_pattern_first(a)); |
472 | run_test(|a| slice_pattern_middle(a)); | |
473 | run_test(|a| slice_pattern_two(a)); | |
474 | run_test(|a| slice_pattern_last(a)); | |
475 | run_test(|a| slice_pattern_one_of(a, 0)); | |
476 | run_test(|a| slice_pattern_one_of(a, 1)); | |
477 | run_test(|a| slice_pattern_one_of(a, 2)); | |
478 | run_test(|a| slice_pattern_one_of(a, 3)); | |
479 | ||
0531ce1d XL |
480 | run_test(|a| subslice_pattern_from_end(a, true)); |
481 | run_test(|a| subslice_pattern_from_end(a, false)); | |
482 | run_test(|a| subslice_pattern_from_end_with_drop(a, true, true)); | |
483 | run_test(|a| subslice_pattern_from_end_with_drop(a, true, false)); | |
484 | run_test(|a| subslice_pattern_from_end_with_drop(a, false, true)); | |
485 | run_test(|a| subslice_pattern_from_end_with_drop(a, false, false)); | |
486 | run_test(|a| slice_pattern_reassign(a)); | |
487 | run_test(|a| subslice_pattern_reassign(a)); | |
488 | ||
60c5eb7d XL |
489 | run_test(|a| index_field_mixed_ends(a)); |
490 | run_test(|a| subslice_mixed_min_lengths(a, 0)); | |
491 | run_test(|a| subslice_mixed_min_lengths(a, 1)); | |
492 | run_test(|a| subslice_mixed_min_lengths(a, 2)); | |
493 | run_test(|a| subslice_mixed_min_lengths(a, 3)); | |
494 | run_test(|a| subslice_mixed_min_lengths(a, 4)); | |
495 | run_test(|a| subslice_mixed_min_lengths(a, 5)); | |
496 | run_test(|a| subslice_mixed_min_lengths(a, 6)); | |
497 | run_test(|a| subslice_mixed_min_lengths(a, 7)); | |
498 | ||
74b04a01 XL |
499 | run_test(|a| move_ref_pattern(a)); |
500 | ||
dc9dc135 XL |
501 | run_test(|a| { |
502 | panic_after_return(a); | |
503 | }); | |
504 | run_test(|a| { | |
505 | panic_after_return_expr(a); | |
506 | }); | |
507 | run_test(|a| panic_after_init(a)); | |
508 | run_test(|a| panic_after_init_temp(a)); | |
509 | run_test(|a| panic_after_init_by_loop(a)); | |
510 | ||
74b04a01 XL |
511 | run_test(|a| bindings_after_at_dynamic_init_move(a, true)); |
512 | run_test(|a| bindings_after_at_dynamic_init_move(a, false)); | |
513 | run_test(|a| bindings_after_at_dynamic_init_ref(a, true)); | |
514 | run_test(|a| bindings_after_at_dynamic_init_ref(a, false)); | |
515 | run_test(|a| bindings_after_at_dynamic_drop_move(a, true)); | |
516 | run_test(|a| bindings_after_at_dynamic_drop_move(a, false)); | |
517 | run_test(|a| bindings_after_at_dynamic_drop_ref(a, true)); | |
518 | run_test(|a| bindings_after_at_dynamic_drop_ref(a, false)); | |
519 | ||
9e0c209e | 520 | run_test_nopanic(|a| union1(a)); |
3157f602 | 521 | } |