Assert that block machines are stackable (#2307)

Fixes a TODO that makes block machine fail hard if a block machine is
not stackable. This way, we'll know when this happens, instead of
silently resorting to run-time solving.

executor/src/witgen/jit/block_machine_processor.rs

@@ -68,7 +68,7 @@ impl<'a, T: FieldElement> BlockMachineProcessor<'a, T> {
         // Solve for the block witness.
         // Fails if any machine call cannot be completed.
         match self.solve_block(can_process, &mut witgen, connection.right) {
-            Ok(()) => Ok(witgen.code()),
+            Ok(()) => Ok(witgen.finish()),
             Err(e) => {
                 log::debug!("\nCode generation failed for connection:\n  {connection}");
                 let known_args_str = known_args
@@ -80,7 +80,7 @@ impl<'a, T: FieldElement> BlockMachineProcessor<'a, T> {
                 log::debug!("Error:\n  {e}");
                 log::debug!(
                     "The following code was generated so far:\n{}",
-                    format_code(witgen.code().as_slice())
+                    format_code(witgen.code())
                 );
                 Err(format!("Code generation failed: {e}\nRun with RUST_LOG=debug to see the code generated so far."))
             }
@@ -131,10 +131,14 @@ impl<'a, T: FieldElement> BlockMachineProcessor<'a, T> {
             }
         }
 
-        // TODO: Fail hard (or return a different error), as this should never
-        // happen for valid block machines. Currently fails in:
-        // powdr-pipeline::powdr_std arith256_memory_large_test
-        self.check_block_shape(witgen)?;
+        if let Err(e) = self.check_block_shape(witgen) {
+            // Fail hard, as this should never happen for a correctly detected block machine.
+            log::debug!(
+                "The following code was generated so far:\n{}",
+                format_code(witgen.code())
+            );
+            panic!("{e}");
+        }
         self.check_incomplete_machine_calls(&complete)?;
 
         Ok(())
@@ -192,7 +196,7 @@ impl<'a, T: FieldElement> BlockMachineProcessor<'a, T> {
                     block_list,
                     values[self.block_size + 1]
                 );
-                log::debug!("Column {column_name} is not stackable:\n{column_str}");
+                log::error!("Column {column_name} is not stackable:\n{column_str}");
             }
 
             stackable

executor/src/witgen/jit/single_step_processor.rs

@@ -51,7 +51,7 @@ impl<'a, T: FieldElement> SingleStepProcessor<'a, T> {
 
         let missing_identities = self.machine_parts.identities.len() - complete.len();
         let code = if unknown_witnesses.is_empty() && missing_identities == 0 {
-            witgen.code()
+            witgen.finish()
         } else {
             let Some(most_constrained_var) = witgen
                 .known_variables()

executor/src/witgen/jit/symbolic_expression.rs

@@ -262,7 +262,10 @@ impl<T: FieldElement, V: Clone> SymbolicExpression<T, V> {
 
     /// Integer division, i.e. convert field elements to unsigned integer and divide.
     pub fn integer_div(&self, rhs: &Self) -> Self {
-        if rhs.is_known_one() {
+        if let (SymbolicExpression::Concrete(a), SymbolicExpression::Concrete(b)) = (self, rhs) {
+            assert!(b != &T::from(0));
+            SymbolicExpression::Concrete(*a / *b)
+        } else if rhs.is_known_one() {
             self.clone()
         } else {
             SymbolicExpression::BinaryOperation(

executor/src/witgen/jit/witgen_inference.rs

@@ -88,10 +88,14 @@ impl<'a, T: FieldElement, FixedEval: FixedEvaluator<T>> WitgenInference<'a, T, F
         }
     }
 
-    pub fn code(self) -> Vec<Effect<T, Variable>> {
+    pub fn finish(self) -> Vec<Effect<T, Variable>> {
         self.code
     }
 
+    pub fn code(&self) -> &[Effect<T, Variable>] {
+        &self.code
+    }
+
     pub fn known_variables(&self) -> &HashSet<Variable> {
         &self.known_variables
     }
@@ -627,7 +631,7 @@ mod test {
             }
             assert!(counter < 10000, "Solving took more than 10000 rounds.");
         }
-        format_code(&witgen.code())
+        format_code(witgen.code())
     }
 
     #[test]