Cleanup

executor/src/witgen/data_structures/finalizable_data.rs

@@ -411,7 +411,7 @@ impl<T: FieldElement> FinalizableData<T> {
         }
     }
 
-    pub fn append_new_finalized_rows<'a>(&'a mut self, count: usize) -> CompactDataRef<'a, T> {
+    pub fn append_new_finalized_rows(&mut self, count: usize) -> CompactDataRef<'_, T> {
         assert!(self.post_finalized_data.is_empty());
         let row_zero = self.finalized_data.len();
         self.finalized_data.append_new_rows(count);

executor/src/witgen/machines/block_machine.rs

@@ -19,7 +19,6 @@ use crate::witgen::sequence_iterator::{
 use crate::witgen::util::try_to_simple_poly;
 use crate::witgen::{machines::Machine, EvalError, EvalValue, IncompleteCause};
 use crate::witgen::{MutableState, QueryCallback};
-use bit_vec::BitVec;
 use powdr_ast::analyzed::{DegreeRange, PolyID, PolynomialType};
 use powdr_number::{DegreeType, FieldElement};
 

executor/src/witgen/machines/jit_machine_driver.rs

@@ -2,16 +2,16 @@ use bit_vec::BitVec;
 use powdr_number::FieldElement;
 
 use crate::witgen::{
-    data_structures::finalizable_data::{CompactData, CompactDataRef},
-    EvalError, FixedData, MutableState, QueryCallback,
+    data_structures::finalizable_data::CompactDataRef, util::try_to_simple_poly, EvalError,
+    FixedData, MutableState, QueryCallback,
 };
 
 use super::{LookupCell, MachineParts};
 
 pub struct JitMachineDriver<'a, T: FieldElement> {
-    fixed_data: &'a FixedData<'a, T>,
+    _fixed_data: &'a FixedData<'a, T>,
     parts: MachineParts<'a, T>,
-    block_size: usize,
+    _block_size: usize,
     latch_row: usize,
 }
 
@@ -23,25 +23,41 @@ impl<'a, T: FieldElement> JitMachineDriver<'a, T> {
         latch_row: usize,
     ) -> Self {
         JitMachineDriver {
-            fixed_data,
+            _fixed_data: fixed_data,
             parts,
-            block_size,
+            _block_size: block_size,
             latch_row,
         }
     }
 
-    pub fn can_answer_lookup(&self, identity_id: u64, known_inputs: &BitVec) -> bool {
-        // TODO
+    pub fn can_answer_lookup(&self, _identity_id: u64, _known_inputs: &BitVec) -> bool {
+        // TODO call the JIT compiler here.
         false
     }
 
     pub fn process_lookup_direct<'b, 'c, 'd, Q: QueryCallback<T>>(
         &self,
         _mutable_state: &'b mut MutableState<'a, 'b, T, Q>,
-        identity_id: u64,
+        connection_id: u64,
         values: Vec<LookupCell<'c, T>>,
-        data: CompactDataRef<'d, T>,
+        mut data: CompactDataRef<'d, T>,
     ) -> Result<bool, EvalError<T>> {
-        todo!();
+        // Transfer inputs.
+        let right = self.parts.connections[&connection_id].right;
+        for (e, v) in right.expressions.iter().zip(&values) {
+            match v {
+                LookupCell::Input(&v) => {
+                    let col = try_to_simple_poly(e).unwrap();
+                    data.set(self.latch_row as i32, col.poly_id.id as u32, v);
+                }
+                LookupCell::Output(_) => {}
+            }
+        }
+
+        // Just some code here to avoid "unused" warnings.
+        // This code will not be called as long as `can_answer_lookup` returns false.
+        data.get(self.latch_row as i32, 0);
+
+        unimplemented!();
     }
 }