Merge pull request #259 from 0xnullifier/log-string

Adds generic `self.print_log` and logging for string literal

Author: katat

examples/log.no

@@ -0,0 +1,19 @@
+
+struct Thing {
+    xx: Field,
+    yy: Field
+}
+
+fn main(pub public_input: Field) -> Field {
+
+    log(1234);
+    log(true);
+
+    let arr = [1,2,3];
+    log(arr);
+
+    let thing = Thing { xx : public_input , yy: public_input + 1};
+    log("formatted string with a number {} boolean {} arr {} struct {}" , 1234,true, arr , thing);
+
+    return public_input + 1;
+}

src/backends/kimchi/mod.rs

@@ -22,7 +22,7 @@ use crate::{
     backends::kimchi::asm::parse_coeffs,
     circuit_writer::{
         writer::{AnnotatedCell, Cell, PendingGate},
-        DebugInfo, Gate, GateKind, Wiring,
+        DebugInfo, Gate, GateKind, VarInfo, Wiring,
     },
     compiler::Sources,
     constants::Span,
@@ -128,6 +128,9 @@ pub struct KimchiVesta {
     /// Indexes used by the private inputs
     /// (this is useful to check that they appear in the circuit)
     pub(crate) private_input_cell_vars: Vec<KimchiCellVar>,
+
+    /// Log information
+    pub(crate) log_info: Vec<(Span, VarInfo<VestaField, KimchiCellVar>)>,
 }
 
 impl Witness {
@@ -174,6 +177,7 @@ impl KimchiVesta {
             finalized: false,
             public_input_size: 0,
             private_input_cell_vars: vec![],
+            log_info: vec![],
         }
     }
 
@@ -418,11 +422,11 @@ impl Backend for KimchiVesta {
         self.compute_val(env, val, var.index)
     }
 
-    fn generate_witness<B: Backend>(
+    fn generate_witness(
         &self,
         witness_env: &mut WitnessEnv<VestaField>,
         sources: &Sources,
-        _typed: &Mast<B>,
+        typed: &Mast<Self>,
     ) -> Result<GeneratedWitness> {
         if !self.finalized {
             unreachable!("the circuit must be finalized before generating a witness");
@@ -471,6 +475,7 @@ impl Backend for KimchiVesta {
             }
             public_outputs.push(val);
         }
+        self.print_log(witness_env, &self.log_info, sources, typed)?;
 
         // sanity check the witness
         for (row, (gate, witness_row, debug_info)) in
@@ -799,9 +804,8 @@ impl Backend for KimchiVesta {
     fn log_var(
         &mut self,
         var: &crate::circuit_writer::VarInfo<Self::Field, Self::Var>,
-        msg: String,
         span: Span,
     ) {
-        println!("todo: implement log_var for kimchi backend");
+        self.log_info.push((span, var.clone()));
     }
 }

src/backends/mod.rs

@@ -13,6 +13,8 @@ use crate::{
     error::{Error, ErrorKind, Result},
     helpers::PrettyField,
     imports::FnHandle,
+    parser::types::TyKind,
+    utils::{log_array_type, log_custom_type, log_string_type},
     var::{ConstOrCell, Value, Var},
     witness::WitnessEnv,
 };
@@ -413,15 +415,105 @@ pub trait Backend: Clone {
     ) -> Result<()>;
 
     /// Generate the witness for a backend.
-    fn generate_witness<B: Backend>(
+    fn generate_witness(
         &self,
         witness_env: &mut WitnessEnv<Self::Field>,
         sources: &Sources,
-        typed: &Mast<B>,
+        typed: &Mast<Self>,
     ) -> Result<Self::GeneratedWitness>;
 
     /// Generate the asm for a backend.
     fn generate_asm(&self, sources: &Sources, debug: bool) -> String;
 
-    fn log_var(&mut self, var: &VarInfo<Self::Field, Self::Var>, msg: String, span: Span);
+    fn log_var(&mut self, var: &VarInfo<Self::Field, Self::Var>, span: Span);
+
+    /// print the log given the log_info
+    fn print_log(
+        &self,
+        witness_env: &mut WitnessEnv<Self::Field>,
+        logs: &[(Span, VarInfo<Self::Field, Self::Var>)],
+        sources: &Sources,
+        typed: &Mast<Self>,
+    ) -> Result<()> {
+        let mut logs_iter = logs.into_iter();
+        while let Some((span, var_info)) = logs_iter.next() {
+            let (filename, source) = sources.get(&span.filename_id).unwrap();
+            let (line, _, _) = crate::utils::find_exact_line(source, *span);
+            let dbg_msg = format!("[{filename}:{line}] -> ");
+
+            match &var_info.typ {
+                // Field
+                Some(TyKind::Field { .. }) => match &var_info.var[0] {
+                    ConstOrCell::Const(cst) => {
+                        println!("{dbg_msg}{}", cst.pretty());
+                    }
+                    ConstOrCell::Cell(cell) => {
+                        let val = self.compute_var(witness_env, cell)?;
+                        println!("{dbg_msg}{}", val.pretty());
+                    }
+                },
+
+                // Bool
+                Some(TyKind::Bool) => match &var_info.var[0] {
+                    ConstOrCell::Const(cst) => {
+                        let val = *cst == Self::Field::one();
+                        println!("{dbg_msg}{}", val);
+                    }
+                    ConstOrCell::Cell(cell) => {
+                        let val = self.compute_var(witness_env, cell)? == Self::Field::one();
+                        println!("{dbg_msg}{}", val);
+                    }
+                },
+
+                // Array
+                Some(TyKind::Array(b, s)) => {
+                    let (output, remaining) =
+                        log_array_type(self, &var_info.var.cvars, b, *s, witness_env, typed, span)?;
+                    assert!(remaining.is_empty());
+                    println!("{dbg_msg}{}", output);
+                }
+
+                // Custom types
+                Some(TyKind::Custom {
+                    module,
+                    name: struct_name,
+                }) => {
+                    let mut string_vec = Vec::new();
+                    let (output, remaining) = log_custom_type(
+                        self,
+                        module,
+                        struct_name,
+                        typed,
+                        &var_info.var.cvars,
+                        witness_env,
+                        span,
+                        &mut string_vec,
+                    )?;
+                    assert!(remaining.is_empty());
+                    println!("{dbg_msg}{}{}", struct_name, output);
+                }
+
+                // GenericSizedArray
+                Some(TyKind::GenericSizedArray(_, _)) => {
+                    unreachable!("GenericSizedArray should be monomorphized")
+                }
+
+                Some(TyKind::String(s)) => {
+                    let output =
+                        log_string_type(self, &mut logs_iter, s, witness_env, typed, span)?;
+                    println!("{dbg_msg}{}", output);
+                }
+
+                None => {
+                    return Err(Error::new(
+                        "log",
+                        ErrorKind::UnexpectedError("No type info for logging"),
+                        *span,
+                    ))
+                }
+            }
+        }
+
+        Ok(())
+    }
 }