diff options
| -rw-r--r-- | Makefile | 4 | ||||
| -rw-r--r-- | trace_reference.txt | 16974 |
2 files changed, 16977 insertions, 1 deletions
@@ -1,5 +1,7 @@ all: - dune build src/main.exe && dune exec src/main.exe + dune build src/main.exe && \ + dune exec src/main.exe > trace_current.txt && \ + cmp trace_reference.txt trace_current.txt doc: dune build @doc diff --git a/trace_reference.txt b/trace_reference.txt new file mode 100644 index 00000000..ee8828da --- /dev/null +++ b/trace_reference.txt @@ -0,0 +1,16974 @@ +[[32mDebug[39m] +struct test1::Pair<T1, T2>{ + x : T1, + y : T2} + +enum test1::List<T> = +| Cons(0 : T, 1 : std::boxed::Box<test1::List<T>>) +| Nil() + +enum test1::One<T1> = +| One(0 : T1) + +enum test1::EmptyEnum = +| Empty() + +enum test1::Enum = +| Variant1() +| Variant2() + +struct test1::EmptyStruct{} + +enum test1::Sum<T1, T2> = +| Left(0 : T1) +| Right(0 : T2) + +fn add_test(x : u32, y : u32) -> u32 { + var@0 : u32; + x : u32; + y : u32; + var@3 : u32; + var@4 : u32; + var@5 : (u32, bool); + + var@3 := copy x + var@4 := copy y + var@0 := copy var@3 + copy var@4 + return +} + +fn subs_test(x : u32, y : u32) -> u32 { + var@0 : u32; + x : u32; + y : u32; + var@3 : u32; + var@4 : u32; + var@5 : (u32, bool); + + var@3 := copy x + var@4 := copy y + var@0 := copy var@3 - copy var@4 + return +} + +fn div_test(x : u32, y : u32) -> u32 { + var@0 : u32; + x : u32; + y : u32; + var@3 : u32; + var@4 : u32; + var@5 : bool; + + var@3 := copy x + var@4 := copy y + var@0 := move var@3 / move var@4 + return +} + +fn rem_test(x : u32, y : u32) -> u32 { + var@0 : u32; + x : u32; + y : u32; + var@3 : u32; + var@4 : u32; + var@5 : bool; + + var@3 := copy x + var@4 := copy y + var@0 := move var@3 % move var@4 + return +} + +fn test2() { + var@0 : (); + x : u32; + y : u32; + z : u32; + p : test1::Pair<u32, u32>; + var@5 : u32; + s : test1::Sum<u32, bool>; + o : test1::One<u64>; + e0 : test1::EmptyEnum; + e1 : test1::EmptyEnum; + enum0 : test1::Enum; + + x := 23: u32 + y := 44: u32 + z := 67: u32 + var@5 := copy x + (p).x := move var@5 + (p).y := 67: u32 + (s as test1::Sum::Right).0 := true + set_discriminant(s, 1) + (o as test1::One::One).0 := 3: u64 + set_discriminant(o, 0) + set_discriminant(e0, 0) + set_discriminant(enum0, 0) + return +} + +fn get_max(x : u32, y : u32) -> u32 { + var@0 : u32; + x : u32; + y : u32; + var@3 : bool; + var@4 : u32; + var@5 : u32; + + var@4 := copy x + var@5 := copy y + var@3 := move var@4 >= move var@5 + if (move var@3) { + var@0 := copy x + } + else { + var@0 := copy y + } + return +} + +fn test3() { + var@0 : (); + x : u32; + y : u32; + z : u32; + var@4 : u32; + var@5 : u32; + var@6 : (u32, bool); + var@7 : bool; + var@8 : bool; + var@9 : u32; + + x := move get_max(4: u32, 3: u32) + y := move get_max(10: u32, 11: u32) + var@4 := copy x + var@5 := copy y + z := copy var@4 + copy var@5 + var@9 := copy z + var@8 := move var@9 == 15: u32 + var@7 := ¬ move var@8 + assert(¬move var@7) + return +} + +fn test_neg(x : i32) -> i32 { + var@0 : i32; + x : i32; + var@2 : i32; + var@3 : bool; + + var@2 := copy x + var@3 := copy var@2 == -2147483648: i32 + assert(¬move var@3) + var@0 := - move var@2 + return +} + +fn test_neg1() { + var@0 : (); + x : i32; + y : i32; + + x := 3: i32 + y := -3: i32 + return +} + +fn refs_test() { + var@0 : (); + x : i32; + y : i32; + px : &'_ mut (i32); + py : &'_ mut (i32); + ppx : &'_ mut (&'_ mut (i32)); + var@6 : &'_ mut (i32); + var@7 : bool; + var@8 : bool; + var@9 : i32; + var@10 : bool; + var@11 : bool; + var@12 : i32; + var@13 : bool; + var@14 : bool; + var@15 : i32; + var@16 : bool; + var@17 : bool; + var@18 : i32; + + x := 0: i32 + y := 1: i32 + px := &mut x + py := &mut y + ppx := &mut px + var@6 := &mut *(py) + *(ppx) := move var@6 + *(*(ppx)) := 2: i32 + var@9 := copy *(px) + var@8 := move var@9 == 2: i32 + var@7 := ¬ move var@8 + assert(¬move var@7) + var@12 := copy x + var@11 := move var@12 == 0: i32 + var@10 := ¬ move var@11 + assert(¬move var@10) + var@15 := copy *(py) + var@14 := move var@15 == 2: i32 + var@13 := ¬ move var@14 + assert(¬move var@13) + var@18 := copy y + var@17 := move var@18 == 2: i32 + var@16 := ¬ move var@17 + assert(¬move var@16) + return +} + +fn test_list1() { + var@0 : (); + l : test1::List<i32>; + var@2 : std::boxed::Box<test1::List<i32>>; + var@3 : test1::List<i32>; + + set_discriminant(var@3, 1) + var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) + (l as test1::List::Cons).0 := 0: i32 + (l as test1::List::Cons).1 := move var@2 + set_discriminant(l, 0) +drop(l) + return +} + +fn test_box1() { + var@0 : (); + b : std::boxed::Box<i32>; + x : &'_ mut (i32); + var@3 : &'_ mut (std::boxed::Box<i32>); + x : &'_ (i32); + var@5 : &'_ (std::boxed::Box<i32>); + var@6 : bool; + var@7 : bool; + var@8 : i32; + + b := move alloc::boxed::Box<i32>::new(0: i32) + var@3 := &two-phase b + x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3) + *(x) := 1: i32 + var@5 := &b + x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5) + var@8 := copy *(x) + var@7 := move var@8 == 1: i32 + var@6 := ¬ move var@7 + assert(¬move var@6) +drop(b) + return +} + +fn copy_int(x : i32) -> i32 { + var@0 : i32; + x : i32; + + var@0 := copy x + return +} + +fn test_copy_int() { + var@0 : (); + x : i32; + px : &'_ (i32); + y : i32; + var@4 : i32; + var@5 : bool; + var@6 : bool; + var@7 : i32; + var@8 : i32; + + x := 0: i32 + px := &x + var@4 := copy x + y := move copy_int(move var@4) + var@7 := copy *(px) + var@8 := copy y + var@6 := move var@7 == move var@8 + var@5 := ¬ move var@6 + assert(¬move var@5) + return +} + +fn is_cons<0,T>(l : &0 (test1::List<T>)) -> bool { + var@0 : bool; + l : &'_ (test1::List<T>); + var@2 : isize; + + var@2 := discriminant(*(l)) + switch (move var@2) { + 0: isize => { + var@0 := true + } + 1: isize => { + var@0 := false + } + _ => { + panic + } + } + return +} + +fn test_is_cons() { + var@0 : (); + l : test1::List<i32>; + var@2 : std::boxed::Box<test1::List<i32>>; + var@3 : test1::List<i32>; + var@4 : bool; + var@5 : bool; + var@6 : &'_ (test1::List<i32>); + var@7 : &'_ (test1::List<i32>); + + set_discriminant(var@3, 1) + var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) + (l as test1::List::Cons).0 := 0: i32 + (l as test1::List::Cons).1 := move var@2 + set_discriminant(l, 0) + var@7 := &l + var@6 := copy var@7 + var@5 := move is_cons<i32>(move var@6) + var@4 := ¬ move var@5 + assert(¬move var@4) +drop(l) + return +} + +fn split_list<T>(l : test1::List<T>) -> (T, test1::List<T>) { + var@0 : (T, test1::List<T>); + l : test1::List<T>; + var@2 : isize; + hd : T; + tl : std::boxed::Box<test1::List<T>>; + var@5 : T; + var@6 : test1::List<T>; + var@7 : bool; + var@8 : bool; + var@9 : (); + var@10 : isize; + + var@8 := false + var@7 := false + var@7 := true + var@8 := true + var@2 := discriminant(l) + switch (move var@2) { + 0: isize => { + var@8 := false + hd := move (l as test1::List::Cons).0 + var@7 := false + tl := move (l as test1::List::Cons).1 + var@5 := move hd + var@6 := move deref_box(tl) + (var@0).0 := move var@5 + (var@0).1 := move var@6 + var@9 := move alloc::alloc::box_free<test1::List<T>>(move tl) + return + } + _ => { + panic + } + } +} + +fn test_split_list() { + var@0 : (); + l : test1::List<i32>; + var@2 : std::boxed::Box<test1::List<i32>>; + var@3 : test1::List<i32>; + hd : i32; + tl : test1::List<i32>; + var@6 : (i32, test1::List<i32>); + var@7 : test1::List<i32>; + var@8 : bool; + var@9 : bool; + var@10 : i32; + + set_discriminant(var@3, 1) + var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) + (l as test1::List::Cons).0 := 0: i32 + (l as test1::List::Cons).1 := move var@2 + set_discriminant(l, 0) + var@7 := move l + var@6 := move split_list<i32>(move var@7) + hd := copy (var@6).0 + tl := move (var@6).1 + var@10 := copy hd + var@9 := move var@10 == 0: i32 + var@8 := ¬ move var@9 + assert(¬move var@8) +drop(tl) + return +} + +fn get_elem<'a,T>(b : bool, x : &'a mut (T), y : &'a mut (T)) -> &'a mut (T) { + var@0 : &'_ mut (T); + b : bool; + x : &'_ mut (T); + y : &'_ mut (T); + var@4 : bool; + + var@4 := copy b + if (move var@4) { + var@0 := &mut *(x) + } + else { + var@0 := move y + } + return +} + +fn get_elem_test() { + var@0 : (); + x : i32; + y : i32; + z : &'_ mut (i32); + var@4 : &'_ mut (i32); + var@5 : &'_ mut (i32); + var@6 : &'_ mut (i32); + var@7 : &'_ mut (i32); + var@8 : i32; + var@9 : (i32, bool); + var@10 : bool; + var@11 : bool; + var@12 : i32; + var@13 : bool; + var@14 : bool; + var@15 : i32; + var@16 : bool; + var@17 : bool; + var@18 : i32; + + x := 0: i32 + y := 0: i32 + var@5 := &mut x + var@4 := &two-phase *(var@5) + var@7 := &mut y + var@6 := &two-phase *(var@7) + z := move get_elem<i32>(true, move var@4, move var@6) + var@8 := copy *(z) + *(z) := copy var@8 + 1: i32 + var@12 := copy *(z) + var@11 := move var@12 == 1: i32 + var@10 := ¬ move var@11 + assert(¬move var@10) + var@15 := copy x + var@14 := move var@15 == 1: i32 + var@13 := ¬ move var@14 + assert(¬move var@13) + var@18 := copy y + var@17 := move var@18 == 0: i32 + var@16 := ¬ move var@17 + assert(¬move var@16) + return +} + +fn id_mut_mut<'a,'b,T>(x : &'a mut (&'b mut (T))) -> &'a mut (&'b mut (T)) { + var@0 : &'_ mut (&'_ mut (T)); + x : &'_ mut (&'_ mut (T)); + var@2 : &'_ mut (&'_ mut (T)); + + var@2 := &mut *(x) + var@0 := &mut *(var@2) + return +} + +fn id_mut_pair<'a,T>(x : &'a mut ((&'a mut (T), u32))) -> &'a mut ((&'a mut (T), u32)) { + var@0 : &'_ mut ((&'_ mut (T), u32)); + x : &'_ mut ((&'_ mut (T), u32)); + var@2 : &'_ mut ((&'_ mut (T), u32)); + + var@2 := &mut *(x) + var@0 := &mut *(var@2) + return +} + +fn id_mut_pair_test1() { + var@0 : (); + x : u32; + px : &'_ mut (u32); + p : (&'_ mut (u32), u32); + var@4 : &'_ mut (u32); + pp0 : &'_ mut ((&'_ mut (u32), u32)); + pp1 : &'_ mut ((&'_ mut (u32), u32)); + var@7 : &'_ mut ((&'_ mut (u32), u32)); + y : u32; + var@9 : &'_ mut (u32); + var@10 : &'_ mut (u32); + + x := 0: u32 + px := &mut x + var@4 := move px + (p).0 := move var@4 + (p).1 := 1: u32 + pp0 := &mut p + var@7 := &two-phase *(pp0) + pp1 := move id_mut_pair<u32>(move var@7) + y := 2: u32 + var@10 := &mut y + var@9 := &mut *(var@10) + *((pp1).0) := move var@9 + *((pp1).1) := 3: u32 + return +} + +fn id_mut_mut_pair<'a,T>(x : &'a mut (&'a mut ((&'a mut (T), u32)))) -> &'a mut (&'a mut ((&'a mut (T), u32))) { + var@0 : &'_ mut (&'_ mut ((&'_ mut (T), u32))); + x : &'_ mut (&'_ mut ((&'_ mut (T), u32))); + var@2 : &'_ mut (&'_ mut ((&'_ mut (T), u32))); + + var@2 := &mut *(x) + var@0 := &mut *(var@2) + return +} + +fn id_mut_mut_mut_same<'a,T>(x : &'a mut (&'a mut (&'a mut (u32)))) -> &'a mut (&'a mut (&'a mut (u32))) { + var@0 : &'_ mut (&'_ mut (&'_ mut (u32))); + x : &'_ mut (&'_ mut (&'_ mut (u32))); + var@2 : &'_ mut (&'_ mut (&'_ mut (u32))); + + var@2 := &mut *(x) + var@0 := &mut *(var@2) + return +} + +fn id_borrow1<'a,'b>(_x : &'a mut (&'b (u32)), _y : &'a (&'a mut (u32))) { + var@0 : (); + _x : &'_ mut (&'_ (u32)); + _y : &'_ (&'_ mut (u32)); + + return +} + +fn test_loop1(max : u32) -> u32 { + s : u32; + max : u32; + i : u32; + var@3 : bool; + var@4 : u32; + var@5 : u32; + var@6 : u32; + var@7 : (u32, bool); + var@8 : (u32, bool); + var@9 : (u32, bool); + + i := 0: u32 + s := 0: u32 + loop { + var@4 := copy i + var@5 := copy max + var@3 := move var@4 < move var@5 + if (move var@3) { + var@6 := copy i + s := copy s + copy var@6 + i := copy i + 1: u32 + continue 0 + } + else { + break 0 + } + } + s := copy s * 2: u32 + return +} + +fn test_loop2(max : u32) -> u32 { + s : u32; + max : u32; + i : u32; + var@3 : bool; + var@4 : u32; + var@5 : u32; + var@6 : u32; + var@7 : u32; + var@8 : (u32, bool); + var@9 : (u32, bool); + + i := 0: u32 + s := 0: u32 + loop { + var@4 := copy i + var@5 := copy max + var@3 := move var@4 < move var@5 + if (move var@3) { + var@6 := copy i + switch (move var@6) { + 17: u32 => { + break 0 + } + _ => { + var@7 := copy i + s := copy s + copy var@7 + i := copy i + 1: u32 + continue 0 + } + } + } + else { + break 0 + } + } + return +} + +fn test_loop3(max : u32) -> u32 { + s : u32; + max : u32; + i : u32; + j : u32; + var@4 : bool; + var@5 : u32; + var@6 : u32; + var@7 : bool; + var@8 : u32; + var@9 : u32; + var@10 : u32; + var@11 : u32; + var@12 : u32; + var@13 : (u32, bool); + var@14 : u32; + var@15 : (u32, bool); + var@16 : (u32, bool); + var@17 : u32; + var@18 : (u32, bool); + var@19 : (u32, bool); + + i := 0: u32 + j := 0: u32 + s := 0: u32 + loop { + var@5 := copy i + var@6 := copy max + var@4 := move var@5 < move var@6 + if (move var@4) { + loop { + var@8 := copy j + var@9 := copy max + var@7 := move var@8 < move var@9 + if (move var@7) { + var@11 := copy i + var@12 := copy j + var@10 := copy var@11 + copy var@12 + switch (move var@10) { + 17: u32 => { + continue 0 + } + _ => { + nop + } + } + var@14 := copy i + s := copy s + copy var@14 + j := copy j + 1: u32 + continue 1 + } + else { + break 0 + } + } + j := 0: u32 + var@17 := copy i + s := copy s + copy var@17 + i := copy i + 1: u32 + continue 0 + } + else { + break 0 + } + } + return +} + +fn test_loop4(max : u32) -> u32 { + s : u32; + max : u32; + i : u32; + j : u32; + var@4 : bool; + var@5 : u32; + var@6 : u32; + var@7 : bool; + var@8 : u32; + var@9 : u32; + var@10 : u32; + var@11 : u32; + var@12 : u32; + var@13 : (u32, bool); + var@14 : u32; + var@15 : (u32, bool); + var@16 : (u32, bool); + var@17 : u32; + var@18 : (u32, bool); + var@19 : (u32, bool); + + i := 0: u32 + j := 0: u32 + s := 0: u32 + loop { + var@5 := copy i + var@6 := copy max + var@4 := move var@5 < move var@6 + if (move var@4) { + loop { + var@8 := copy j + var@9 := copy max + var@7 := move var@8 < move var@9 + if (move var@7) { + var@11 := copy i + var@12 := copy j + var@10 := copy var@11 + copy var@12 + switch (move var@10) { + 17: u32 => { + continue 0 + } + _ => { + nop + } + } + var@14 := copy i + s := copy s + copy var@14 + j := copy j + 1: u32 + break 1 + } + else { + break 0 + } + } + j := 0: u32 + var@17 := copy i + s := copy s + copy var@17 + i := copy i + 1: u32 + continue 0 + } + else { + break 0 + } + } + return +} + +fn test_loop5(max : u32) -> u32 { + s : u32; + max : u32; + i : u32; + j : u32; + var@4 : bool; + var@5 : u32; + var@6 : u32; + var@7 : bool; + var@8 : u32; + var@9 : u32; + var@10 : u32; + var@11 : (u32, bool); + var@12 : (u32, bool); + var@13 : u32; + var@14 : (u32, bool); + var@15 : (u32, bool); + + i := 0: u32 + j := 0: u32 + s := 0: u32 + loop { + var@5 := copy i + var@6 := copy max + var@4 := move var@5 < move var@6 + if (move var@4) { + loop { + var@8 := copy j + var@9 := copy max + var@7 := move var@8 < move var@9 + if (move var@7) { + var@10 := copy j + s := copy s + copy var@10 + j := copy j + 1: u32 + continue 0 + } + else { + break 0 + } + } + var@13 := copy i + s := copy s + copy var@13 + i := copy i + 1: u32 + continue 0 + } + else { + break 0 + } + } + return +} + +fn test_loop6(max : u32) -> u32 { + s : u32; + max : u32; + i : u32; + var@3 : bool; + var@4 : u32; + var@5 : u32; + var@6 : bool; + var@7 : u32; + var@8 : u32; + var@9 : (u32, bool); + var@10 : (u32, bool); + var@11 : (u32, bool); + + i := 0: u32 + s := 0: u32 + loop { + var@4 := copy i + var@5 := copy max + var@3 := move var@4 < move var@5 + if (move var@3) { + var@7 := copy i + var@6 := move var@7 > 3: u32 + if (move var@6) { + break 0 + } + else { + var@8 := copy i + s := copy s + copy var@8 + i := copy i + 1: u32 + continue 0 + } + } + else { + break 0 + } + } + s := copy s + 1: u32 + return +} + +fn test_static(x : &'static (u32)) -> &'static (u32) { + var@0 : &'_ (u32); + x : &'_ (u32); + + var@0 := copy x + return +} + +fn test_char() -> char { + var@0 : char; + + var@0 := a + return +} + +[[32mDebug[39m] test_unit_function: test2 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: x := 23: u32 +y := 44: u32 +z := 67: u32 +var@5 := copy x +(p).x := move var@5 +(p).y := 67: u32 +(s as test1::Sum::Right).0 := true +set_discriminant(s, 1) +(o as test1::One::One).0 := 3: u64 +set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: x := 23: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + + +- op: +23: u32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: y := 44: u32 +z := 67: u32 +var@5 := copy x +(p).x := move var@5 +(p).y := 67: u32 +(s as test1::Sum::Right).0 := true +set_discriminant(s, 1) +(o as test1::One::One).0 := 3: u64 +set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: y := 44: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + + +- op: +44: u32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> ⊥ : u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: z := 67: u32 +var@5 := copy x +(p).x := move var@5 +(p).y := 67: u32 +(s as test1::Sum::Right).0 := true +set_discriminant(s, 1) +(o as test1::One::One).0 := 3: u64 +set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> ⊥ : u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: z := 67: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> ⊥ : u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + + +- op: +67: u32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: var@5 := copy x +(p).x := move var@5 +(p).y := 67: u32 +(s as test1::Sum::Right).0 := true +set_discriminant(s, 1) +(o as test1::One::One).0 := 3: u64 +set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: var@5 := copy x + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + + +- op: +copy x + +[[32mDebug[39m] Value to copy: +23: u32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> 23: u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: (p).x := move var@5 +(p).y := 67: u32 +(s as test1::Sum::Right).0 := true +set_discriminant(s, 1) +(o as test1::One::One).0 := 3: u64 +set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> 23: u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: (p).x := move var@5 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> ⊥ : test1::Pair<u32, u32> ; + var@5 -> 23: u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + + +- op: +move var@5 + +[[32mDebug[39m] Value to move: +23: u32 +[[32mDebug[39m] expand_bottom_value_from_projection: +pe: (Expressions.Field ((Expressions.ProjAdt (0, None)), 0)) +ty: (Types.Adt ((Types.AdtId 0), [], + [(Types.Integer Types.U32); (Types.Integer Types.U32)])) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = ⊥ : u32; } ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: (p).y := 67: u32 +(s as test1::Sum::Right).0 := true +set_discriminant(s, 1) +(o as test1::One::One).0 := 3: u64 +set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = ⊥ : u32; } ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: (p).y := 67: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = ⊥ : u32; } ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + + +- op: +67: u32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: (s as test1::Sum::Right).0 := true +set_discriminant(s, 1) +(o as test1::One::One).0 := 3: u64 +set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: (s as test1::Sum::Right).0 := true + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> ⊥ : test1::Sum<u32, bool> ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + + +- op: +true + +[[32mDebug[39m] expand_bottom_value_from_projection: +pe: (Expressions.Field ((Expressions.ProjAdt (6, (Some 1))), 0)) +ty: (Types.Adt ((Types.AdtId 6), [], [(Types.Integer Types.U32); Types.Bool])) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: set_discriminant(s, 1) +(o as test1::One::One).0 := 3: u64 +set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: set_discriminant(s, 1) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: (o as test1::One::One).0 := 3: u64 +set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: (o as test1::One::One).0 := 3: u64 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> ⊥ : test1::One<u64> ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + + +- op: +3: u64 + +[[32mDebug[39m] expand_bottom_value_from_projection: +pe: (Expressions.Field ((Expressions.ProjAdt (2, (Some 0))), 0)) +ty: (Types.Adt ((Types.AdtId 2), [], [(Types.Integer Types.U64)])) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> test1::One::One { 0 = 3: u64; } ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: set_discriminant(o, 0) +set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> test1::One::One { 0 = 3: u64; } ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: set_discriminant(o, 0) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> test1::One::One { 0 = 3: u64; } ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: set_discriminant(e0, 0) +set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> test1::One::One { 0 = 3: u64; } ; + e0 -> ⊥ : test1::EmptyEnum ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: set_discriminant(e0, 0) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> test1::One::One { 0 = 3: u64; } ; + e0 -> test1::EmptyEnum::Empty ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: set_discriminant(enum0, 0) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> test1::One::One { 0 = 3: u64; } ; + e0 -> test1::EmptyEnum::Empty ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> ⊥ : test1::Enum ; +} + +About to evaluate statement: set_discriminant(enum0, 0) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 23: u32 ; + y -> 44: u32 ; + z -> 67: u32 ; + p -> test1::Pair { x = 23: u32; y = 67: u32; } ; + var@5 -> ⊥ : u32 ; + s -> test1::Sum::Right { 0 = true; } ; + o -> test1::One::One { 0 = 3: u64; } ; + e0 -> test1::EmptyEnum::Empty ; + e1 -> ⊥ : test1::EmptyEnum ; + enum0 -> test1::Enum::Variant1 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: test3 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: x := move get_max(4: u32, 3: u32) +y := move get_max(10: u32, 11: u32) +var@4 := copy x +var@5 := copy y +z := copy var@4 + copy var@5 +var@9 := copy z +var@8 := move var@9 == 15: u32 +var@7 := ¬ move var@8 +assert(¬move var@7) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: x := move get_max(4: u32, 3: u32) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +4: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +3: u32 + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@4 := copy x +var@5 := copy y +var@3 := move var@4 >= move var@5 +if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@4 := copy x + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +copy x + +[[32mDebug[39m] Value to copy: +4: u32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 4: u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@5 := copy y +var@3 := move var@4 >= move var@5 +if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 4: u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@5 := copy y + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 4: u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +copy y + +[[32mDebug[39m] Value to copy: +3: u32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 4: u32 ; + var@5 -> 3: u32 ; +} + +About to evaluate statement: var@3 := move var@4 >= move var@5 +if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 4: u32 ; + var@5 -> 3: u32 ; +} + +About to evaluate statement: var@3 := move var@4 >= move var@5 + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 4: u32 ; + var@5 -> 3: u32 ; +} + + +- op: +move var@4 + +[[32mDebug[39m] Value to move: +4: u32 +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> 3: u32 ; +} + + +- op: +move var@5 + +[[32mDebug[39m] Value to move: +3: u32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> true ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> true ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> true ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +move var@3 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@0 := copy x + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +copy x + +[[32mDebug[39m] Value to copy: +4: u32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> 4: u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> 4: u32 ; + x -> 4: u32 ; + y -> 3: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [5,4,3,2,1] +[[32mDebug[39m] drop_value: place: var@5 +[[32mDebug[39m] drop_value: place: var@4 +[[32mDebug[39m] drop_value: place: var@3 +[[32mDebug[39m] drop_value: place: y +[[32mDebug[39m] drop_value: place: x +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> 4: u32 ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> 4: u32 ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +move var@0 + +[[32mDebug[39m] Value to move: +4: u32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: y := move get_max(10: u32, 11: u32) +var@4 := copy x +var@5 := copy y +z := copy var@4 + copy var@5 +var@9 := copy z +var@8 := move var@9 == 15: u32 +var@7 := ¬ move var@8 +assert(¬move var@7) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: y := move get_max(10: u32, 11: u32) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +10: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +11: u32 + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@4 := copy x +var@5 := copy y +var@3 := move var@4 >= move var@5 +if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@4 := copy x + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +copy x + +[[32mDebug[39m] Value to copy: +10: u32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 10: u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@5 := copy y +var@3 := move var@4 >= move var@5 +if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 10: u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@5 := copy y + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 10: u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +copy y + +[[32mDebug[39m] Value to copy: +11: u32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 10: u32 ; + var@5 -> 11: u32 ; +} + +About to evaluate statement: var@3 := move var@4 >= move var@5 +if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 10: u32 ; + var@5 -> 11: u32 ; +} + +About to evaluate statement: var@3 := move var@4 >= move var@5 + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> 10: u32 ; + var@5 -> 11: u32 ; +} + + +- op: +move var@4 + +[[32mDebug[39m] Value to move: +10: u32 +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> 11: u32 ; +} + + +- op: +move var@5 + +[[32mDebug[39m] Value to move: +11: u32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> false ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> false ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: if (move var@3) { + var@0 := copy x +} +else { + var@0 := copy y +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> false ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +move var@3 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: var@0 := copy y + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +copy y + +[[32mDebug[39m] Value to copy: +11: u32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> 11: u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> 11: u32 ; + x -> 10: u32 ; + y -> 11: u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [5,4,3,2,1] +[[32mDebug[39m] drop_value: place: var@5 +[[32mDebug[39m] drop_value: place: var@4 +[[32mDebug[39m] drop_value: place: var@3 +[[32mDebug[39m] drop_value: place: y +[[32mDebug[39m] drop_value: place: x +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> 11: u32 ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> ⊥ : u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +# Frame 1: +{ + var@0 -> 11: u32 ; + x -> ⊥ : u32 ; + y -> ⊥ : u32 ; + var@3 -> ⊥ : bool ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; +} + + +- op: +move var@0 + +[[32mDebug[39m] Value to move: +11: u32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: var@4 := copy x +var@5 := copy y +z := copy var@4 + copy var@5 +var@9 := copy z +var@8 := move var@9 == 15: u32 +var@7 := ¬ move var@8 +assert(¬move var@7) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: var@4 := copy x + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> ⊥ : u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +copy x + +[[32mDebug[39m] Value to copy: +4: u32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> 4: u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: var@5 := copy y +z := copy var@4 + copy var@5 +var@9 := copy z +var@8 := move var@9 == 15: u32 +var@7 := ¬ move var@8 +assert(¬move var@7) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> 4: u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: var@5 := copy y + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> 4: u32 ; + var@5 -> ⊥ : u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +copy y + +[[32mDebug[39m] Value to copy: +11: u32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: z := copy var@4 + copy var@5 +var@9 := copy z +var@8 := move var@9 == 15: u32 +var@7 := ¬ move var@8 +assert(¬move var@7) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: z := copy var@4 + copy var@5 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +copy var@4 + +[[32mDebug[39m] Value to copy: +4: u32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> ⊥ : u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +copy var@5 + +[[32mDebug[39m] Value to copy: +11: u32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: var@9 := copy z +var@8 := move var@9 == 15: u32 +var@7 := ¬ move var@8 +assert(¬move var@7) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: var@9 := copy z + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +copy z + +[[32mDebug[39m] Value to copy: +15: u32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> 15: u32 ; +} + +About to evaluate statement: var@8 := move var@9 == 15: u32 +var@7 := ¬ move var@8 +assert(¬move var@7) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> 15: u32 ; +} + +About to evaluate statement: var@8 := move var@9 == 15: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> 15: u32 ; +} + + +- op: +move var@9 + +[[32mDebug[39m] Value to move: +15: u32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +15: u32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> true ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: var@7 := ¬ move var@8 +assert(¬move var@7) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> true ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: var@7 := ¬ move var@8 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> true ; + var@9 -> ⊥ : u32 ; +} + + +- op: +move var@8 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> false ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: assert(¬move var@7) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> false ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: assert(¬move var@7) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> false ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + + +- op: +move var@7 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 4: u32 ; + y -> 11: u32 ; + z -> 15: u32 ; + var@4 -> 4: u32 ; + var@5 -> 11: u32 ; + var@6 -> ⊥ : (u32, bool) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : u32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: test_neg1 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + y -> ⊥ : i32 ; +} + +About to evaluate statement: x := 3: i32 +y := -3: i32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + y -> ⊥ : i32 ; +} + +About to evaluate statement: x := 3: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + y -> ⊥ : i32 ; +} + + +- op: +3: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 3: i32 ; + y -> ⊥ : i32 ; +} + +About to evaluate statement: y := -3: i32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 3: i32 ; + y -> ⊥ : i32 ; +} + +About to evaluate statement: y := -3: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 3: i32 ; + y -> ⊥ : i32 ; +} + + +- op: +-3: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 3: i32 ; + y -> -3: i32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: refs_test +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + y -> ⊥ : i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: x := 0: i32 +y := 1: i32 +px := &mut x +py := &mut y +ppx := &mut px +var@6 := &mut *(py) +*(ppx) := move var@6 +*(*(ppx)) := 2: i32 +var@9 := copy *(px) +var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + y -> ⊥ : i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: x := 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + y -> ⊥ : i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +0: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⊥ : i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: y := 1: i32 +px := &mut x +py := &mut y +ppx := &mut px +var@6 := &mut *(py) +*(ppx) := move var@6 +*(*(ppx)) := 2: i32 +var@9 := copy *(px) +var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⊥ : i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: y := 1: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⊥ : i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +1: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 1: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: px := &mut x +py := &mut y +ppx := &mut px +var@6 := &mut *(py) +*(ppx) := move var@6 +*(*(ppx)) := 2: i32 +var@9 := copy *(px) +var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 1: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: px := &mut x + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> 1: i32 ; + px -> &mut@0 (0: i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: py := &mut y +ppx := &mut px +var@6 := &mut *(py) +*(ppx) := move var@6 +*(*(ppx)) := 2: i32 +var@9 := copy *(px) +var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> 1: i32 ; + px -> &mut@0 (0: i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: py := &mut y + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@1⌋ ; + px -> &mut@0 (0: i32) ; + py -> &mut@1 (1: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: ppx := &mut px +var@6 := &mut *(py) +*(ppx) := move var@6 +*(*(ppx)) := 2: i32 +var@9 := copy *(px) +var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@1⌋ ; + px -> &mut@0 (0: i32) ; + py -> &mut@1 (1: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: ppx := &mut px + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (1: i32) ; + ppx -> &mut@2 (&mut@0 (0: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@6 := &mut *(py) +*(ppx) := move var@6 +*(*(ppx)) := 2: i32 +var@9 := copy *(px) +var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (1: i32) ; + ppx -> &mut@2 (&mut@0 (0: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@6 := &mut *(py) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@0 (0: i32)) ; + var@6 -> &mut@3 (1: i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: *(ppx) := move var@6 +*(*(ppx)) := 2: i32 +var@9 := copy *(px) +var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@0 (0: i32)) ; + var@6 -> &mut@3 (1: i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: *(ppx) := move var@6 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@0 (0: i32)) ; + var@6 -> &mut@3 (1: i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@6 + +[[32mDebug[39m] Value to move: +&mut@3 (1: i32) +[[32mDebug[39m] drop_borrows_loans_at_lplace: dropping 0 +[[32mDebug[39m] end_borrow 0: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@0 (0: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrow 0: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (⊥ : &'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@3 (1: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: *(*(ppx)) := 2: i32 +var@9 := copy *(px) +var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@3 (1: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: *(*(ppx)) := 2: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@3 (1: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +2: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@3 (2: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@9 := copy *(px) +var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@3 (2: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@9 := copy *(px) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@3 (2: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +copy *(px) + +[[32mDebug[39m] end_borrow 2: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⌊mut@2⌋ ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> &mut@2 (&mut@3 (2: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrow 2: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] Value to copy: +2: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> 2: i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := move var@9 == 2: i32 +var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> 2: i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := move var@9 == 2: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> 2: i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@9 + +[[32mDebug[39m] Value to move: +2: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +2: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> true ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@7 := ¬ move var@8 +assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> true ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@7 := ¬ move var@8 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> true ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@8 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> false ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@7) +var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> false ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@7) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> false ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@7 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@12 := copy x +var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@12 := copy x + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +copy x + +[[32mDebug[39m] Value to copy: +0: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> 0: i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@11 := move var@12 == 0: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> 0: i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@11 := move var@12 == 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> 0: i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@12 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +0: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> true ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> true ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@10 := ¬ move var@11 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> true ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@11 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> false ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@10) +var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> false ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@10) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> false ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@10 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@15 := copy *(py) +var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@15 := copy *(py) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +copy *(py) + +[[32mDebug[39m] end_borrow 3: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> &mut@3 (2: i32) ; + py -> &mut@1 (⌊mut@3⌋) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrow 3: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] Value to copy: +2: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> 2: i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@14 := move var@15 == 2: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> 2: i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@14 := move var@15 == 2: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> 2: i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@15 + +[[32mDebug[39m] Value to move: +2: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +2: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> true ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> true ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@13 := ¬ move var@14 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> true ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@14 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> false ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> false ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@13) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> false ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@13 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@18 := copy y +var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@18 := copy y + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +copy y + +[[32mDebug[39m] end_borrow 1: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⌊mut@1⌋ ; + px -> ⊥ : &'_ mut (i32) ; + py -> &mut@1 (2: i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrow 1: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] Value to copy: +2: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> 2: i32 ; +} + +About to evaluate statement: var@17 := move var@18 == 2: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> 2: i32 ; +} + +About to evaluate statement: var@17 := move var@18 == 2: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> 2: i32 ; +} + + +- op: +move var@18 + +[[32mDebug[39m] Value to move: +2: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +2: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> true ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> true ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@16 := ¬ move var@17 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> true ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@17 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> false ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> false ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@16) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> false ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@16 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 2: i32 ; + px -> ⊥ : &'_ mut (i32) ; + py -> ⊥ : &'_ mut (i32) ; + ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : i32 ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: test_list1 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: set_discriminant(var@3, 1) +var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) +(l as test1::List::Cons).0 := 0: i32 +(l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: set_discriminant(var@3, 1) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> test1::List::Nil ; +} + +About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) +(l as test1::List::Cons).0 := 0: i32 +(l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> test1::List::Nil ; +} + +About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) + +[[32mDebug[39m] eval_non_local_function_call: +- fid:CfimAst.BoxNew +- type_params: [test1::List<i32>] +- args: [move var@3] +- dest: var@2 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> test1::List::Nil ; +} + + +- op: +move var@3 + +[[32mDebug[39m] Value to move: +test1::List::Nil +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +# Frame 1: +{ + @return -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@1 -> test1::List::Nil ; +} + + +- op: +move var@1 + +[[32mDebug[39m] Value to move: +test1::List::Nil +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +# Frame 1: +{ + @return -> @Box(test1::List::Nil) ; + var@1 -> ⊥ : test1::List<i32> ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [1] +[[32mDebug[39m] drop_value: place: var@1 +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +# Frame 1: +{ + @return -> @Box(test1::List::Nil) ; + var@1 -> ⊥ : test1::List<i32> ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +# Frame 1: +{ + @return -> @Box(test1::List::Nil) ; + var@1 -> ⊥ : test1::List<i32> ; +} + + +- op: +move @return + +[[32mDebug[39m] Value to move: +@Box(test1::List::Nil) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: (l as test1::List::Cons).0 := 0: i32 +(l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: (l as test1::List::Cons).0 := 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; +} + + +- op: +0: i32 + +[[32mDebug[39m] expand_bottom_value_from_projection: +pe: (Expressions.Field ((Expressions.ProjAdt (1, (Some 0))), 0)) +ty: (Types.Adt ((Types.AdtId 1), [], [(Types.Integer Types.I32)])) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: (l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: (l as test1::List::Cons).1 := move var@2 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; +} + + +- op: +move var@2 + +[[32mDebug[39m] Value to move: +@Box(test1::List::Nil) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: set_discriminant(l, 0) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: set_discriminant(l, 0) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: drop(l) + +[[32mDebug[39m] drop_value: place: l +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: test_box1 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⊥ : std::boxed::Box<i32> ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: b := move alloc::boxed::Box<i32>::new(0: i32) +var@3 := &two-phase b +x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3) +*(x) := 1: i32 +var@5 := &b +x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5) +var@8 := copy *(x) +var@7 := move var@8 == 1: i32 +var@6 := ¬ move var@7 +assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⊥ : std::boxed::Box<i32> ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: b := move alloc::boxed::Box<i32>::new(0: i32) + +[[32mDebug[39m] eval_non_local_function_call: +- fid:CfimAst.BoxNew +- type_params: [i32] +- args: [0: i32] +- dest: b +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⊥ : std::boxed::Box<i32> ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + + +- op: +0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⊥ : std::boxed::Box<i32> ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> ⊥ : std::boxed::Box<i32> ; + var@1 -> 0: i32 ; +} + + +- op: +move var@1 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⊥ : std::boxed::Box<i32> ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> @Box(0: i32) ; + var@1 -> ⊥ : i32 ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [1] +[[32mDebug[39m] drop_value: place: var@1 +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⊥ : std::boxed::Box<i32> ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> @Box(0: i32) ; + var@1 -> ⊥ : i32 ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⊥ : std::boxed::Box<i32> ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> @Box(0: i32) ; + var@1 -> ⊥ : i32 ; +} + + +- op: +move @return + +[[32mDebug[39m] Value to move: +@Box(0: i32) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(0: i32) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@3 := &two-phase b +x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3) +*(x) := 1: i32 +var@5 := &b +x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5) +var@8 := copy *(x) +var@7 := move var@8 == 1: i32 +var@6 := ¬ move var@7 +assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(0: i32) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@3 := &two-phase b + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({0}, @Box(0: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⌊inactivated_mut@0⌋ ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3) +*(x) := 1: i32 +var@5 := &b +x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5) +var@8 := copy *(x) +var@7 := move var@8 == 1: i32 +var@6 := ¬ move var@7 +assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({0}, @Box(0: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⌊inactivated_mut@0⌋ ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3) + +[[32mDebug[39m] eval_non_local_function_call: +- fid:CfimAst.BoxDerefMut +- type_params: [i32] +- args: [move var@3] +- dest: x +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({0}, @Box(0: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⌊inactivated_mut@0⌋ ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + + +- op: +move var@3 + +[[32mDebug[39m] activate_inactivated_mut_borrow: resulting value: +{ Values.value = + (Values.Adt + { Values.variant_id = <opaque>; + field_values = + [{ Values.value = (Values.Concrete <opaque>); + ty = (Types.Integer Types.I32) } + ] + }); + ty = + (Types.Adt ((Types.Assumed Types.Box), [], [(Types.Integer Types.I32)])) } +[[32mDebug[39m] end_borrows {}: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({0}, @Box(0: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⌊inactivated_mut@0⌋ ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrows {}: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({0}, @Box(0: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⌊inactivated_mut@0⌋ ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +[[32mDebug[39m] Value to move: +&mut@0 (@Box(0: i32)) +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⌊mut@0⌋ ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> &mut@1 (0: i32) ; + var@1 -> &mut@0 (@Box(⌊mut@1⌋)) ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [1] +[[32mDebug[39m] drop_value: place: var@1 +[[32mDebug[39m] drop_borrows_loans_at_lplace: dropping 0 +[[32mDebug[39m] end_borrow 0: context before: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⌊mut@0⌋ ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> &mut@1 (0: i32) ; + var@1 -> &mut@0 (@Box(⌊mut@1⌋)) ; +} + +[[32mDebug[39m] end_borrow 0: context after: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(⌊mut@1⌋) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> &mut@1 (0: i32) ; + var@1 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; +} + +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(⌊mut@1⌋) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> &mut@1 (0: i32) ; + var@1 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(⌊mut@1⌋) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> &mut@1 (0: i32) ; + var@1 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; +} + + +- op: +move @return + +[[32mDebug[39m] Value to move: +&mut@1 (0: i32) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(⌊mut@1⌋) ; + x -> &mut@1 (0: i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: *(x) := 1: i32 +var@5 := &b +x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5) +var@8 := copy *(x) +var@7 := move var@8 == 1: i32 +var@6 := ¬ move var@7 +assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(⌊mut@1⌋) ; + x -> &mut@1 (0: i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: *(x) := 1: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(⌊mut@1⌋) ; + x -> &mut@1 (0: i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + + +- op: +1: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(⌊mut@1⌋) ; + x -> &mut@1 (1: i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@5 := &b +x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5) +var@8 := copy *(x) +var@7 := move var@8 == 1: i32 +var@6 := ¬ move var@7 +assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(⌊mut@1⌋) ; + x -> &mut@1 (1: i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@5 := &b + +[[32mDebug[39m] end_borrow 1: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(⌊mut@1⌋) ; + x -> &mut@1 (1: i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrow 1: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(1: i32) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({2}, @Box(1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⌊shared@2⌋ ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5) +var@8 := copy *(x) +var@7 := move var@8 == 1: i32 +var@6 := ¬ move var@7 +assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({2}, @Box(1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⌊shared@2⌋ ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5) + +[[32mDebug[39m] eval_non_local_function_call: +- fid:CfimAst.BoxDeref +- type_params: [i32] +- args: [move var@5] +- dest: x +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({2}, @Box(1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⌊shared@2⌋ ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + + +- op: +move var@5 + +[[32mDebug[39m] Value to move: +⌊shared@2⌋ +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({2}, @Box(@shared_loan({3}, 1: i32))) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> ⌊shared@3⌋ ; + var@1 -> ⌊shared@2⌋ ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [1] +[[32mDebug[39m] drop_value: place: var@1 +[[32mDebug[39m] drop_borrows_loans_at_lplace: dropping 2 +[[32mDebug[39m] end_borrow 2: context before: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @shared_loan({2}, @Box(@shared_loan({3}, 1: i32))) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> ⌊shared@3⌋ ; + var@1 -> ⌊shared@2⌋ ; +} + +[[32mDebug[39m] end_borrow 2: context after: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> ⌊shared@3⌋ ; + var@1 -> ⊥ : &'_ (std::boxed::Box<i32>) ; +} + +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> ⌊shared@3⌋ ; + var@1 -> ⊥ : &'_ (std::boxed::Box<i32>) ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> ⌊shared@3⌋ ; + var@1 -> ⊥ : &'_ (std::boxed::Box<i32>) ; +} + + +- op: +move @return + +[[32mDebug[39m] Value to move: +⌊shared@3⌋ +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := copy *(x) +var@7 := move var@8 == 1: i32 +var@6 := ¬ move var@7 +assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := copy *(x) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + + +- op: +copy *(x) + +[[32mDebug[39m] Value to copy: +1: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> 1: i32 ; +} + +About to evaluate statement: var@7 := move var@8 == 1: i32 +var@6 := ¬ move var@7 +assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> 1: i32 ; +} + +About to evaluate statement: var@7 := move var@8 == 1: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> 1: i32 ; +} + + +- op: +move var@8 + +[[32mDebug[39m] Value to move: +1: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + + +- op: +1: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> true ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@6 := ¬ move var@7 +assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> true ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@6 := ¬ move var@7 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> true ; + var@8 -> ⊥ : i32 ; +} + + +- op: +move var@7 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> false ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@6) +drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> false ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@6) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> false ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + + +- op: +move var@6 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: drop(b) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: drop(b) + +[[32mDebug[39m] drop_value: place: b +[[32mDebug[39m] end_borrows {3}: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(@shared_loan({3}, 1: i32)) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⌊shared@3⌋ ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrows {3}: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> @Box(1: i32) ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + b -> ⊥ : std::boxed::Box<i32> ; + x -> ⊥ : &'_ mut (i32) ; + var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ; + x -> ⊥ : &'_ (i32) ; + var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: test_copy_int +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + px -> ⊥ : &'_ (i32) ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: x := 0: i32 +px := &x +var@4 := copy x +y := move copy_int(move var@4) +var@7 := copy *(px) +var@8 := copy y +var@6 := move var@7 == move var@8 +var@5 := ¬ move var@6 +assert(¬move var@5) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + px -> ⊥ : &'_ (i32) ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: x := 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + px -> ⊥ : &'_ (i32) ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + + +- op: +0: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + px -> ⊥ : &'_ (i32) ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: px := &x +var@4 := copy x +y := move copy_int(move var@4) +var@7 := copy *(px) +var@8 := copy y +var@6 := move var@7 == move var@8 +var@5 := ¬ move var@6 +assert(¬move var@5) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + px -> ⊥ : &'_ (i32) ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: px := &x + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@4 := copy x +y := move copy_int(move var@4) +var@7 := copy *(px) +var@8 := copy y +var@6 := move var@7 == move var@8 +var@5 := ¬ move var@6 +assert(¬move var@5) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@4 := copy x + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + + +- op: +copy x + +[[32mDebug[39m] Value to copy: +@shared_loan({0}, 0: i32) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> 0: i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: y := move copy_int(move var@4) +var@7 := copy *(px) +var@8 := copy y +var@6 := move var@7 == move var@8 +var@5 := ¬ move var@6 +assert(¬move var@5) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> 0: i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: y := move copy_int(move var@4) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> 0: i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + + +- op: +move var@4 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : i32 ; + x -> 0: i32 ; +} + +About to evaluate statement: var@0 := copy x +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : i32 ; + x -> 0: i32 ; +} + +About to evaluate statement: var@0 := copy x + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : i32 ; + x -> 0: i32 ; +} + + +- op: +copy x + +[[32mDebug[39m] Value to copy: +0: i32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> 0: i32 ; + x -> 0: i32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> 0: i32 ; + x -> 0: i32 ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [1] +[[32mDebug[39m] drop_value: place: x +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> 0: i32 ; + x -> ⊥ : i32 ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> ⊥ : i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> 0: i32 ; + x -> ⊥ : i32 ; +} + + +- op: +move var@0 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@7 := copy *(px) +var@8 := copy y +var@6 := move var@7 == move var@8 +var@5 := ¬ move var@6 +assert(¬move var@5) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@7 := copy *(px) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + + +- op: +copy *(px) + +[[32mDebug[39m] Value to copy: +0: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> 0: i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := copy y +var@6 := move var@7 == move var@8 +var@5 := ¬ move var@6 +assert(¬move var@5) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> 0: i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := copy y + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> 0: i32 ; + var@8 -> ⊥ : i32 ; +} + + +- op: +copy y + +[[32mDebug[39m] Value to copy: +0: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> 0: i32 ; + var@8 -> 0: i32 ; +} + +About to evaluate statement: var@6 := move var@7 == move var@8 +var@5 := ¬ move var@6 +assert(¬move var@5) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> 0: i32 ; + var@8 -> 0: i32 ; +} + +About to evaluate statement: var@6 := move var@7 == move var@8 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> 0: i32 ; + var@8 -> 0: i32 ; +} + + +- op: +move var@7 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> 0: i32 ; +} + + +- op: +move var@8 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> true ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@5 := ¬ move var@6 +assert(¬move var@5) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> true ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: var@5 := ¬ move var@6 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> true ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + + +- op: +move var@6 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> false ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@5) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> false ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@5) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> false ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + + +- op: +move var@5 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> @shared_loan({0}, 0: i32) ; + px -> ⌊shared@0⌋ ; + y -> 0: i32 ; + var@4 -> ⊥ : i32 ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : bool ; + var@7 -> ⊥ : i32 ; + var@8 -> ⊥ : i32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: test_is_cons +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: set_discriminant(var@3, 1) +var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) +(l as test1::List::Cons).0 := 0: i32 +(l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +var@7 := &l +var@6 := copy var@7 +var@5 := move is_cons<i32>(move var@6) +var@4 := ¬ move var@5 +assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: set_discriminant(var@3, 1) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> test1::List::Nil ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) +(l as test1::List::Cons).0 := 0: i32 +(l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +var@7 := &l +var@6 := copy var@7 +var@5 := move is_cons<i32>(move var@6) +var@4 := ¬ move var@5 +assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> test1::List::Nil ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) + +[[32mDebug[39m] eval_non_local_function_call: +- fid:CfimAst.BoxNew +- type_params: [test1::List<i32>] +- args: [move var@3] +- dest: var@2 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> test1::List::Nil ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + + +- op: +move var@3 + +[[32mDebug[39m] Value to move: +test1::List::Nil +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +# Frame 1: +{ + @return -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@1 -> test1::List::Nil ; +} + + +- op: +move var@1 + +[[32mDebug[39m] Value to move: +test1::List::Nil +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +# Frame 1: +{ + @return -> @Box(test1::List::Nil) ; + var@1 -> ⊥ : test1::List<i32> ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [1] +[[32mDebug[39m] drop_value: place: var@1 +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +# Frame 1: +{ + @return -> @Box(test1::List::Nil) ; + var@1 -> ⊥ : test1::List<i32> ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +# Frame 1: +{ + @return -> @Box(test1::List::Nil) ; + var@1 -> ⊥ : test1::List<i32> ; +} + + +- op: +move @return + +[[32mDebug[39m] Value to move: +@Box(test1::List::Nil) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: (l as test1::List::Cons).0 := 0: i32 +(l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +var@7 := &l +var@6 := copy var@7 +var@5 := move is_cons<i32>(move var@6) +var@4 := ¬ move var@5 +assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: (l as test1::List::Cons).0 := 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + + +- op: +0: i32 + +[[32mDebug[39m] expand_bottom_value_from_projection: +pe: (Expressions.Field ((Expressions.ProjAdt (1, (Some 0))), 0)) +ty: (Types.Adt ((Types.AdtId 1), [], [(Types.Integer Types.I32)])) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: (l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +var@7 := &l +var@6 := copy var@7 +var@5 := move is_cons<i32>(move var@6) +var@4 := ¬ move var@5 +assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: (l as test1::List::Cons).1 := move var@2 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + + +- op: +move var@2 + +[[32mDebug[39m] Value to move: +@Box(test1::List::Nil) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: set_discriminant(l, 0) +var@7 := &l +var@6 := copy var@7 +var@5 := move is_cons<i32>(move var@6) +var@4 := ¬ move var@5 +assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: set_discriminant(l, 0) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: var@7 := &l +var@6 := copy var@7 +var@5 := move is_cons<i32>(move var@6) +var@4 := ¬ move var@5 +assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: var@7 := &l + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: var@6 := copy var@7 +var@5 := move is_cons<i32>(move var@6) +var@4 := ¬ move var@5 +assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: var@6 := copy var@7 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + + +- op: +copy var@7 + +[[32mDebug[39m] Value to copy: +⌊shared@0⌋ +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⌊shared@1⌋ ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: var@5 := move is_cons<i32>(move var@6) +var@4 := ¬ move var@5 +assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⌊shared@1⌋ ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: var@5 := move is_cons<i32>(move var@6) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⌊shared@1⌋ ; + var@7 -> ⌊shared@0⌋ ; +} + + +- op: +move var@6 + +[[32mDebug[39m] Value to move: +⌊shared@1⌋ +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> ⊥ : bool ; + l -> ⌊shared@1⌋ ; + var@2 -> ⊥ : isize ; +} + +About to evaluate statement: var@2 := discriminant(*(l)) +switch (move var@2) { + 0: isize => { + var@0 := true + } + 1: isize => { + var@0 := false + } + _ => { + panic + } +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> ⊥ : bool ; + l -> ⌊shared@1⌋ ; + var@2 -> ⊥ : isize ; +} + +About to evaluate statement: var@2 := discriminant(*(l)) + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> ⊥ : bool ; + l -> ⌊shared@1⌋ ; + var@2 -> 0: isize ; +} + +About to evaluate statement: switch (move var@2) { + 0: isize => { + var@0 := true + } + 1: isize => { + var@0 := false + } + _ => { + panic + } +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> ⊥ : bool ; + l -> ⌊shared@1⌋ ; + var@2 -> 0: isize ; +} + +About to evaluate statement: switch (move var@2) { + 0: isize => { + var@0 := true + } + 1: isize => { + var@0 := false + } + _ => { + panic + } +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> ⊥ : bool ; + l -> ⌊shared@1⌋ ; + var@2 -> 0: isize ; +} + + +- op: +move var@2 + +[[32mDebug[39m] Value to move: +0: isize +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> ⊥ : bool ; + l -> ⌊shared@1⌋ ; + var@2 -> ⊥ : isize ; +} + +About to evaluate statement: var@0 := true + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> ⊥ : bool ; + l -> ⌊shared@1⌋ ; + var@2 -> ⊥ : isize ; +} + + +- op: +true + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> true ; + l -> ⌊shared@1⌋ ; + var@2 -> ⊥ : isize ; +} + +About to evaluate statement: return + +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> true ; + l -> ⌊shared@1⌋ ; + var@2 -> ⊥ : isize ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [2,1] +[[32mDebug[39m] drop_value: place: var@2 +[[32mDebug[39m] drop_value: place: l +[[32mDebug[39m] drop_borrows_loans_at_lplace: dropping 1 +[[32mDebug[39m] end_borrow 1: context before: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> true ; + l -> ⌊shared@1⌋ ; + var@2 -> ⊥ : isize ; +} + +[[32mDebug[39m] end_borrow 1: context after: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> true ; + l -> ⊥ : &'_ (test1::List<i32>) ; + var@2 -> ⊥ : isize ; +} + +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> true ; + l -> ⊥ : &'_ (test1::List<i32>) ; + var@2 -> ⊥ : isize ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +# Frame 1: +{ + var@0 -> true ; + l -> ⊥ : &'_ (test1::List<i32>) ; + var@2 -> ⊥ : isize ; +} + + +- op: +move var@0 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> true ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: var@4 := ¬ move var@5 +assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> true ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: var@4 := ¬ move var@5 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> true ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + + +- op: +move var@5 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> false ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: assert(¬move var@4) +drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> false ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: assert(¬move var@4) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> false ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + + +- op: +move var@4 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: drop(l) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +About to evaluate statement: drop(l) + +[[32mDebug[39m] drop_value: place: l +[[32mDebug[39m] end_borrows {0}: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⌊shared@0⌋ ; +} + +[[32mDebug[39m] end_borrows {0}: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + var@4 -> ⊥ : bool ; + var@5 -> ⊥ : bool ; + var@6 -> ⊥ : &'_ (test1::List<i32>) ; + var@7 -> ⊥ : &'_ (test1::List<i32>) ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: test_split_list +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: set_discriminant(var@3, 1) +var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) +(l as test1::List::Cons).0 := 0: i32 +(l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +var@7 := move l +var@6 := move split_list<i32>(move var@7) +hd := copy (var@6).0 +tl := move (var@6).1 +var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: set_discriminant(var@3, 1) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> test1::List::Nil ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) +(l as test1::List::Cons).0 := 0: i32 +(l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +var@7 := move l +var@6 := move split_list<i32>(move var@7) +hd := copy (var@6).0 +tl := move (var@6).1 +var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> test1::List::Nil ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3) + +[[32mDebug[39m] eval_non_local_function_call: +- fid:CfimAst.BoxNew +- type_params: [test1::List<i32>] +- args: [move var@3] +- dest: var@2 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> test1::List::Nil ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +move var@3 + +[[32mDebug[39m] Value to move: +test1::List::Nil +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@1 -> test1::List::Nil ; +} + + +- op: +move var@1 + +[[32mDebug[39m] Value to move: +test1::List::Nil +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> @Box(test1::List::Nil) ; + var@1 -> ⊥ : test1::List<i32> ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [1] +[[32mDebug[39m] drop_value: place: var@1 +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> @Box(test1::List::Nil) ; + var@1 -> ⊥ : test1::List<i32> ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + @return -> @Box(test1::List::Nil) ; + var@1 -> ⊥ : test1::List<i32> ; +} + + +- op: +move @return + +[[32mDebug[39m] Value to move: +@Box(test1::List::Nil) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: (l as test1::List::Cons).0 := 0: i32 +(l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +var@7 := move l +var@6 := move split_list<i32>(move var@7) +hd := copy (var@6).0 +tl := move (var@6).1 +var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: (l as test1::List::Cons).0 := 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +0: i32 + +[[32mDebug[39m] expand_bottom_value_from_projection: +pe: (Expressions.Field ((Expressions.ProjAdt (1, (Some 0))), 0)) +ty: (Types.Adt ((Types.AdtId 1), [], [(Types.Integer Types.I32)])) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: (l as test1::List::Cons).1 := move var@2 +set_discriminant(l, 0) +var@7 := move l +var@6 := move split_list<i32>(move var@7) +hd := copy (var@6).0 +tl := move (var@6).1 +var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: (l as test1::List::Cons).1 := move var@2 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> @Box(test1::List::Nil) ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +move var@2 + +[[32mDebug[39m] Value to move: +@Box(test1::List::Nil) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: set_discriminant(l, 0) +var@7 := move l +var@6 := move split_list<i32>(move var@7) +hd := copy (var@6).0 +tl := move (var@6).1 +var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: set_discriminant(l, 0) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@7 := move l +var@6 := move split_list<i32>(move var@7) +hd := copy (var@6).0 +tl := move (var@6).1 +var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@7 := move l + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +move l + +[[32mDebug[39m] Value to move: +test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@6 := move split_list<i32>(move var@7) +hd := copy (var@6).0 +tl := move (var@6).1 +var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@6 := move split_list<i32>(move var@7) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +move var@7 + +[[32mDebug[39m] Value to move: +test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@8 := false +var@7 := false +var@7 := true +var@8 := true +var@2 := discriminant(l) +switch (move var@2) { + 0: isize => { + var@8 := false + hd := move (l as test1::List::Cons).0 + var@7 := false + tl := move (l as test1::List::Cons).1 + var@5 := move hd + var@6 := move deref_box(tl) + (var@0).0 := move var@5 + (var@0).1 := move var@6 + var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) + return + } + _ => { + panic + } +} + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@8 := false + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +false + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> ⊥ : bool ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@7 := false +var@7 := true +var@8 := true +var@2 := discriminant(l) +switch (move var@2) { + 0: isize => { + var@8 := false + hd := move (l as test1::List::Cons).0 + var@7 := false + tl := move (l as test1::List::Cons).1 + var@5 := move hd + var@6 := move deref_box(tl) + (var@0).0 := move var@5 + (var@0).1 := move var@6 + var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) + return + } + _ => { + panic + } +} + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> ⊥ : bool ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@7 := false + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> ⊥ : bool ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +false + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@7 := true +var@8 := true +var@2 := discriminant(l) +switch (move var@2) { + 0: isize => { + var@8 := false + hd := move (l as test1::List::Cons).0 + var@7 := false + tl := move (l as test1::List::Cons).1 + var@5 := move hd + var@6 := move deref_box(tl) + (var@0).0 := move var@5 + (var@0).1 := move var@6 + var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) + return + } + _ => { + panic + } +} + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@7 := true + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +true + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@8 := true +var@2 := discriminant(l) +switch (move var@2) { + 0: isize => { + var@8 := false + hd := move (l as test1::List::Cons).0 + var@7 := false + tl := move (l as test1::List::Cons).1 + var@5 := move hd + var@6 := move deref_box(tl) + (var@0).0 := move var@5 + (var@0).1 := move var@6 + var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) + return + } + _ => { + panic + } +} + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@8 := true + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +true + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> true ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@2 := discriminant(l) +switch (move var@2) { + 0: isize => { + var@8 := false + hd := move (l as test1::List::Cons).0 + var@7 := false + tl := move (l as test1::List::Cons).1 + var@5 := move hd + var@6 := move deref_box(tl) + (var@0).0 := move var@5 + (var@0).1 := move var@6 + var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) + return + } + _ => { + panic + } +} + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> true ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@2 := discriminant(l) + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> 0: isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> true ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: switch (move var@2) { + 0: isize => { + var@8 := false + hd := move (l as test1::List::Cons).0 + var@7 := false + tl := move (l as test1::List::Cons).1 + var@5 := move hd + var@6 := move deref_box(tl) + (var@0).0 := move var@5 + (var@0).1 := move var@6 + var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) + return + } + _ => { + panic + } +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> 0: isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> true ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +move var@2 + +[[32mDebug[39m] Value to move: +0: isize +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> true ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@8 := false +hd := move (l as test1::List::Cons).0 +var@7 := false +tl := move (l as test1::List::Cons).1 +var@5 := move hd +var@6 := move deref_box(tl) +(var@0).0 := move var@5 +(var@0).1 := move var@6 +var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> true ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@8 := false + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> true ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +false + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: hd := move (l as test1::List::Cons).0 +var@7 := false +tl := move (l as test1::List::Cons).1 +var@5 := move hd +var@6 := move deref_box(tl) +(var@0).0 := move var@5 +(var@0).1 := move var@6 +var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: hd := move (l as test1::List::Cons).0 + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +move (l as test1::List::Cons).0 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> 0: i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@7 := false +tl := move (l as test1::List::Cons).1 +var@5 := move hd +var@6 := move deref_box(tl) +(var@0).0 := move var@5 +(var@0).1 := move var@6 +var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> 0: i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@7 := false + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> 0: i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> true ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +false + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> 0: i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: tl := move (l as test1::List::Cons).1 +var@5 := move hd +var@6 := move deref_box(tl) +(var@0).0 := move var@5 +(var@0).1 := move var@6 +var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> 0: i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: tl := move (l as test1::List::Cons).1 + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ; + var@2 -> ⊥ : isize ; + hd -> 0: i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +move (l as test1::List::Cons).1 + +[[32mDebug[39m] Value to move: +@Box(test1::List::Nil) +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> 0: i32 ; + tl -> @Box(test1::List::Nil) ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@5 := move hd +var@6 := move deref_box(tl) +(var@0).0 := move var@5 +(var@0).1 := move var@6 +var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> 0: i32 ; + tl -> @Box(test1::List::Nil) ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@5 := move hd + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> 0: i32 ; + tl -> @Box(test1::List::Nil) ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +move hd + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(test1::List::Nil) ; + var@5 -> 0: i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@6 := move deref_box(tl) +(var@0).0 := move var@5 +(var@0).1 := move var@6 +var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(test1::List::Nil) ; + var@5 -> 0: i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@6 := move deref_box(tl) + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(test1::List::Nil) ; + var@5 -> 0: i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +move deref_box(tl) + +[[32mDebug[39m] Value to move: +test1::List::Nil +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(⊥ : test1::List<i32>) ; + var@5 -> 0: i32 ; + var@6 -> test1::List::Nil ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: (var@0).0 := move var@5 +(var@0).1 := move var@6 +var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(⊥ : test1::List<i32>) ; + var@5 -> 0: i32 ; + var@6 -> test1::List::Nil ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: (var@0).0 := move var@5 + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : (i32, test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(⊥ : test1::List<i32>) ; + var@5 -> 0: i32 ; + var@6 -> test1::List::Nil ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +move var@5 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] expand_bottom_value_from_projection: +pe: (Expressions.Field ((Expressions.ProjTuple 2), 0)) +ty: (Types.Adt (Types.Tuple, [], + [(Types.Integer Types.I32); + (Types.Adt ((Types.AdtId 1), [], [(Types.Integer Types.I32)]))] + )) +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> (0: i32, ⊥ : test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(⊥ : test1::List<i32>) ; + var@5 -> ⊥ : i32 ; + var@6 -> test1::List::Nil ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: (var@0).1 := move var@6 +var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> (0: i32, ⊥ : test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(⊥ : test1::List<i32>) ; + var@5 -> ⊥ : i32 ; + var@6 -> test1::List::Nil ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: (var@0).1 := move var@6 + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> (0: i32, ⊥ : test1::List<i32>) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(⊥ : test1::List<i32>) ; + var@5 -> ⊥ : i32 ; + var@6 -> test1::List::Nil ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +move var@6 + +[[32mDebug[39m] Value to move: +test1::List::Nil +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> (0: i32, test1::List::Nil) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(⊥ : test1::List<i32>) ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> (0: i32, test1::List::Nil) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> @Box(⊥ : test1::List<i32>) ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl) + +[[32mDebug[39m] eval_non_local_function_call: +- fid:CfimAst.BoxFree +- type_params: [test1::List<i32>] +- args: [move tl] +- dest: var@9 +[[32mDebug[39m] drop_value: place: tl +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> (0: i32, test1::List::Nil) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> () ; + var@10 -> ⊥ : isize ; +} + +About to evaluate statement: return + +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> (0: i32, test1::List::Nil) ; + l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> false ; + var@8 -> false ; + var@9 -> () ; + var@10 -> ⊥ : isize ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [10,9,8,7,6,5,4,3,2,1] +[[32mDebug[39m] drop_value: place: var@10 +[[32mDebug[39m] drop_value: place: var@9 +[[32mDebug[39m] drop_value: place: var@8 +[[32mDebug[39m] drop_value: place: var@7 +[[32mDebug[39m] drop_value: place: var@6 +[[32mDebug[39m] drop_value: place: var@5 +[[32mDebug[39m] drop_value: place: tl +[[32mDebug[39m] drop_value: place: hd +[[32mDebug[39m] drop_value: place: var@2 +[[32mDebug[39m] drop_value: place: l +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> (0: i32, test1::List::Nil) ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> ⊥ : (i32, test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> (0: i32, test1::List::Nil) ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : isize ; + hd -> ⊥ : i32 ; + tl -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@5 -> ⊥ : i32 ; + var@6 -> ⊥ : test1::List<i32> ; + var@7 -> ⊥ : bool ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : () ; + var@10 -> ⊥ : isize ; +} + + +- op: +move var@0 + +[[32mDebug[39m] Value to move: +(0: i32, test1::List::Nil) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> (0: i32, test1::List::Nil) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: hd := copy (var@6).0 +tl := move (var@6).1 +var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> (0: i32, test1::List::Nil) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: hd := copy (var@6).0 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> ⊥ : i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> (0: i32, test1::List::Nil) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +copy (var@6).0 + +[[32mDebug[39m] Value to copy: +0: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> (0: i32, test1::List::Nil) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: tl := move (var@6).1 +var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> (0: i32, test1::List::Nil) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: tl := move (var@6).1 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> (0: i32, test1::List::Nil) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +move (var@6).1 + +[[32mDebug[39m] Value to move: +test1::List::Nil +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@10 := copy hd +var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@10 := copy hd + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +copy hd + +[[32mDebug[39m] Value to copy: +0: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> 0: i32 ; +} + +About to evaluate statement: var@9 := move var@10 == 0: i32 +var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> 0: i32 ; +} + +About to evaluate statement: var@9 := move var@10 == 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> 0: i32 ; +} + + +- op: +move var@10 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +0: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> true ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := ¬ move var@9 +assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> true ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := ¬ move var@9 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> true ; + var@10 -> ⊥ : i32 ; +} + + +- op: +move var@9 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> false ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@8) +drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> false ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@8) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> false ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + + +- op: +move var@8 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: drop(tl) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> test1::List::Nil ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: drop(tl) + +[[32mDebug[39m] drop_value: place: tl +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + l -> ⊥ : test1::List<i32> ; + var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ; + var@3 -> ⊥ : test1::List<i32> ; + hd -> 0: i32 ; + tl -> ⊥ : test1::List<i32> ; + var@6 -> (0: i32, ⊥ : test1::List<i32>) ; + var@7 -> ⊥ : test1::List<i32> ; + var@8 -> ⊥ : bool ; + var@9 -> ⊥ : bool ; + var@10 -> ⊥ : i32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: get_elem_test +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + y -> ⊥ : i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: x := 0: i32 +y := 0: i32 +var@5 := &mut x +var@4 := &two-phase *(var@5) +var@7 := &mut y +var@6 := &two-phase *(var@7) +z := move get_elem<i32>(true, move var@4, move var@6) +var@8 := copy *(z) +*(z) := copy var@8 + 1: i32 +var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + y -> ⊥ : i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: x := 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : i32 ; + y -> ⊥ : i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +0: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⊥ : i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: y := 0: i32 +var@5 := &mut x +var@4 := &two-phase *(var@5) +var@7 := &mut y +var@6 := &two-phase *(var@7) +z := move get_elem<i32>(true, move var@4, move var@6) +var@8 := copy *(z) +*(z) := copy var@8 + 1: i32 +var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⊥ : i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: y := 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> ⊥ : i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +0: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@5 := &mut x +var@4 := &two-phase *(var@5) +var@7 := &mut y +var@6 := &two-phase *(var@7) +z := move get_elem<i32>(true, move var@4, move var@6) +var@8 := copy *(z) +*(z) := copy var@8 + 1: i32 +var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@5 := &mut x + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (0: i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@4 := &two-phase *(var@5) +var@7 := &mut y +var@6 := &two-phase *(var@7) +z := move get_elem<i32>(true, move var@4, move var@6) +var@8 := copy *(z) +*(z) := copy var@8 + 1: i32 +var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (0: i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@4 := &two-phase *(var@5) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@7 := &mut y +var@6 := &two-phase *(var@7) +z := move get_elem<i32>(true, move var@4, move var@6) +var@8 := copy *(z) +*(z) := copy var@8 + 1: i32 +var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@7 := &mut y + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@6 := &two-phase *(var@7) +z := move get_elem<i32>(true, move var@4, move var@6) +var@8 := copy *(z) +*(z) := copy var@8 + 1: i32 +var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@6 := &two-phase *(var@7) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⌊inactivated_mut@3⌋ ; + var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: z := move get_elem<i32>(true, move var@4, move var@6) +var@8 := copy *(z) +*(z) := copy var@8 + 1: i32 +var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⌊inactivated_mut@3⌋ ; + var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: z := move get_elem<i32>(true, move var@4, move var@6) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⌊inactivated_mut@3⌋ ; + var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +true + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⌊inactivated_mut@3⌋ ; + var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@4 + +[[32mDebug[39m] activate_inactivated_mut_borrow: resulting value: +{ Values.value = (Values.Concrete <opaque>); ty = (Types.Integer Types.I32) } +[[32mDebug[39m] end_borrows {}: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⌊inactivated_mut@3⌋ ; + var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrows {}: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⌊inactivated_mut@1⌋ ; + var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ; + var@6 -> ⌊inactivated_mut@3⌋ ; + var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] Value to move: +&mut@1 (0: i32) +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⌊inactivated_mut@3⌋ ; + var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@6 + +[[32mDebug[39m] activate_inactivated_mut_borrow: resulting value: +{ Values.value = (Values.Concrete <opaque>); ty = (Types.Integer Types.I32) } +[[32mDebug[39m] end_borrows {}: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⌊inactivated_mut@3⌋ ; + var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrows {}: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⌊inactivated_mut@3⌋ ; + var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] Value to move: +&mut@3 (0: i32) +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut (i32) ; + b -> true ; + x -> &mut@1 (0: i32) ; + y -> &mut@3 (0: i32) ; + var@4 -> ⊥ : bool ; +} + +About to evaluate statement: var@4 := copy b +if (move var@4) { + var@0 := &mut *(x) +} +else { + var@0 := move y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut (i32) ; + b -> true ; + x -> &mut@1 (0: i32) ; + y -> &mut@3 (0: i32) ; + var@4 -> ⊥ : bool ; +} + +About to evaluate statement: var@4 := copy b + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut (i32) ; + b -> true ; + x -> &mut@1 (0: i32) ; + y -> &mut@3 (0: i32) ; + var@4 -> ⊥ : bool ; +} + + +- op: +copy b + +[[32mDebug[39m] Value to copy: +true +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut (i32) ; + b -> true ; + x -> &mut@1 (0: i32) ; + y -> &mut@3 (0: i32) ; + var@4 -> true ; +} + +About to evaluate statement: if (move var@4) { + var@0 := &mut *(x) +} +else { + var@0 := move y +} +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut (i32) ; + b -> true ; + x -> &mut@1 (0: i32) ; + y -> &mut@3 (0: i32) ; + var@4 -> true ; +} + +About to evaluate statement: if (move var@4) { + var@0 := &mut *(x) +} +else { + var@0 := move y +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut (i32) ; + b -> true ; + x -> &mut@1 (0: i32) ; + y -> &mut@3 (0: i32) ; + var@4 -> true ; +} + + +- op: +move var@4 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut (i32) ; + b -> true ; + x -> &mut@1 (0: i32) ; + y -> &mut@3 (0: i32) ; + var@4 -> ⊥ : bool ; +} + +About to evaluate statement: var@0 := &mut *(x) + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> &mut@4 (0: i32) ; + b -> true ; + x -> &mut@1 (⌊mut@4⌋) ; + y -> &mut@3 (0: i32) ; + var@4 -> ⊥ : bool ; +} + +About to evaluate statement: return + +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> &mut@4 (0: i32) ; + b -> true ; + x -> &mut@1 (⌊mut@4⌋) ; + y -> &mut@3 (0: i32) ; + var@4 -> ⊥ : bool ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [4,3,2,1] +[[32mDebug[39m] drop_value: place: var@4 +[[32mDebug[39m] drop_value: place: y +[[32mDebug[39m] drop_borrows_loans_at_lplace: dropping 3 +[[32mDebug[39m] end_borrow 3: context before: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (⌊mut@3⌋) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> &mut@4 (0: i32) ; + b -> true ; + x -> &mut@1 (⌊mut@4⌋) ; + y -> &mut@3 (0: i32) ; + var@4 -> ⊥ : bool ; +} + +[[32mDebug[39m] end_borrow 3: context after: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> &mut@4 (0: i32) ; + b -> true ; + x -> &mut@1 (⌊mut@4⌋) ; + y -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : bool ; +} + +[[32mDebug[39m] drop_value: place: x +[[32mDebug[39m] drop_borrows_loans_at_lplace: dropping 1 +[[32mDebug[39m] end_borrow 1: context before: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@1⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> &mut@4 (0: i32) ; + b -> true ; + x -> &mut@1 (⌊mut@4⌋) ; + y -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : bool ; +} + +[[32mDebug[39m] end_borrow 1: context after: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> &mut@4 (0: i32) ; + b -> true ; + x -> ⊥ : &'_ mut (i32) ; + y -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : bool ; +} + +[[32mDebug[39m] drop_value: place: b +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> &mut@4 (0: i32) ; + b -> ⊥ : bool ; + x -> ⊥ : &'_ mut (i32) ; + y -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : bool ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +# Frame 1: +{ + var@0 -> &mut@4 (0: i32) ; + b -> ⊥ : bool ; + x -> ⊥ : &'_ mut (i32) ; + y -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : bool ; +} + + +- op: +move var@0 + +[[32mDebug[39m] Value to move: +&mut@4 (0: i32) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (0: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := copy *(z) +*(z) := copy var@8 + 1: i32 +var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (0: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@8 := copy *(z) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (0: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> ⊥ : i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +copy *(z) + +[[32mDebug[39m] Value to copy: +0: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (0: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: *(z) := copy var@8 + 1: i32 +var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (0: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: *(z) := copy var@8 + 1: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (0: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +copy var@8 + +[[32mDebug[39m] Value to copy: +0: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (0: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +1: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@12 := copy *(z) +var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@12 := copy *(z) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +copy *(z) + +[[32mDebug[39m] Value to copy: +1: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> 1: i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@11 := move var@12 == 1: i32 +var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> 1: i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@11 := move var@12 == 1: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> 1: i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@12 + +[[32mDebug[39m] Value to move: +1: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +1: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> true ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@10 := ¬ move var@11 +assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> true ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@10 := ¬ move var@11 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> true ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@11 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> false ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@10) +var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> false ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@10) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> false ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@10 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@15 := copy x +var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@15 := copy x + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +copy x + +[[32mDebug[39m] end_borrow 0: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> &mut@0 (⌊mut@4⌋) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrow 0: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@4⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrow 4: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@4⌋ ; + y -> ⌊mut@2⌋ ; + z -> &mut@4 (1: i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrow 4: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] Value to copy: +1: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> 1: i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@14 := move var@15 == 1: i32 +var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> 1: i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@14 := move var@15 == 1: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> 1: i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@15 + +[[32mDebug[39m] Value to move: +1: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +1: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> true ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@13 := ¬ move var@14 +assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> true ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@13 := ¬ move var@14 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> true ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@14 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> false ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@13) +var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> false ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@13) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> false ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@13 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@18 := copy y +var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@18 := copy y + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +copy y + +[[32mDebug[39m] end_borrow 2: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> ⌊mut@2⌋ ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> &mut@2 (0: i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] end_borrow 2: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +[[32mDebug[39m] Value to copy: +0: i32 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> 0: i32 ; +} + +About to evaluate statement: var@17 := move var@18 == 0: i32 +var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> 0: i32 ; +} + +About to evaluate statement: var@17 := move var@18 == 0: i32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> 0: i32 ; +} + + +- op: +move var@18 + +[[32mDebug[39m] Value to move: +0: i32 +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +0: i32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> true ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@16 := ¬ move var@17 +assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> true ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: var@16 := ¬ move var@17 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> true ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@17 + +[[32mDebug[39m] Value to move: +true +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> false ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@16) +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> false ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: assert(¬move var@16) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> false ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + + +- op: +move var@16 + +[[32mDebug[39m] Value to move: +false +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 1: i32 ; + y -> 0: i32 ; + z -> ⊥ : &'_ mut (i32) ; + var@4 -> ⊥ : &'_ mut (i32) ; + var@5 -> ⊥ : &'_ mut (i32) ; + var@6 -> ⊥ : &'_ mut (i32) ; + var@7 -> ⊥ : &'_ mut (i32) ; + var@8 -> 0: i32 ; + var@9 -> ⊥ : (i32, bool) ; + var@10 -> ⊥ : bool ; + var@11 -> ⊥ : bool ; + var@12 -> ⊥ : i32 ; + var@13 -> ⊥ : bool ; + var@14 -> ⊥ : bool ; + var@15 -> ⊥ : i32 ; + var@16 -> ⊥ : bool ; + var@17 -> ⊥ : bool ; + var@18 -> ⊥ : i32 ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: id_mut_pair_test1 +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: x := 0: u32 +px := &mut x +var@4 := move px +(p).0 := move var@4 +(p).1 := 1: u32 +pp0 := &mut p +var@7 := &two-phase *(pp0) +pp1 := move id_mut_pair<u32>(move var@7) +y := 2: u32 +var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: x := 0: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⊥ : u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + + +- op: +0: u32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: px := &mut x +var@4 := move px +(p).0 := move var@4 +(p).1 := 1: u32 +pp0 := &mut p +var@7 := &two-phase *(pp0) +pp1 := move id_mut_pair<u32>(move var@7) +y := 2: u32 +var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: px := &mut x + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> &mut@0 (0: u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: var@4 := move px +(p).0 := move var@4 +(p).1 := 1: u32 +pp0 := &mut p +var@7 := &two-phase *(pp0) +pp1 := move id_mut_pair<u32>(move var@7) +y := 2: u32 +var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> &mut@0 (0: u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: var@4 := move px + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> &mut@0 (0: u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + + +- op: +move px + +[[32mDebug[39m] Value to move: +&mut@0 (0: u32) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> &mut@0 (0: u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: (p).0 := move var@4 +(p).1 := 1: u32 +pp0 := &mut p +var@7 := &two-phase *(pp0) +pp1 := move id_mut_pair<u32>(move var@7) +y := 2: u32 +var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> &mut@0 (0: u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: (p).0 := move var@4 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⊥ : (&'_ mut (u32), u32) ; + var@4 -> &mut@0 (0: u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + + +- op: +move var@4 + +[[32mDebug[39m] Value to move: +&mut@0 (0: u32) +[[32mDebug[39m] expand_bottom_value_from_projection: +pe: (Expressions.Field ((Expressions.ProjTuple 2), 0)) +ty: (Types.Adt (Types.Tuple, [], + [(Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut)); + (Types.Integer Types.U32)] + )) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> (&mut@0 (0: u32), ⊥ : u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: (p).1 := 1: u32 +pp0 := &mut p +var@7 := &two-phase *(pp0) +pp1 := move id_mut_pair<u32>(move var@7) +y := 2: u32 +var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> (&mut@0 (0: u32), ⊥ : u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: (p).1 := 1: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> (&mut@0 (0: u32), ⊥ : u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + + +- op: +1: u32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> (&mut@0 (0: u32), 1: u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: pp0 := &mut p +var@7 := &two-phase *(pp0) +pp1 := move id_mut_pair<u32>(move var@7) +y := 2: u32 +var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> (&mut@0 (0: u32), 1: u32) ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: pp0 := &mut p + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 ((&mut@0 (0: u32), 1: u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: var@7 := &two-phase *(pp0) +pp1 := move id_mut_pair<u32>(move var@7) +y := 2: u32 +var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 ((&mut@0 (0: u32), 1: u32)) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: var@7 := &two-phase *(pp0) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⌊inactivated_mut@2⌋ ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: pp1 := move id_mut_pair<u32>(move var@7) +y := 2: u32 +var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⌊inactivated_mut@2⌋ ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: pp1 := move id_mut_pair<u32>(move var@7) + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⌊inactivated_mut@2⌋ ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + + +- op: +move var@7 + +[[32mDebug[39m] activate_inactivated_mut_borrow: resulting value: +{ Values.value = + (Values.Adt + { Values.variant_id = <opaque>; + field_values = + [{ Values.value = + (Values.Borrow + (Values.MutBorrow (<opaque>, + { Values.value = (Values.Concrete <opaque>); + ty = (Types.Integer Types.U32) } + ))); + ty = + (Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut)) }; + { Values.value = (Values.Concrete <opaque>); + ty = (Types.Integer Types.U32) } + ] + }); + ty = + (Types.Adt (Types.Tuple, [], + [(Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut)); + (Types.Integer Types.U32)] + )) + } +[[32mDebug[39m] end_borrows {}: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⌊inactivated_mut@2⌋ ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +[[32mDebug[39m] end_borrows {}: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⌊inactivated_mut@2⌋ ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +[[32mDebug[39m] Value to move: +&mut@2 ((&mut@0 (0: u32), 1: u32)) +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@2⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + x -> &mut@2 ((&mut@0 (0: u32), 1: u32)) ; + var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; +} + +About to evaluate statement: var@2 := &mut *(x) +var@0 := &mut *(var@2) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@2⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + x -> &mut@2 ((&mut@0 (0: u32), 1: u32)) ; + var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; +} + +About to evaluate statement: var@2 := &mut *(x) + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@2⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + x -> &mut@2 (⌊mut@3⌋) ; + var@2 -> &mut@3 ((&mut@0 (0: u32), 1: u32)) ; +} + +About to evaluate statement: var@0 := &mut *(var@2) +return + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@2⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + x -> &mut@2 (⌊mut@3⌋) ; + var@2 -> &mut@3 ((&mut@0 (0: u32), 1: u32)) ; +} + +About to evaluate statement: var@0 := &mut *(var@2) + +[[32mDebug[39m] +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@2⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + x -> &mut@2 (⌊mut@3⌋) ; + var@2 -> &mut@3 (⌊mut@4⌋) ; +} + +About to evaluate statement: return + +[[32mDebug[39m] ctx_pop_frame: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@2⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + x -> &mut@2 (⌊mut@3⌋) ; + var@2 -> &mut@3 (⌊mut@4⌋) ; +} + +[[32mDebug[39m] ctx_pop_frame: locals to drop: [2,1] +[[32mDebug[39m] drop_value: place: var@2 +[[32mDebug[39m] drop_borrows_loans_at_lplace: dropping 3 +[[32mDebug[39m] end_borrow 3: context before: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@2⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + x -> &mut@2 (⌊mut@3⌋) ; + var@2 -> &mut@3 (⌊mut@4⌋) ; +} + +[[32mDebug[39m] end_borrow 3: context after: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@2⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + x -> &mut@2 (⌊mut@4⌋) ; + var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; +} + +[[32mDebug[39m] drop_value: place: x +[[32mDebug[39m] drop_borrows_loans_at_lplace: dropping 2 +[[32mDebug[39m] end_borrow 2: context before: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@2⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + x -> &mut@2 (⌊mut@4⌋) ; + var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; +} + +[[32mDebug[39m] end_borrow 2: context after: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + x -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; +} + +[[32mDebug[39m] ctx_pop_frame: after dropping local variables: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + x -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; +} + +[[32mDebug[39m] eval_operand: +- ctx: +# 2 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +# Frame 1: +{ + var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + x -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; +} + + +- op: +move var@0 + +[[32mDebug[39m] Value to move: +&mut@4 ((&mut@0 (0: u32), 1: u32)) +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: y := 2: u32 +var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: y := 2: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⊥ : u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + + +- op: +2: u32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> 2: u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: var@10 := &mut y +var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> 2: u32 ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> ⊥ : &'_ mut (u32) ; +} + +About to evaluate statement: var@10 := &mut y + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> &mut@5 (2: u32) ; +} + +About to evaluate statement: var@9 := &mut *(var@10) +*((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> &mut@5 (2: u32) ; +} + +About to evaluate statement: var@9 := &mut *(var@10) + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> &mut@6 (2: u32) ; + var@10 -> &mut@5 (⌊mut@6⌋) ; +} + +About to evaluate statement: *((pp1).0) := move var@9 +*((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> &mut@6 (2: u32) ; + var@10 -> &mut@5 (⌊mut@6⌋) ; +} + +About to evaluate statement: *((pp1).0) := move var@9 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> &mut@6 (2: u32) ; + var@10 -> &mut@5 (⌊mut@6⌋) ; +} + + +- op: +move var@9 + +[[32mDebug[39m] Value to move: +&mut@6 (2: u32) +[[32mDebug[39m] drop_borrows_loans_at_lplace: dropping 0 +[[32mDebug[39m] end_borrow 0: context before: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> ⌊mut@0⌋ ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> &mut@5 (⌊mut@6⌋) ; +} + +[[32mDebug[39m] end_borrow 0: context after: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((⊥ : &'_ mut (u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> &mut@5 (⌊mut@6⌋) ; +} + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@6 (2: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> &mut@5 (⌊mut@6⌋) ; +} + +About to evaluate statement: *((pp1).1) := 3: u32 +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@6 (2: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> &mut@5 (⌊mut@6⌋) ; +} + +About to evaluate statement: *((pp1).1) := 3: u32 + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@6 (2: u32), 1: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> &mut@5 (⌊mut@6⌋) ; +} + + +- op: +3: u32 + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : () ; + x -> 0: u32 ; + px -> ⊥ : &'_ mut (u32) ; + p -> ⌊mut@1⌋ ; + var@4 -> ⊥ : &'_ mut (u32) ; + pp0 -> &mut@1 (⌊mut@4⌋) ; + pp1 -> &mut@4 ((&mut@6 (2: u32), 3: u32)) ; + var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ; + y -> ⌊mut@5⌋ ; + var@9 -> ⊥ : &'_ mut (u32) ; + var@10 -> &mut@5 (⌊mut@6⌋) ; +} + +About to evaluate statement: return + +[[32mDebug[39m] test_unit_function: test_char +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : char ; +} + +About to evaluate statement: var@0 := a +return + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : char ; +} + +About to evaluate statement: var@0 := a + +[[32mDebug[39m] eval_operand: +- ctx: +# 1 frame(s) + +# Frame 0: +{ + var@0 -> ⊥ : char ; +} + + +- op: +a + +[[32mDebug[39m] +# 1 frame(s) + +# Frame 0: +{ + var@0 -> a ; +} + +About to evaluate statement: return + |