1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
//@ run-pass
#![expect(incomplete_features)]
#![feature(explicit_tail_calls)]
use std::cell::RefCell;
fn main() {
let tail_counter = Default::default();
tail_recursive(0, &tail_counter);
assert_eq!(tail_counter.into_inner(), (0..128).collect::<Vec<u8>>());
let simply_counter = Default::default();
simply_recursive(0, &simply_counter);
assert_eq!(simply_counter.into_inner(), (0..128).rev().collect::<Vec<u8>>());
let scope_counter = Default::default();
out_of_inner_scope(&scope_counter);
assert_eq!(scope_counter.into_inner(), (0..8).collect::<Vec<u8>>());
}
fn tail_recursive(n: u8, order: &RefCell<Vec<u8>>) {
if n >= 128 {
return;
}
let _local = DropCounter(n, order);
become tail_recursive(n + 1, order)
}
fn simply_recursive(n: u8, order: &RefCell<Vec<u8>>) {
if n >= 128 {
return;
}
let _local = DropCounter(n, order);
return simply_recursive(n + 1, order);
}
fn out_of_inner_scope(order: &RefCell<Vec<u8>>) {
fn inner(order: &RefCell<Vec<u8>>) {
let _7 = DropCounter(7, order);
let _6 = DropCounter(6, order);
}
let _5 = DropCounter(5, order);
let _4 = DropCounter(4, order);
if true {
let _3 = DropCounter(3, order);
let _2 = DropCounter(2, order);
loop {
let _1 = DropCounter(1, order);
let _0 = DropCounter(0, order);
become inner(order);
}
}
}
struct DropCounter<'a>(u8, &'a RefCell<Vec<u8>>);
impl Drop for DropCounter<'_> {
#[track_caller]
fn drop(&mut self) {
self.1.borrow_mut().push(self.0);
}
}
|
