Add DefaultHint

Author: 4l0n50

circuit/src/builder/compiler/expression_lowerer.rs

@@ -10,7 +10,7 @@ use crate::Op;
 use crate::builder::CircuitBuilderError;
 use crate::builder::compiler::get_witness_id;
 use crate::expr::{Expr, ExpressionGraph};
-use crate::op::WitnessHintFiller;
+use crate::op::{DefaultHint, WitnessHintFiller};
 use crate::types::{ExprId, WitnessAllocator, WitnessId};
 
 /// Sparse disjoint-set "find" with path compression over a HashMap (iterative).
@@ -189,29 +189,18 @@ where
 
         // Pass C: emit arithmetic ops in creation order; tie outputs to class slot if connected
         let mut hints_sequence = vec![];
-        let mut hints_wit_fillers_iter = self.hints_with_fillers.iter();
+        let mut fillers_iter = self.hints_with_fillers.iter().cloned();
         for (expr_idx, expr) in self.graph.nodes().iter().enumerate() {
             let expr_id = ExprId(expr_idx as u32);
             match expr {
                 Expr::Const(_) | Expr::Public(_) => { /* handled above */ }
-                Expr::Witness {
-                    has_filler: false, ..
-                } => {
-                    let expr_id = ExprId(expr_idx as u32);
-                    let out_widx = alloc_witness_id_for_expr(expr_idx);
-                    expr_to_widx.insert(expr_id, out_widx);
-                    hints_sequence.push(out_widx);
-                }
-                Expr::Witness {
-                    last_hint,
-                    has_filler: true,
-                } => {
+                Expr::Witness { last_hint } => {
                     let expr_id = ExprId(expr_idx as u32);
                     let out_widx = alloc_witness_id_for_expr(expr_idx);
                     expr_to_widx.insert(expr_id, out_widx);
                     hints_sequence.push(out_widx);
                     if *last_hint {
-                        let filler = hints_wit_fillers_iter.next().expect("Hints with fillers can be only created with `alloc_witness_hints`, which in turn must have add a filler");
+                        let filler = fillers_iter.next().unwrap_or(DefaultHint::boxed_default());
                         let inputs = filler
                             .inputs()
                             .iter()
@@ -228,7 +217,7 @@ where
                         primitive_ops.push(Op::Unconstrained {
                             inputs,
                             outputs: hints_sequence,
-                            filler: filler.clone(),
+                            filler,
                         });
                         hints_sequence = vec![];
                     }

circuit/src/builder/expression_builder.rs

@@ -111,10 +111,7 @@ where
     #[allow(unused_variables)]
     #[must_use]
     pub fn add_witness_hint(&mut self, label: &'static str) -> ExprId {
-        let expr_id = self.graph.add_expr(Expr::Witness {
-            last_hint: false,
-            has_filler: false,
-        });
+        let expr_id = self.graph.add_expr(Expr::Witness { last_hint: true });
 
         #[cfg(debug_assertions)]
         self.allocation_log.push(AllocationEntry {
@@ -143,7 +140,6 @@ where
             .map(|i| {
                 self.graph.add_expr(Expr::Witness {
                     last_hint: i == n_outputs - 1,
-                    has_filler: true,
                 })
             })
             .collect_vec();
@@ -601,16 +597,7 @@ mod tests {
         assert_eq!(builder.graph().nodes().len(), 4);
 
         match (&builder.graph().nodes()[2], &builder.graph().nodes()[3]) {
-            (
-                Expr::Witness {
-                    last_hint: false,
-                    has_filler: true,
-                },
-                Expr::Witness {
-                    last_hint: true,
-                    has_filler: true,
-                },
-            ) => (),
+            (Expr::Witness { last_hint: false }, Expr::Witness { last_hint: true }) => (),
             _ => panic!("Expected Witness operation"),
         }
     }

circuit/src/expr.rs

@@ -13,10 +13,7 @@ pub enum Expr<F> {
     /// a non-deterministic hint. The boolean indicates
     /// wether this is the last witness in a sequence of hint.
     /// A sequence of hints is one generated from a single filler.
-    /// TODO: The extra bool indicates whether this witness
-    /// has an associted filler. We should get rid of this
-    /// when all witness have an associated filler.
-    Witness { last_hint: bool, has_filler: bool },
+    Witness { last_hint: bool },
     /// Addition of two expressions
     Add { lhs: ExprId, rhs: ExprId },
     /// Subtraction of two expressions

circuit/src/op.rs

@@ -1,4 +1,5 @@
 use alloc::boxed::Box;
+use alloc::vec;
 use alloc::vec::Vec;
 use core::fmt::Debug;
 use core::hash::Hash;
@@ -417,6 +418,29 @@ impl<F> Clone for Box<dyn WitnessHintFiller<F>> {
     }
 }
 
+#[derive(Debug, Clone, Default)]
+pub struct DefaultHint {}
+
+impl DefaultHint {
+    pub fn boxed_default<F: Default>() -> Box<dyn WitnessHintFiller<F>> {
+        Box::new(Self::default())
+    }
+}
+
+impl<F: Default> WitnessHintFiller<F> for DefaultHint {
+    fn inputs(&self) -> &[ExprId] {
+        &[]
+    }
+
+    fn n_outputs(&self) -> usize {
+        1
+    }
+
+    fn compute_outputs(&self, _inputs_val: Vec<F>) -> Result<Vec<F>, CircuitError> {
+        Ok(vec![F::default()])
+    }
+}
+
 // Object-safe "clone into Box" helper
 pub trait WitnessFillerClone<F> {
     fn clone_box(&self) -> Box<dyn WitnessHintFiller<F>>;