Tracing

README.md

@@ -137,19 +137,21 @@ We already have a language server that provides some tooling.
 ## Short-term TODOs
 
 - fix fault attribution
-- rearchitect tracing
 - new name?
 - add caching while compile-time evaluating code
-- tags?
+- tags
 - pattern matching
 - pipe operator
+- add CI
+- add tests
+- add a more lightweight tracer that only tracks stack traces
 - text interpolation
-- eliminate common subtrees
-- inline functions
+- optimize: eliminate common subtrees
+- optimize: inline functions
 - minimize inputs found through fuzzing
 - fuzz parser
 - remove builtinPrint
-- tail call optimization
+- optimize: tail call optimization
 - parse function declaration with doc comment but no code
 - tracing visualization
 - distinguish packages from normal modules

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

@@ -82,6 +82,7 @@ impl LoweringContext {
                         .collect_vec(),
                     lambda.parameters.len(),
                     instructions,
+                    !lambda.fuzzable,
                 );
                 if lambda.fuzzable {
                     self.emit_register_fuzzable_closure(id.clone());
@@ -96,9 +97,11 @@ impl LoweringContext {
                 }
 
                 self.emit_push_from_stack(function.clone());
+                self.emit_start_responsibility(id.clone());
                 self.emit_trace_call_starts(id.clone(), arguments.len());
                 self.emit_call(id.clone(), arguments.len());
                 self.emit_trace_call_ends();
+                self.emit_end_responsibility();
             }
             Expression::Builtin(builtin) => {
                 self.emit_create_builtin(id.clone(), *builtin);
@@ -147,11 +150,14 @@ impl LoweringContext {
         captured: Vec<StackOffset>,
         num_args: usize,
         instructions: Vec<Instruction>,
+        is_curly: bool,
     ) {
         self.emit(Instruction::CreateClosure {
+            id: id.clone(),
             captured,
             num_args,
             body: instructions,
+            is_curly,
         });
         self.stack.push(id);
     }
@@ -184,6 +190,12 @@ impl LoweringContext {
         self.emit(Instruction::UseModule { current_module });
         self.stack.push(id); // exported definitions
     }
+    fn emit_start_responsibility(&mut self, responsible: hir::Id) {
+        self.emit(Instruction::StartResponsibility(responsible));
+    }
+    fn emit_end_responsibility(&mut self) {
+        self.emit(Instruction::EndResponsibility);
+    }
     fn emit_needs(&mut self, id: hir::Id) {
         self.stack.pop(); // reason
         self.stack.pop(); // condition

compiler/src/compiler/lir.rs

@@ -1,4 +1,4 @@
-use super::error::CompilerError;
+use super::{error::CompilerError, hir::Id};
 use crate::{builtin_functions::BuiltinFunction, hir, module::Module};
 use itertools::Itertools;
 use num_bigint::BigUint;
@@ -33,9 +33,11 @@ pub enum Instruction {
     ///
     /// a -> a, pointer to closure
     CreateClosure {
+        id: hir::Id,
         captured: Vec<StackOffset>,
         num_args: usize,
         body: Vec<Instruction>,
+        is_curly: bool,
     },
 
     /// Pushes a builtin function.
@@ -89,6 +91,12 @@ pub enum Instruction {
         current_module: Module,
     },
 
+    /// Contrary to other languages, in Candy it's always clear who's fault it
+    /// is when a program panics. Each fiber maintains a responsibility stack
+    /// which notes which call-site is responsible for needs to be fulfilled.
+    StartResponsibility(Id),
+    EndResponsibility,
+
     /// Pops a boolean condition and a reason. If the condition is true, it
     /// just pushes Nothing. If the condition is false, it panics with the
     /// reason.
@@ -130,13 +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 {
@@ -146,7 +156,12 @@ impl Display for Instruction {
                         "nothing".to_string()
                     } else {
                         captured.iter().join(", ")
-                    }
+                    },
+                    if *is_curly {
+                        "(is curly)"
+                    } else {
+                        "(is not curly)"
+                    },
                 )?;
                 for instruction in instructions {
                     let indented = format!("{instruction}")
@@ -171,6 +186,10 @@ impl Display for Instruction {
             Instruction::UseModule { current_module } => {
                 write!(f, "useModule (currently in {})", current_module)
             }
+            Instruction::StartResponsibility(responsible) => {
+                write!(f, "responsibility of {responsible} starts")
+            }
+            Instruction::EndResponsibility => write!(f, "responsibility ends"),
             Instruction::Needs => write!(f, "needs"),
             Instruction::RegisterFuzzableClosure(hir_id) => {
                 write!(f, "registerFuzzableClosure {hir_id}")

compiler/src/fuzzer/fuzzer.rs

@@ -1,14 +1,14 @@
-use super::{generator::generate_n_values, utils::did_need_in_closure_cause_panic};
+use super::generator::generate_n_values;
 use crate::{
     compiler::hir,
-    database::Database,
     vm::{
         self,
         context::{ExecutionController, UseProvider},
-        tracer::Tracer,
-        Closure, Heap, Pointer, TearDownResult, Vm,
+        tracer::{full::FullTracer, Tracer},
+        Closure, Heap, Packet, Pointer, Vm,
     },
 };
+use itertools::Itertools;
 use std::mem;
 
 pub struct Fuzzer {
@@ -24,15 +24,15 @@ pub enum Status {
     // input that triggers the loop.
     StillFuzzing {
         vm: Vm,
-        arguments: Vec<Pointer>,
+        arguments: Vec<Packet>,
+        tracer: FullTracer,
     },
     // TODO: In the future, also add a state for trying to simplify the
     // arguments.
     PanickedForArguments {
-        heap: Heap,
-        arguments: Vec<Pointer>,
+        arguments: Vec<Packet>,
         reason: String,
-        tracer: Tracer,
+        tracer: FullTracer,
     },
 }
 
@@ -45,12 +45,20 @@ impl Status {
 
         let mut vm_heap = Heap::default();
         let closure = closure_heap.clone_single_to_other_heap(&mut vm_heap, closure);
-        let arguments = generate_n_values(&mut vm_heap, num_args);
+        let arguments = generate_n_values(num_args);
+        let argument_addresses = arguments
+            .iter()
+            .map(|arg| arg.clone_to_other_heap(&mut vm_heap))
+            .collect_vec();
 
         let mut vm = Vm::new();
-        vm.set_up_for_running_closure(vm_heap, closure, &arguments);
+        vm.set_up_for_running_closure(vm_heap, closure, &argument_addresses);
 
-        Status::StillFuzzing { vm, arguments }
+        Status::StillFuzzing {
+            vm,
+            arguments,
+            tracer: FullTracer::default(),
+        }
     }
 }
 impl Fuzzer {
@@ -74,46 +82,41 @@ impl Fuzzer {
 
     pub fn run<U: UseProvider, E: ExecutionController>(
         &mut self,
-        db: &Database,
         use_provider: &mut U,
         execution_controller: &mut E,
     ) {
         let mut status = mem::replace(&mut self.status, None).unwrap();
         while matches!(status, Status::StillFuzzing { .. })
             && execution_controller.should_continue_running()
         {
-            status = self.map_status(status, db, use_provider, execution_controller);
+            status = self.map_status(status, use_provider, execution_controller);
         }
         self.status = Some(status);
     }
     fn map_status<U: UseProvider, E: ExecutionController>(
         &self,
         status: Status,
-        db: &Database,
-        use_provider: &mut U,
+        use_provider: &U,
         execution_controller: &mut E,
     ) -> Status {
         match status {
-            Status::StillFuzzing { mut vm, arguments } => match vm.status() {
+            Status::StillFuzzing { mut vm, arguments, mut tracer } => match vm.status() {
                 vm::Status::CanRun => {
-                    vm.run(use_provider, execution_controller);
-                    Status::StillFuzzing { vm, arguments }
+                    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."),
                 // The VM finished running without panicking.
                 vm::Status::Done => Status::new_fuzzing_attempt(&self.closure_heap, self.closure),
-                vm::Status::Panicked { reason } => {
+                vm::Status::Panicked { reason, responsible } => {
                     // If a `needs` directly inside the tested closure was not
                     // satisfied, then the panic is not closure's fault, but our
                     // fault.
-                    let TearDownResult { heap, tracer, .. } = vm.tear_down();
-                    let is_our_fault =
-                        did_need_in_closure_cause_panic(db, &self.closure_id, &tracer);
+                    let is_our_fault = responsible.is_none();
                     if is_our_fault {
                         Status::new_fuzzing_attempt(&self.closure_heap, self.closure)
                     } else {
                         Status::PanickedForArguments {
-                            heap,
                             arguments,
                             reason,
                             tracer,
@@ -124,12 +127,10 @@ impl Fuzzer {
             // We already found some arguments that caused the closure to panic,
             // so there's nothing more to do.
             Status::PanickedForArguments {
-                heap,
                 arguments,
                 reason,
                 tracer,
             } => Status::PanickedForArguments {
-                heap,
                 arguments,
                 reason,
                 tracer,

compiler/src/fuzzer/generator.rs

@@ -2,21 +2,26 @@ use std::collections::HashMap;
 
 use crate::{
     builtin_functions,
-    vm::{Heap, Pointer},
+    vm::{Heap, Packet, Pointer},
 };
 use num_bigint::RandBigInt;
 use rand::{prelude::ThreadRng, Rng};
 
-pub fn generate_n_values(heap: &mut Heap, n: usize) -> Vec<Pointer> {
+pub fn generate_n_values(n: usize) -> Vec<Packet> {
     let mut values = vec![];
     for _ in 0..n {
-        values.push(generate_value(heap));
+        values.push(generate_value());
     }
     values
 }
 
-fn generate_value(heap: &mut Heap) -> Pointer {
-    generate_value_with_complexity(heap, &mut rand::thread_rng(), 100.0)
+fn generate_value() -> Packet {
+    let mut heap = Heap::default();
+    let value = generate_value_with_complexity(&mut heap, &mut rand::thread_rng(), 100.0);
+    Packet {
+        heap,
+        address: value,
+    }
 }
 fn generate_value_with_complexity(
     heap: &mut Heap,