feat(fuzz): AST function body

compiler/noirc_frontend/src/ast/expression.rs

@@ -302,8 +302,7 @@ impl Expression {
 
 pub type BinaryOp = Located<BinaryOpKind>;
 
-#[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Debug, Copy, Clone)]
-#[cfg_attr(test, derive(strum_macros::EnumIter))]
+#[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Debug, Copy, Clone, strum_macros::EnumIter)]
 pub enum BinaryOpKind {
     Add,
     Subtract,
@@ -339,6 +338,24 @@ impl BinaryOpKind {
         )
     }
 
+    pub fn is_arithmetic(self) -> bool {
+        matches!(
+            self,
+            BinaryOpKind::Add
+                | BinaryOpKind::Subtract
+                | BinaryOpKind::Multiply
+                | BinaryOpKind::Divide
+        )
+    }
+
+    pub fn is_bitwise(self) -> bool {
+        matches!(self, BinaryOpKind::And | BinaryOpKind::Or | BinaryOpKind::Xor)
+    }
+
+    pub fn is_bitshift(self) -> bool {
+        matches!(self, BinaryOpKind::ShiftLeft | BinaryOpKind::ShiftRight)
+    }
+
     pub fn is_valid_for_field_type(self) -> bool {
         matches!(
             self,

compiler/noirc_frontend/src/ast/mod.rs

@@ -91,6 +91,7 @@ impl From<IntegerBitSize> for u32 {
     }
 }
 
+#[derive(Debug)]
 pub struct InvalidIntegerBitSizeError(pub u32);
 
 impl TryFrom<u32> for IntegerBitSize {

compiler/noirc_frontend/src/monomorphization/printer.rs

@@ -33,8 +33,12 @@ impl AstPrinter {
 
         write!(
             f,
-            "fn {}$f{}({}) -> {} {{",
-            function.name, function.id, params, function.return_type
+            "{}fn {}$f{}({}) -> {} {{",
+            if function.unconstrained { "unconstrained " } else { "" },
+            function.name,
+            function.id,
+            params,
+            function.return_type
         )?;
         self.indent_level += 1;
         self.print_expr_expect_block(&function.body, f)?;
@@ -75,7 +79,13 @@ impl AstPrinter {
             }
             Expression::Call(call) => self.print_call(call, f),
             Expression::Let(let_expr) => {
-                write!(f, "let {}${} = ", let_expr.name, let_expr.id.0)?;
+                write!(
+                    f,
+                    "let {}{}${} = ",
+                    if let_expr.mutable { "mut " } else { "" },
+                    let_expr.name,
+                    let_expr.id.0
+                )?;
                 self.print_expr(&let_expr.expression, f)
             }
             Expression::Constrain(expr, ..) => {

cspell.json

@@ -26,6 +26,7 @@
         "bindgen",
         "bitand",
         "bitmask",
+        "bitshift",
         "bitsize",
         "blackbox",
         "boilerplate",
@@ -108,6 +109,7 @@
         "foralls",
         "formatcp",
         "fpath",
+        "freqs",
         "frontends",
         "fuzzer",
         "fxhash",

test_programs/execution_success/loop/src/main.nr

@@ -5,6 +5,7 @@ fn main(six_as_u32: u32) {
     assert_eq(loop_excl(4), six_as_u32);
     assert_eq(loop_incl(3), six_as_u32);
     assert(plain_loop() == six_as_u32);
+    assert(never_loop() == 0);
 }
 
 fn loop_excl(x: u32) -> u32 {
@@ -30,3 +31,11 @@ fn plain_loop() -> u32 {
     }
     sum
 }
+
+fn never_loop() -> u32 {
+    let mut sum = 0;
+    for i in 4..0 {
+        sum = sum + i;
+    }
+    sum
+}

tooling/ast_fuzzer/src/lib.rs

@@ -6,6 +6,7 @@ mod program;
 pub use abi::program_abi;
 pub use input::arb_inputs;
 pub use program::arb_program;
+use program::freq::Freqs;
 
 /// AST generation configuration.
 #[derive(Debug, Clone)]
@@ -16,23 +17,48 @@ pub struct Config {
     pub max_functions: usize,
     /// Maximum number of arguments a function can have.
     pub max_function_args: usize,
+    /// Maximum number of statements to aim for in a function body.
+    pub max_function_size: usize,
+    /// Maximum number of statements in a block.
+    pub max_block_size: usize,
     /// Maximum nesting depth for complex expressions.
     pub max_depth: usize,
     /// Maximum number of fields for tuples.
     pub max_tuple_size: usize,
     /// Maximum size for arrays.
     pub max_array_size: usize,
+    /// Maximum size of for loop ranges, which affects unrolling in ACIR.
+    pub max_range_size: usize,
+    /// Frequency of expressions that produce a value.
+    pub expr_freqs: Freqs,
+    /// Frequency of statements that don't produce a value.
+    pub stmt_freqs: Freqs,
 }
 
 impl Default for Config {
     fn default() -> Self {
+        let expr_freqs = Freqs::new(&[
+            ("unary", 5),
+            ("binary", 20),
+            ("if", 15),
+            ("block", 30),
+            ("vars", 20),
+            ("literal", 5),
+        ]);
+        let stmt_freqs =
+            Freqs::new(&[("drop", 5), ("assign", 30), ("if", 10), ("for", 20), ("let", 20)]);
         Self {
             max_globals: 3,
             max_functions: 5,
             max_function_args: 3,
+            max_function_size: 25,
+            max_block_size: 5,
             max_depth: 2,
-            max_tuple_size: 4,
-            max_array_size: 8,
+            max_tuple_size: 5,
+            max_array_size: 4,
+            max_range_size: 10,
+            expr_freqs,
+            stmt_freqs,
         }
     }
 }