insert reset/reuse for Cond

compiler/gen/src/llvm/build.rs

@@ -174,7 +174,7 @@ pub fn build_expr<'a, 'ctx, 'env>(
         Bool(b) => env.context.bool_type().const_int(*b as u64, false).into(),
         Byte(b) => env.context.i8_type().const_int(*b as u64, false).into(),
         Cond {
-            branch_symbol,
+            branching_symbol,
             pass: (pass_stores, pass_expr),
             fail: (fail_stores, fail_expr),
             ret_layout,
@@ -186,7 +186,7 @@ pub fn build_expr<'a, 'ctx, 'env>(
             let ret_type =
                 basic_type_from_layout(env.arena, env.context, &ret_layout, env.ptr_bytes);
 
-            let cond_expr = load_symbol(env, scope, branch_symbol);
+            let cond_expr = load_symbol(env, scope, branching_symbol);
 
             match cond_expr {
                 IntValue(value) => {

compiler/mono/src/decision_tree.rs

@@ -1125,10 +1125,10 @@ fn decide_to_branching<'a>(
 
             let condition = boolean_all(env.arena, tests);
 
-            let branch_symbol = env.unique_symbol();
-            let stores = [(branch_symbol, Layout::Builtin(Builtin::Int1), condition)];
+            let branching_symbol = env.unique_symbol();
+            let stores = [(branching_symbol, Layout::Builtin(Builtin::Int1), condition)];
 
-            let cond_layout = Layout::Builtin(Builtin::Int1);
+            let branching_layout = Layout::Builtin(Builtin::Int1);
 
             (
                 env.arena.alloc(stores),
@@ -1136,8 +1136,9 @@ fn decide_to_branching<'a>(
                     &[],
                     env.arena.alloc(Expr::Cond {
                         cond_symbol,
-                        branch_symbol,
                         cond_layout,
+                        branching_symbol,
+                        branching_layout,
                         pass,
                         fail,
                         ret_layout,

compiler/mono/src/expr.rs

@@ -312,11 +312,12 @@ pub enum Expr<'a> {
         // symbol storing the original expression that we branch on, e.g. `Ok 42`
         // required for RC logic
         cond_symbol: Symbol,
+        cond_layout: Layout<'a>,
 
         // symbol storing the value that we branch on, e.g. `1` representing the `Ok` tag
-        branch_symbol: Symbol,
+        branching_symbol: Symbol,
+        branching_layout: Layout<'a>,
 
-        cond_layout: Layout<'a>,
         // What to do if the condition either passes or fails
         pass: (Stores<'a>, &'a Expr<'a>),
         fail: (Stores<'a>, &'a Expr<'a>),
@@ -408,8 +409,9 @@ fn function_r<'a>(env: &mut Env<'a, '_>, body: &'a Expr<'a>) -> Expr<'a> {
         }
         Cond {
             cond_symbol,
-            branch_symbol,
             cond_layout,
+            branching_symbol,
+            branching_layout,
             pass,
             fail,
             ret_layout,
@@ -432,8 +434,9 @@ fn function_r<'a>(env: &mut Env<'a, '_>, body: &'a Expr<'a>) -> Expr<'a> {
 
             Cond {
                 cond_symbol: *cond_symbol,
-                branch_symbol: *branch_symbol,
                 cond_layout: cond_layout.clone(),
+                branching_symbol: *branching_symbol,
+                branching_layout: branching_layout.clone(),
                 ret_layout: ret_layout.clone(),
                 pass: new_pass,
                 fail: new_fail,
@@ -577,8 +580,9 @@ fn function_s<'a>(
 
         Cond {
             cond_symbol,
-            branch_symbol,
             cond_layout,
+            branching_symbol,
+            branching_layout,
             pass,
             fail,
             ret_layout,
@@ -608,8 +612,9 @@ fn function_s<'a>(
 
             let result = env.arena.alloc(Cond {
                 cond_symbol: *cond_symbol,
-                branch_symbol: *branch_symbol,
                 cond_layout: cond_layout.clone(),
+                branching_symbol: *branching_symbol,
+                branching_layout: branching_layout.clone(),
                 ret_layout: ret_layout.clone(),
                 pass: new_pass,
                 fail: new_fail,
@@ -676,13 +681,13 @@ fn symbols_in_expr<'a>(initial: &Expr<'a>) -> MutSet<Symbol> {
 
             Cond {
                 cond_symbol,
-                branch_symbol,
+                branching_symbol,
                 pass,
                 fail,
                 ..
             } => {
                 result.insert(*cond_symbol);
-                result.insert(*branch_symbol);
+                result.insert(*branching_symbol);
 
                 for (symbol, _, expr) in pass.0.iter() {
                     result.insert(*symbol);
@@ -1189,19 +1194,20 @@ fn from_can<'a>(
                 let cond = from_can(env, loc_cond.value, procs, layout_cache);
                 let then = from_can(env, loc_then.value, procs, layout_cache);
 
-                let branch_symbol = env.unique_symbol();
+                let branching_symbol = env.unique_symbol();
 
                 let cond_expr = Expr::Cond {
-                    cond_symbol: branch_symbol,
-                    branch_symbol,
+                    cond_symbol: branching_symbol,
+                    branching_symbol,
                     cond_layout: cond_layout.clone(),
+                    branching_layout: cond_layout.clone(),
                     pass: (&[], env.arena.alloc(then)),
                     fail: (&[], env.arena.alloc(expr)),
                     ret_layout: ret_layout.clone(),
                 };
 
                 expr = Expr::Store(
-                    bumpalo::vec![in arena; (branch_symbol, Layout::Builtin(Builtin::Int1), cond)]
+                    bumpalo::vec![in arena; (branching_symbol, Layout::Builtin(Builtin::Int1), cond)]
                         .into_bump_slice(),
                     env.arena.alloc(cond_expr),
                 );

compiler/mono/tests/test_mono.rs

@@ -219,8 +219,9 @@ mod test_mono {
                     )],
                     &Cond {
                         cond_symbol: gen_symbol_0,
-                        branch_symbol: gen_symbol_0,
+                        branching_symbol: gen_symbol_0,
                         cond_layout: Builtin(Int1),
+                        branching_layout: Builtin(Int1),
                         pass: (&[] as &[_], &Expr::Str("bar")),
                         fail: (&[] as &[_], &Expr::Str("foo")),
                         ret_layout: Builtin(Str),
@@ -257,8 +258,9 @@ mod test_mono {
                     )],
                     &Cond {
                         cond_symbol: gen_symbol_0,
-                        branch_symbol: gen_symbol_0,
+                        branching_symbol: gen_symbol_0,
                         cond_layout: Builtin(Int1),
+                        branching_layout: Builtin(Int1),
                         pass: (&[] as &[_], &Expr::Str("bar")),
                         fail: (
                             &[] as &[_],
@@ -270,7 +272,8 @@ mod test_mono {
                                 )],
                                 &Cond {
                                     cond_symbol: gen_symbol_1,
-                                    branch_symbol: gen_symbol_1,
+                                    branching_symbol: gen_symbol_1,
+                                    branching_layout: Builtin(Int1),
                                     cond_layout: Builtin(Int1),
                                     pass: (&[] as &[_], &Expr::Str("foo")),
                                     fail: (&[] as &[_], &Expr::Str("baz")),
@@ -317,8 +320,9 @@ mod test_mono {
                                 )],
                                 &Cond {
                                     cond_symbol: gen_symbol_0,
-                                    branch_symbol: gen_symbol_0,
+                                    branching_symbol: gen_symbol_0,
                                     cond_layout: Builtin(Int1),
+                                    branching_layout: Builtin(Int1),
                                     pass: (&[] as &[_], &Expr::Str("bar")),
                                     fail: (&[] as &[_], &Expr::Str("foo")),
                                     ret_layout: Builtin(Str),