Feat/debug tests functions

compiler/noirc_frontend/src/debug/mod.rs

@@ -1,6 +1,6 @@
 use crate::ast::PathSegment;
 use crate::parse_program;
-use crate::parser::ParsedModule;
+use crate::parser::{ParsedModule, ParsedSubModule};
 use crate::signed_field::SignedField;
 use crate::{
     ast,
@@ -63,7 +63,25 @@
             if let Item { kind: ItemKind::Function(f), .. } = item {
                 self.walk_fn(&mut f.def);
             }
+            if let Item {
+                kind:
+                    ItemKind::Submodules(ParsedSubModule {
+                        is_contract: true,
+                        contents: contract_module @ ParsedModule { .. },
+                        ..
+                    }),
+                ..
+            } = item
+            {
+                contract_module.items.iter_mut().for_each(|item| {
+                    if let Item { kind: ItemKind::Function(f), .. } = item {
+                        self.walk_fn(&mut f.def);
+                    }
+                });
+                self.insert_state_set_oracle(contract_module, 8, file);
+            }
         });
+
         // this part absolutely must happen after ast traversal above
         // so that oracle functions don't get wrapped, resulting in infinite recursion:
         self.insert_state_set_oracle(module, 8, file);
@@ -315,7 +333,7 @@
             }
             ast::LValue::Dereference(_lv, location) => {
                 // TODO: this is a dummy statement for now, but we should
                 // somehow track the derefence and update the pointed to
                 // variable
                 ast::Statement {
                     kind: ast::StatementKind::Expression(uint_expr(0, *location)),
@@ -719,9 +737,9 @@
             ast::Pattern::Tuple(patterns, _) => {
                 stack.extend(patterns.iter().map(|pattern| (pattern, false)));
             }
             ast::Pattern::Struct(_, pids, _) => {
                 stack.extend(pids.iter().map(|(_, pattern)| (pattern, is_mut)));
                 vars.extend(pids.iter().map(|(id, _)| (id.clone(), false)));
             }
             ast::Pattern::Interned(_, _) => (),
         }
@@ -732,7 +750,7 @@
 fn pattern_to_string(pattern: &ast::Pattern) -> String {
     match pattern {
         ast::Pattern::Identifier(id) => id.0.contents.clone(),
         ast::Pattern::Mutable(mpat, _, _) => format!("mut {}", pattern_to_string(mpat.as_ref())),
         ast::Pattern::Tuple(elements, _) => format!(
             "({})",
             elements.iter().map(pattern_to_string).collect::<Vec<String>>().join(", ")

tooling/debugger/Cargo.toml

@@ -28,6 +28,8 @@ dap.workspace = true
 easy-repl = "0.2.1"
 owo-colors = "3"
 serde_json.workspace = true
+bn254_blackbox_solver.workspace = true
+
 
 [dev-dependencies]
 assert_cmd = "2.0.12"

tooling/debugger/src/context.rs

@@ -1,7 +1,7 @@
 use crate::foreign_calls::DebugForeignCallExecutor;
 use acvm::acir::brillig::BitSize;
 use acvm::acir::circuit::brillig::{BrilligBytecode, BrilligFunctionId};
-use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
+use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation, ResolvedOpcodeLocation};
 use acvm::acir::native_types::{Witness, WitnessMap, WitnessStack};
 use acvm::brillig_vm::MemoryValue;
 use acvm::pwg::{
@@ -12,15 +12,16 @@
 
 use codespan_reporting::files::{Files, SimpleFile};
 use fm::FileId;
-use nargo::errors::{ExecutionError, Location};
+use nargo::errors::{execution_error_from, ExecutionError, Location};
 use nargo::NargoError;
 use noirc_artifacts::debug::{DebugArtifact, StackFrame};
 use noirc_driver::DebugFile;
 
+use noirc_printable_type::{PrintableType, PrintableValue};
 use thiserror::Error;
 
 use std::collections::BTreeMap;
-use std::collections::{hash_set::Iter, HashSet};
+use std::collections::HashSet;
 
 /// A Noir program is composed by
 /// `n` ACIR circuits
@@ -189,6 +190,15 @@
     }
 }
 
+impl From<DebugLocation> for ResolvedOpcodeLocation {
+    fn from(debug_loc: DebugLocation) -> Self {
+        ResolvedOpcodeLocation {
+            acir_function_index: usize::try_from(debug_loc.circuit_id).unwrap(),
+            opcode_location: debug_loc.opcode_location,
+        }
+    }
+}
+
 #[derive(Error, Debug)]
 pub enum DebugLocationFromStrError {
     #[error("Invalid debug location string: {0}")]
@@ -227,6 +237,29 @@
     Error(NargoError<FieldElement>),
 }
 
+#[derive(Debug)]
+pub struct DebugStackFrame<F> {
+    pub function_name: String,
+    pub function_params: Vec<String>,
+    pub variables: Vec<(String, PrintableValue<F>, PrintableType)>,
+}
+
+impl<F: Clone> From<&StackFrame<'_, F>> for DebugStackFrame<F> {
+    fn from(value: &StackFrame<F>) -> Self {
+        DebugStackFrame {
+            function_name: value.function_name.to_string(),
+            function_params: value.function_params.iter().map(|param| param.to_string()).collect(),
+            variables: value
+                .variables
+                .iter()
+                .map(|(name, value, var_type)| {
+                    (name.to_string(), (**value).clone(), (*var_type).clone())
+                })
+                .collect(),
+        }
+    }
+}
+
 pub struct ExecutionFrame<'a, B: BlackBoxFunctionSolver<FieldElement>> {
     circuit_id: u32,
     acvm: ACVM<'a, FieldElement, B>,
@@ -251,6 +284,25 @@
     unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
 
     acir_opcode_addresses: AddressMap,
+    initial_witness: WitnessMap<FieldElement>,
+}
+
+fn initialize_acvm<'a, B: BlackBoxFunctionSolver<FieldElement>>(
+    backend: &'a B,
+    circuits: &'a [Circuit<FieldElement>],
+    initial_witness: WitnessMap<FieldElement>,
+    unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
+) -> ACVM<'a, FieldElement, B> {
+    let current_circuit_id: u32 = 0;
+    let initial_circuit = &circuits[current_circuit_id as usize];
+
+    ACVM::new(
+        backend,
+        &initial_circuit.opcodes,
+        initial_witness,
+        unconstrained_functions,
+        &initial_circuit.assert_messages,
+    )
 }
 
 impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
@@ -264,16 +316,8 @@
     ) -> Self {
         let source_to_opcodes = build_source_to_opcode_debug_mappings(debug_artifact);
         let current_circuit_id: u32 = 0;
-        let initial_circuit = &circuits[current_circuit_id as usize];
         let acir_opcode_addresses = AddressMap::new(circuits, unconstrained_functions);
         Self {
-            acvm: ACVM::new(
-                blackbox_solver,
-                &initial_circuit.opcodes,
-                initial_witness,
-                unconstrained_functions,
-                &initial_circuit.assert_messages,
-            ),
             current_circuit_id,
             brillig_solver: None,
             witness_stack: WitnessStack::default(),
@@ -286,6 +330,13 @@
             circuits,
             unconstrained_functions,
             acir_opcode_addresses,
+            initial_witness: initial_witness.clone(), // keeping it to be able to restart the context by itself
+            acvm: initialize_acvm(
+                blackbox_solver,
+                circuits,
+                initial_witness,
+                unconstrained_functions,
+            ),
         }
     }
 
@@ -415,6 +466,12 @@
         Some(found_location)
     }
 
+    pub(super) fn find_opcode_at_current_file_line(&self, line: i64) -> Option<DebugLocation> {
+        let file = self.get_current_file()?;
+
+        self.find_opcode_for_source_location(&file, line)
+    }
+
     /// Returns the callstack in source code locations for the currently
     /// executing opcode. This can be `None` if the execution finished (and
     /// `get_current_opcode_location()` returns `None`) or if the opcode is not
@@ -430,7 +487,7 @@
     }
 
     /// Returns the `FileId` of the file associated with the innermost function on the call stack.
-    pub(super) fn get_current_file(&mut self) -> Option<FileId> {
+    fn get_current_file(&self) -> Option<FileId> {
         self.get_current_source_location()
             .and_then(|locations| locations.last().map(|location| location.file))
     }
@@ -539,9 +596,17 @@
                 self.brillig_solver = Some(solver);
                 self.handle_foreign_call(foreign_call)
             }
-            Err(err) => DebugCommandResult::Error(NargoError::ExecutionError(
-                ExecutionError::SolvingError(err, None),
-            )),
+            Err(err) => {
+                let error = execution_error_from(
+                    err,
+                    &self
+                        .get_call_stack()
+                        .into_iter()
+                        .map(|op| op.into())
+                        .collect::<Vec<ResolvedOpcodeLocation>>(),
+                );
+                DebugCommandResult::Error(NargoError::ExecutionError(error))
+            }
         }
     }
 
@@ -550,6 +615,7 @@
         foreign_call: ForeignCallWaitInfo<FieldElement>,
     ) -> DebugCommandResult {
         let foreign_call_result = self.foreign_call_executor.execute(&foreign_call);
+
         match foreign_call_result {
             Ok(foreign_call_result) => {
                 if let Some(mut solver) = self.brillig_solver.take() {
@@ -844,10 +910,6 @@
         self.breakpoints.remove(location)
     }
 
-    pub(super) fn iterate_breakpoints(&self) -> Iter<'_, DebugLocation> {
-        self.breakpoints.iter()
-    }
-
     pub(super) fn clear_breakpoints(&mut self) {
         self.breakpoints.clear();
     }
@@ -861,6 +923,22 @@
         self.witness_stack.push(0, last_witness_map);
         self.witness_stack
     }
+
+    pub(super) fn restart(&mut self) {
+        // restart everything that's progress related
+        // by assigning the initial values
+        self.current_circuit_id = 0;
+        self.brillig_solver = None;
+        self.witness_stack = WitnessStack::default();
+        self.acvm_stack = vec![];
+        self.foreign_call_executor.restart(self.debug_artifact);
+        self.acvm = initialize_acvm(
+            self.backend,
+            self.circuits,
+            self.initial_witness.clone(),
+            self.unconstrained_functions,
+        );
+    }
 }
 
 fn is_debug_file_in_debug_crate(debug_file: &DebugFile) -> bool {
@@ -1022,7 +1100,7 @@
             outputs: vec![],
             predicate: None,
         }];
         let brillig_funcs = &[brillig_bytecode];
         let current_witness_index = 2;
         let circuit = Circuit { current_witness_index, opcodes, ..Circuit::default() };
         let circuits = &[circuit];
@@ -1035,15 +1113,18 @@
 
         let foreign_call_executor = Box::new(DefaultDebugForeignCallExecutor::from_artifact(
             PrintOutput::Stdout,
+            None,
             debug_artifact,
+            None,
+            String::new(),
         ));
-        let mut context = DebugContext::new(
+        let mut context = DebugContext::<StubbedBlackBoxSolver>::new(
             &solver,
             circuits,
             debug_artifact,
             initial_witness,
             foreign_call_executor,
             brillig_funcs,
         );
 
         assert_eq!(
@@ -1079,7 +1160,7 @@
             })
         );
 
         // Calldatacopy
         let result = context.step_into_opcode();
         assert!(matches!(result, DebugCommandResult::Ok));
         assert_eq!(
@@ -1203,10 +1284,13 @@
 
         let foreign_call_executor = Box::new(DefaultDebugForeignCallExecutor::from_artifact(
             PrintOutput::Stdout,
+            None,
             debug_artifact,
+            None,
+            String::new(),
         ));
         let brillig_funcs = &[brillig_bytecode];
-        let mut context = DebugContext::new(
+        let mut context = DebugContext::<StubbedBlackBoxSolver>::new(
             &solver,
             circuits,
             debug_artifact,
@@ -1294,12 +1378,17 @@
         let debug_artifact = DebugArtifact { debug_symbols: vec![], file_map: BTreeMap::new() };
         let brillig_funcs = &[brillig_one, brillig_two];
 
-        let context = DebugContext::new(
+        let context = DebugContext::<StubbedBlackBoxSolver>::new(
             &solver,
             &circuits,
             &debug_artifact,
             WitnessMap::new(),
-            Box::new(DefaultDebugForeignCallExecutor::new(PrintOutput::Stdout)),
+            Box::new(DefaultDebugForeignCallExecutor::new(
+                PrintOutput::Stdout,
+                None,
+                None,
+                String::new(),
+            )),
             brillig_funcs,
         );