Tracing

compiler/Cargo.toml

@@ -21,6 +21,7 @@ notify = "4.0.17"
 num-bigint = { version = "0.4.3", features = ["rand"] }
 num-integer = { version = "0.1.45", features = ["i128"] }
 num-traits = { version = "0.2.15", features = ["i128"] }
+pad = "0.1.6"
 proptest = "1.0.0"
 rand = "0.8.5"
 regex = "1.5.5"

compiler/src/compiler/hir_to_lir.rs

@@ -153,6 +153,7 @@ impl LoweringContext {
         is_curly: bool,
     ) {
         self.emit(Instruction::CreateClosure {
+            id: id.clone(),
             captured,
             num_args,
             body: instructions,

compiler/src/compiler/lir.rs

@@ -33,6 +33,7 @@ pub enum Instruction {
     ///
     /// a -> a, pointer to closure
     CreateClosure {
+        id: hir::Id,
         captured: Vec<StackOffset>,
         num_args: usize,
         body: Vec<Instruction>,
@@ -137,14 +138,15 @@ impl Display for Instruction {
                 write!(f, "createStruct {num_entries}")
             }
             Instruction::CreateClosure {
+                id,
                 captured,
                 num_args,
                 body: instructions,
                 is_curly,
             } => {
                 write!(
                     f,
-                    "createClosure with {num_args} {} capturing {} {}",
+                    "createClosure {id} with {num_args} {} capturing {} {}",
                     if *num_args == 1 {
                         "argument"
                     } else {

compiler/src/fuzzer/fuzzer.rs

@@ -4,7 +4,7 @@ use crate::{
     vm::{
         self,
         context::{ExecutionController, UseProvider},
-        tracer::FullTracer,
+        tracer::{full::FullTracer, Tracer},
         Closure, Heap, Packet, Pointer, Vm,
     },
 };
@@ -57,7 +57,7 @@ impl Status {
         Status::StillFuzzing {
             vm,
             arguments,
-            tracer: FullTracer::new(),
+            tracer: FullTracer::default(),
         }
     }
 }
@@ -96,13 +96,13 @@ impl Fuzzer {
     fn map_status<U: UseProvider, E: ExecutionController>(
         &self,
         status: Status,
-        use_provider: &mut U,
+        use_provider: &U,
         execution_controller: &mut E,
     ) -> Status {
         match status {
             Status::StillFuzzing { mut vm, arguments, mut tracer } => match vm.status() {
                 vm::Status::CanRun => {
-                    vm.run(use_provider, execution_controller, &mut tracer);
+                    vm.run(use_provider, execution_controller, &mut tracer.for_vm());
                     Status::StillFuzzing { vm, arguments, tracer }
                 }
                 vm::Status::WaitingForOperations => panic!("Fuzzing should not have to wait on channel operations because arguments were not channels."),

compiler/src/fuzzer/mod.rs

@@ -12,6 +12,7 @@ use crate::{
     module::Module,
     vm::{
         context::{DbUseProvider, RunForever, RunLimitedNumberOfInstructions},
+        tracer::Tracer,
         Closure, Heap, Pointer, Vm,
     },
 };
@@ -20,10 +21,10 @@ use tracing::{error, info};
 
 pub async fn fuzz(db: &Database, module: Module) {
     let (fuzzables_heap, fuzzables): (Heap, Vec<(Id, Pointer)>) = {
-        let mut tracer = FuzzablesFinder::new();
+        let mut tracer = FuzzablesFinder::default();
         let mut vm = Vm::new();
         vm.set_up_for_running_module_closure(Closure::of_module(db, module).unwrap());
-        vm.run(&mut DbUseProvider { db }, &mut RunForever, &mut tracer);
+        vm.run(&DbUseProvider { db }, &mut RunForever, &mut tracer.for_vm());
         (tracer.heap, tracer.fuzzables)
     };
 

compiler/src/fuzzer/utils.rs

@@ -1,72 +1,32 @@
 use crate::{
     compiler::hir::Id,
-    module::Module,
     vm::{
-        tracer::{InFiberTracer, Tracer},
-        ChannelId, FiberId, Heap, Pointer,
+        tracer::{FiberEvent, Tracer, VmEvent},
+        FiberId, Heap, Pointer,
     },
 };
 use std::collections::HashMap;
 
+#[derive(Default)]
 pub struct FuzzablesFinder {
     pub fuzzables: Vec<(Id, Pointer)>,
     pub heap: Heap,
     transferred_objects: HashMap<FiberId, HashMap<Pointer, Pointer>>,
 }
-impl FuzzablesFinder {
-    pub fn new() -> Self {
-        Self {
-            fuzzables: vec![],
-            heap: Heap::default(),
-            transferred_objects: HashMap::new(),
-        }
-    }
-}
 impl Tracer for FuzzablesFinder {
-    fn fiber_created(&mut self, _fiber: FiberId) {}
-    fn fiber_done(&mut self, _fiber: FiberId) {}
-    fn fiber_panicked(&mut self, _fiber: FiberId, _panicked_child: Option<FiberId>) {}
-    fn fiber_canceled(&mut self, _fiber: FiberId) {}
-    fn fiber_execution_started(&mut self, _fiber: FiberId) {}
-    fn fiber_execution_ended(&mut self, _fiber: FiberId) {}
-    fn channel_created(&mut self, _channel: ChannelId) {}
-    fn sent_to_channel(&mut self, _value: Pointer, _from: FiberId, _to: ChannelId) {}
-    fn received_from_channel(&mut self, _value: Pointer, _from: ChannelId, _to: FiberId) {}
-
-    fn in_fiber_tracer<'a>(&'a mut self, fiber: FiberId) -> Box<dyn InFiberTracer<'a> + 'a>
-    where
-        Self: 'a,
-    {
-        Box::new(InFiberFuzzablesFinder {
-            tracer: self,
-            fiber,
-        })
-    }
-}
-pub struct InFiberFuzzablesFinder<'a> {
-    tracer: &'a mut FuzzablesFinder,
-    fiber: FiberId,
-}
-impl<'a> InFiberTracer<'a> for InFiberFuzzablesFinder<'a> {
-    fn module_started(&mut self, _module: Module) {}
-    fn module_ended(&mut self, _heap: &Heap, _export_map: Pointer) {}
-    fn value_evaluated(&mut self, _heap: &Heap, _id: Id, _value: Pointer) {}
-    fn call_started(&mut self, _heap: &Heap, _id: Id, _closure: Pointer, _args: Vec<Pointer>) {}
-    fn call_ended(&mut self, _heap: &Heap, _return_value: Pointer) {}
-    fn needs_started(&mut self, _heap: &Heap, _id: Id, _condition: Pointer, _reason: Pointer) {}
-    fn needs_ended(&mut self) {}
+    fn add(&mut self, event: VmEvent) {
+        let VmEvent::InFiber { fiber, event } = event else { return; };
+        let FiberEvent::FoundFuzzableClosure { id, closure, heap } = event else { return; };
 
-    fn found_fuzzable_closure(&mut self, heap: &Heap, id: Id, closure: Pointer) {
         let address_map = self
-            .tracer
             .transferred_objects
-            .entry(self.fiber)
+            .entry(fiber)
             .or_insert_with(HashMap::new);
         let address = heap.clone_single_to_other_heap_with_existing_mapping(
-            &mut self.tracer.heap,
+            &mut self.heap,
             closure,
             address_map,
         );
-        self.tracer.fuzzables.push((id, address));
+        self.fuzzables.push((id, address));
     }
 }

compiler/src/language_server/hints/constant_evaluator.rs

@@ -12,7 +12,11 @@ use crate::{
     vm::{
         self,
         context::{DbUseProvider, RunLimitedNumberOfInstructions},
-        tracer::{stack_trace::StackEntry, Event, FullTracer, InFiberEvent, TimedEvent},
+        tracer::{
+            full::{FullTracer, StoredFiberEvent, StoredVmEvent, TimedEvent},
+            stack_trace::StackEntry,
+            Tracer,
+        },
         Closure, FiberId, Heap, Pointer, Vm,
     },
 };
@@ -32,7 +36,7 @@ struct Evaluator {
 
 impl ConstantEvaluator {
     pub fn update_module(&mut self, db: &Database, module: Module) {
-        let tracer = FullTracer::new();
+        let tracer = FullTracer::default();
         let mut vm = Vm::new();
         vm.set_up_for_running_module_closure(Closure::of_module(db, module.clone()).unwrap());
         self.evaluators.insert(module, Evaluator { tracer, vm });
@@ -57,9 +61,9 @@ impl ConstantEvaluator {
 
         if let Some((module, evaluator)) = running_evaluators.choose_mut(&mut thread_rng()) {
             evaluator.vm.run(
-                &mut DbUseProvider { db },
+                &DbUseProvider { db },
                 &mut RunLimitedNumberOfInstructions::new(500),
-                &mut evaluator.tracer,
+                &mut evaluator.tracer.for_vm(),
             );
             Some(module.clone())
         } else {
@@ -74,8 +78,8 @@ impl ConstantEvaluator {
             .events
             .iter()
             .filter_map(|event| match &event.event {
-                Event::InFiber {
-                    event: InFiberEvent::FoundFuzzableClosure { id, closure },
+                StoredVmEvent::InFiber {
+                    event: StoredFiberEvent::FoundFuzzableClosure { id, closure },
                     ..
                 } => Some((id.clone(), *closure)),
                 _ => None,
@@ -99,7 +103,8 @@ impl ConstantEvaluator {
         };
 
         for TimedEvent { event, .. } in &evaluator.tracer.events {
-            let Event::InFiber { event: InFiberEvent::ValueEvaluated { id, value }, .. } = event else { continue; };
+            let StoredVmEvent::InFiber { event, .. } = event else { continue; };
+            let StoredFiberEvent::ValueEvaluated { id, value } = event else { continue; };
 
             if &id.module != module {
                 continue;

compiler/src/language_server/hints/fuzzer.rs

@@ -9,7 +9,7 @@ use crate::{
     module::Module,
     vm::{
         context::{DbUseProvider, RunLimitedNumberOfInstructions},
-        tracer::{Event, InFiberEvent},
+        tracer::full::{StoredFiberEvent, StoredVmEvent},
         Heap, Pointer,
     },
 };
@@ -111,13 +111,13 @@ impl FuzzerManager {
                         // Find the innermost panicking call that is in the
                         // function.
                         .filter_map(|event| match &event.event {
-                            Event::InFiber { event, .. } => Some(event),
+                            StoredVmEvent::InFiber { event, .. } => Some(event),
                             _ => None,
                         })
                         .find(|event| {
                             let innermost_panicking_call_id = match &event {
-                                InFiberEvent::CallStarted { id, .. } => id,
-                                InFiberEvent::NeedsStarted { id, .. } => id,
+                                StoredFiberEvent::CallStarted { id, .. } => id,
+                                StoredFiberEvent::NeedsStarted { id, .. } => id,
                                 _ => return false,
                             };
                             id.is_same_module_and_any_parent_of(innermost_panicking_call_id)
@@ -133,10 +133,10 @@ impl FuzzerManager {
                         }
                     };
                     let (call_id, name, arguments) = match &panicking_inner_call {
-                        InFiberEvent::CallStarted { id, closure, args } => {
+                        StoredFiberEvent::CallStarted { id, closure, args } => {
                             (id.clone(), closure.format(&tracer.heap), args.clone())
                         }
-                        InFiberEvent::NeedsStarted {
+                        StoredFiberEvent::NeedsStarted {
                             id,
                             condition,
                             reason,

compiler/src/main.rs

@@ -28,7 +28,7 @@ use crate::{
     module::{Module, ModuleKind},
     vm::{
         context::{DbUseProvider, RunForever},
-        tracer::{FullTracer, Tracer},
+        tracer::{full::FullTracer, Tracer},
         Closure, ExecutionResult, FiberId, Status, Struct, Vm,
     },
 };
@@ -210,11 +210,15 @@ fn run(options: CandyRunOptions) {
     debug!("Running `{path_string}`.");
 
     let module_closure = Closure::of_module(&db, module.clone()).unwrap();
-    let mut tracer = FullTracer::new();
+    let mut tracer = FullTracer::default();
 
     let mut vm = Vm::new();
     vm.set_up_for_running_module_closure(module_closure);
-    vm.run(&mut DbUseProvider { db: &db }, &mut RunForever, &mut tracer);
+    vm.run(
+        &DbUseProvider { db: &db },
+        &mut RunForever,
+        &mut tracer.for_vm(),
+    );
     if let Status::WaitingForOperations = vm.status() {
         error!("The module waits on channel operations. Perhaps, the code tried to read from a channel without sending a packet into it.");
         // TODO: Show stack traces of all fibers?
@@ -273,18 +277,22 @@ fn run(options: CandyRunOptions) {
         let stdout_port = heap.create_send_port(stdout.channel);
         heap.create_struct(HashMap::from([(stdout_symbol, stdout_port)]))
     };
-    tracer.in_fiber_tracer(FiberId::root()).call_started(
-        &heap,
+    tracer.for_vm().for_fiber(FiberId::root()).call_started(
         Id::new(module, vec!["main".to_string()]),
         main,
         vec![environment],
+        &heap,
     );
     vm.set_up_for_running_closure(heap, main, &[environment]);
     loop {
         match vm.status() {
             Status::CanRun => {
                 debug!("VM still running.");
-                vm.run(&mut DbUseProvider { db: &db }, &mut RunForever, &mut tracer);
+                vm.run(
+                    &DbUseProvider { db: &db },
+                    &mut RunForever,
+                    &mut tracer.for_vm(),
+                );
             }
             Status::WaitingForOperations => {
                 todo!("VM can't proceed until some operations complete.");
@@ -299,8 +307,9 @@ fn run(options: CandyRunOptions) {
     match vm.tear_down() {
         ExecutionResult::Finished(return_value) => {
             tracer
-                .in_fiber_tracer(FiberId::root())
-                .call_ended(&return_value.heap, return_value.address);
+                .for_vm()
+                .for_fiber(FiberId::root())
+                .call_ended(return_value.address, &return_value.heap);
             debug!("The main function returned: {return_value:?}");
         }
         ExecutionResult::Panicked {

compiler/src/vm/builtin_functions.rs

@@ -4,8 +4,8 @@ use super::{
     fiber::{Fiber, Status},
     heap::{Closure, Data, Int, Pointer, ReceivePort, SendPort, Struct, Symbol, Text},
     ids::ChannelId,
-    tracer::DummyInFiberTracer,
-    Heap,
+    tracer::{dummy::DummyTracer, Tracer},
+    FiberId, Heap,
 };
 use crate::{builtin_functions::BuiltinFunction, compiler::lir::Instruction};
 use itertools::Itertools;
@@ -67,8 +67,8 @@ impl Fiber {
             Ok(DivergeControlFlow { closure }) => {
                 self.data_stack.push(closure);
                 self.run_instruction(
-                    &mut PanickingUseProvider,
-                    &mut DummyInFiberTracer,
+                    &PanickingUseProvider,
+                    &mut DummyTracer.for_vm().for_fiber(FiberId::root()),
                     Instruction::Call { num_args: 0 },
                 );
             }