Add fuzzing to the CI

.github/workflows/compiler.yaml

@@ -67,3 +67,18 @@ jobs:
         with:
           command: clippy
           args: --manifest-path compiler/Cargo.toml -- -D warnings
+
+  # fuzzing:
+  #   name: Fuzzing
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - uses: actions/checkout@v3
+  #     - uses: actions-rs/toolchain@v1
+  #       with:
+  #         profile: minimal
+  #         toolchain: ${{ env.RUST_VERSION }}
+  #         override: true
+  #     - uses: actions-rs/cargo@v1
+  #       with:
+  #         command: run
+  #         args: --manifest-path compiler/Cargo.toml -- fuzz packages/Benchmark.candy

compiler/src/fuzzer/fuzzer.rs

@@ -79,6 +79,9 @@ impl Fuzzer {
     pub fn status(&self) -> &Status {
         self.status.as_ref().unwrap()
     }
+    pub fn into_status(self) -> Status {
+        self.status.unwrap()
+    }
 
     pub fn run<U: UseProvider, E: ExecutionController>(
         &mut self,

compiler/src/fuzzer/mod.rs

@@ -12,13 +12,14 @@ use crate::{
     module::Module,
     vm::{
         context::{DbUseProvider, RunForever, RunLimitedNumberOfInstructions},
-        Closure, Heap, Pointer, Vm,
+        tracer::full::FullTracer,
+        Closure, Heap, Packet, Pointer, Vm,
     },
 };
 use itertools::Itertools;
 use tracing::{error, info};
 
-pub async fn fuzz(db: &Database, module: Module) {
+pub async fn fuzz(db: &Database, module: Module) -> Vec<FailingFuzzCase> {
     let (fuzzables_heap, fuzzables): (Heap, Vec<(Id, Pointer)>) = {
         let mut tracer = FuzzablesFinder::default();
         let mut vm = Vm::new();
@@ -32,30 +33,59 @@ pub async fn fuzz(db: &Database, module: Module) {
         fuzzables.len()
     );
 
+    let mut failing_cases = vec![];
+
     for (id, closure) in fuzzables {
         info!("Fuzzing {id}.");
         let mut fuzzer = Fuzzer::new(&fuzzables_heap, closure, id.clone());
         fuzzer.run(
             &mut DbUseProvider { db },
             &mut RunLimitedNumberOfInstructions::new(1000),
         );
-        match fuzzer.status() {
+        match fuzzer.into_status() {
             Status::StillFuzzing { .. } => {}
             Status::PanickedForArguments {
                 arguments,
                 reason,
                 tracer,
             } => {
                 error!("The fuzzer discovered an input that crashes {id}:");
-                error!(
-                    "Calling `{id} {}` doesn't work because {reason}.",
-                    arguments.iter().map(|arg| format!("{arg:?}")).join(" "),
-                );
-                error!(
-                    "This is the stack trace:\n{}",
-                    tracer.format_panic_stack_trace_to_root_fiber(db)
-                );
+                let case = FailingFuzzCase {
+                    closure: id,
+                    arguments,
+                    reason,
+                    tracer,
+                };
+                case.dump(db);
+                failing_cases.push(case);
             }
         }
     }
+
+    failing_cases
+}
+
+pub struct FailingFuzzCase {
+    closure: Id,
+    arguments: Vec<Packet>,
+    reason: String,
+    tracer: FullTracer,
+}
+
+impl FailingFuzzCase {
+    pub fn dump(&self, db: &Database) {
+        error!(
+            "Calling `{} {}` doesn't work because {}.",
+            self.closure,
+            self.arguments
+                .iter()
+                .map(|arg| format!("{arg:?}"))
+                .join(" "),
+            self.reason,
+        );
+        error!(
+            "This is the stack trace:\n{}",
+            self.tracer.format_panic_stack_trace_to_root_fiber(db)
+        );
+    }
 }

compiler/src/main.rs

@@ -87,7 +87,7 @@ struct CandyFuzzOptions {
 }
 
 #[tokio::main]
-async fn main() {
+async fn main() -> ProgramResult {
     init_logger();
     match CandyOptions::from_args() {
         CandyOptions::Build(options) => build(options),
@@ -97,15 +97,25 @@ async fn main() {
     }
 }
 
-fn build(options: CandyBuildOptions) {
+type ProgramResult = Result<(), Exit>;
+#[derive(Debug)]
+enum Exit {
+    FileNotFound,
+    FuzzingFoundFailingCases,
+    CodePanicked,
+}
+
+fn build(options: CandyBuildOptions) -> ProgramResult {
     let module = Module::from_package_root_and_file(
         current_dir().unwrap(),
         options.file.clone(),
         ModuleKind::Code,
     );
-    raw_build(module.clone(), options.debug);
+    let result = raw_build(module.clone(), options.debug);
 
-    if options.watch {
+    if !options.watch {
+        result.ok_or(Exit::FileNotFound).map(|_| ())
+    } else {
         let (tx, rx) = channel();
         let mut watcher = watcher(tx, Duration::from_secs(1)).unwrap();
         watcher
@@ -192,7 +202,7 @@ fn raw_build(module: Module, debug: bool) -> Option<Arc<Lir>> {
     Some(lir)
 }
 
-fn run(options: CandyRunOptions) {
+fn run(options: CandyRunOptions) -> ProgramResult {
     let module = Module::from_package_root_and_file(
         current_dir().unwrap(),
         options.file.clone(),
@@ -201,8 +211,8 @@ fn run(options: CandyRunOptions) {
     let db = Database::default();
 
     if raw_build(module.clone(), false).is_none() {
-        warn!("Build failed.");
-        return;
+        warn!("File not found.");
+        return Err(Exit::FileNotFound);
     };
     // TODO: Optimize the code before running.
 
@@ -251,7 +261,7 @@ fn run(options: CandyRunOptions) {
                 "This is the stack trace:\n{}",
                 tracer.format_panic_stack_trace_to_root_fiber(&db)
             );
-            return;
+            return Err(Exit::CodePanicked);
         }
     };
 
@@ -260,7 +270,7 @@ fn run(options: CandyRunOptions) {
         Some(main) => main,
         None => {
             error!("The module doesn't contain a main function.");
-            return;
+            return Err(Exit::CodePanicked);
         }
     };
 
@@ -302,6 +312,7 @@ fn run(options: CandyRunOptions) {
                 .for_fiber(FiberId::root())
                 .call_ended(return_value.address, &return_value.heap);
             debug!("The main function returned: {return_value:?}");
+            Ok(())
         }
         ExecutionResult::Panicked {
             reason,
@@ -317,6 +328,7 @@ fn run(options: CandyRunOptions) {
                 "This is the stack trace:\n{}",
                 tracer.format_panic_stack_trace_to_root_fiber(&db)
             );
+            Err(Exit::CodePanicked)
         }
     }
 }
@@ -346,29 +358,44 @@ impl StdoutService {
     }
 }
 
-async fn fuzz(options: CandyFuzzOptions) {
+async fn fuzz(options: CandyFuzzOptions) -> ProgramResult {
     let module = Module::from_package_root_and_file(
         current_dir().unwrap(),
         options.file.clone(),
         ModuleKind::Code,
     );
 
     if raw_build(module.clone(), false).is_none() {
-        warn!("Build failed.");
-        return;
+        warn!("File not found.");
+        return Err(Exit::FileNotFound);
     }
 
     debug!("Fuzzing `{module}`.");
     let db = Database::default();
-    fuzzer::fuzz(&db, module).await;
+    let failing_cases = fuzzer::fuzz(&db, module).await;
+
+    if failing_cases.is_empty() {
+        info!("All found fuzzable closures seem fine.");
+        Ok(())
+    } else {
+        error!("");
+        error!("Finished fuzzing.");
+        error!("These are the failing cases:");
+        for case in failing_cases {
+            error!("");
+            case.dump(&db);
+        }
+        Err(Exit::FuzzingFoundFailingCases)
+    }
 }
 
-async fn lsp() {
+async fn lsp() -> ProgramResult {
     info!("Starting language server…");
     let (service, socket) = LspService::new(CandyLanguageServer::from_client);
     Server::new(tokio::io::stdin(), tokio::io::stdout(), socket)
         .serve(service)
         .await;
+    Ok(())
 }
 
 fn init_logger() {

compiler/src/vm/mod.rs

@@ -12,6 +12,7 @@ pub use self::{
     fiber::{ExecutionResult, Fiber},
     heap::{Closure, Heap, Object, Pointer, Struct},
     ids::{ChannelId, FiberId, OperationId},
+    tracer::{full::FullTracer, Tracer},
 };
 use self::{
     channel::{Channel, Completer, Performer},
@@ -21,7 +22,6 @@ use self::{
     },
     heap::SendPort,
     ids::{CountableId, IdGenerator},
-    tracer::Tracer,
 };
 use crate::compiler::hir::Id;
 use itertools::Itertools;

packages/Benchmark.candy

@@ -3,27 +3,22 @@
 
 core = use "..Core"
 
-fibRec fibRec n =
+fibRec = { fibRec n ->
   core.ifElse (core.int.isLessThan n 2) { n } {
     core.int.add
       fibRec fibRec (core.int.subtract n 1)
       fibRec fibRec (core.int.subtract n 2)
   }
-fib n = fibRec fibRec n
+}
+fib n =
+  needs (core.int.is n)
+  fibRec fibRec n
 twentyOne := fib 8
 
 main := { environment ->
-  print message = { core.channel.send environment.stdout message }
-  print "Hello, world!"
-
-  core.parallel { nursery ->
-    print (core.await (core.async nursery {
-      print "Hello from fiber!"
-      "Hello, async await!"
-    }))
+  print message =
+    needs (core.text.is message)
+    core.channel.send environment.stdout message
 
-    core.async nursery { print "Kiwi" }
-    core.async nursery { print "Banana" }
-    print "Hi"
-  }
+  print "Hello, world!"
 }

packages/Core/channel.candy

@@ -1,14 +1,19 @@
 bool = use "..bool"
 equals = (use "..equality").equals
 if = (use "..conditionals").if
-isInt = (use "..int").is
+int = use "..int"
 isType = (use "..type").is
 
 isSendPort value := isType value SendPort
 isReceivePort value := isType value ReceivePort
 
 create capacity :=
-  needs (isInt capacity) "`capacity` is not an integer. Channels need a capacity because otherwise, there would be no backpressure among fibers, and memory leaks would go unnoticed."
+  needs (int.is capacity) "`capacity` is not an integer. Channels need a capacity because otherwise, there would be no backpressure among fibers, and memory leaks would go unnoticed."
+  needs (int.isNonNegative capacity)
+  needs (int.fitsInRustU32 capacity)
+  # Technically, it needs to fit in a usize, the natural word length on systems.
+  # Typically, this is 64-bits, so we are conservative here, although there
+  # also exist exotic/old systems with smaller word sizes of 16 bits.
   ✨.channelCreate capacity
 
 send port packet :=

packages/Core/int.candy

@@ -73,6 +73,13 @@ absolute value :=
   needs (is value)
   conditionals.ifElse (isNegative value) (negate value) value
 
+fitsInRustU32 value :=
+  needs (is value)
+  needs (isNonNegative value)  "you gave `fitsInRustU128` a signed int"
+
+  rustU32Max = 4294967295
+  # https://doc.rust-lang.org/std/primitive.u32.html#associatedconstant.MAX
+  isLessThan value rustU32Max
 fitsInRustU128 value =
   needs (is value)
   needs (isNonNegative value)