allocate cut variables properly (#2183)

src/allocator.rs

@@ -36,12 +36,7 @@ pub(crate) trait Allocator {
         is_new_var: bool,
     );
 
-    fn mark_cut_var<'a, Target: CompilationTarget<'a>>(
+    fn mark_cut_var(&mut self, var_num: usize, chunk_num: usize) -> RegType;
-        &mut self,
-        var_num: usize,
-        term_loc: GenContext,
-        code: &mut CodeDeque,
-    ) -> RegType;
 
     fn mark_var<'a, Target: CompilationTarget<'a>>(
         &mut self,

src/codegen.rs

@@ -926,16 +926,12 @@ impl<'b> CodeGenerator<'b> {
                         match term {
                             &QueryTerm::GetLevel(var_num) => {
                                 let code = branch_code_stack.code(code);
-                                let r = self
+                                let r = self.marker.mark_cut_var(var_num, chunk_num);
-                                    .marker
-                                    .mark_cut_var::<QueryInstruction>(var_num, term_loc, code);
                                 code.push_back(instr!("get_level", r));
                             }
                             &QueryTerm::GetCutPoint { var_num, prev_b } => {
                                 let code = branch_code_stack.code(code);
-                                let r = self
+                                let r = self.marker.mark_cut_var(var_num, chunk_num);
-                                    .marker
-                                    .mark_cut_var::<FactInstruction>(var_num, term_loc, code);
 
                                 code.push_back(if prev_b {
                                     instr!("get_prev_level", r)

src/debray_allocator.rs

@@ -840,18 +840,23 @@ impl Allocator for DebrayAllocator {
         self.in_use.insert(o);
     }
 
-    fn mark_cut_var<'a, Target: CompilationTarget<'a>>(
+    fn mark_cut_var(&mut self, var_num: usize, chunk_num: usize) -> RegType {
-        &mut self,
-        var_num: usize,
-        term_loc: GenContext,
-        code: &mut CodeDeque,
-    ) -> RegType {
         match self.get_binding(var_num) {
-            RegType::Perm(0) => RegType::Perm(self.alloc_perm_var(var_num, term_loc.chunk_num())),
+            RegType::Perm(0) => RegType::Perm(self.alloc_perm_var(var_num, chunk_num)),
             RegType::Temp(0) => {
-                let cell = Cell::default();
+                let t = self.alloc_reg_to_non_var();
-                self.mark_var::<Target>(var_num, Level::Shallow, &cell, term_loc, code);
+
-                cell.get().norm()
+                match &mut self.var_data.records[var_num].allocation {
+                    VarAlloc::Temp {
+                        temp_reg, safety, ..
+                    } => {
+                        *temp_reg = t;
+                        *safety = VarSafetyStatus::GloballyUnneeded;
+                    }
+                    _ => unreachable!(),
+                };
+
+                RegType::Temp(t)
             }
             r => r,
         }