chore: Change AST fuzzer recursion limit

tooling/ast_fuzzer/src/lib.rs

@@ -30,8 +30,10 @@ pub struct Config {
     pub max_array_size: usize,
     /// Maximum size of for loop ranges, which affects unrolling in ACIR.
     pub max_loop_size: usize,
-    /// Maximum call depth for recursive calls.
-    pub max_call_depth: usize,
+    /// Whether to choose the backstop for `loop` and `while` randomly.
+    pub vary_loop_size: bool,
+    /// Maximum number of recursive calls to make at runtime.
+    pub max_recursive_calls: usize,
     /// Frequency of expressions, which produce a value.
     pub expr_freqs: Freqs,
     /// Frequency of statements in ACIR functions.
@@ -81,7 +83,8 @@ impl Default for Config {
             max_tuple_size: 5,
             max_array_size: 4,
             max_loop_size: 10,
-            max_call_depth: 5,
+            vary_loop_size: true,
+            max_recursive_calls: 25,
             expr_freqs,
             stmt_freqs_acir,
             stmt_freqs_brillig,

tooling/ast_fuzzer/src/program/expr.rs

@@ -277,10 +277,18 @@ pub(crate) fn if_else(
 }
 
 /// Assign a value to an identifier.
-pub(crate) fn assign(ident: Ident, expr: Expression) -> Expression {
+pub(crate) fn assign_ident(ident: Ident, expr: Expression) -> Expression {
     Expression::Assign(Assign { lvalue: LValue::Ident(ident), expression: Box::new(expr) })
 }
 
+/// Assign a value to a mutable reference.
+pub(crate) fn assign_ref(ident: Ident, expr: Expression) -> Expression {
+    let typ = ident.typ.clone();
+    let lvalue = LValue::Ident(ident);
+    let lvalue = LValue::Dereference { reference: Box::new(lvalue), element_type: typ };
+    Expression::Assign(Assign { lvalue, expression: Box::new(expr) })
+}
+
 /// Cast an expression to a target type.
 pub(crate) fn cast(lhs: Expression, tgt_type: Type) -> Expression {
     Expression::Cast(Cast { lhs: Box::new(lhs), r#type: tgt_type, location: Location::dummy() })
@@ -312,6 +320,11 @@ pub(crate) fn deref(rhs: Expression, tgt_type: Type) -> Expression {
     unary(UnaryOp::Dereference { implicitly_added: false }, rhs, tgt_type)
 }
 
+/// Reference an expression as a target type
+pub(crate) fn ref_mut(rhs: Expression, tgt_type: Type) -> Expression {
+    unary(UnaryOp::Reference { mutable: true }, rhs, tgt_type)
+}
+
 /// Make a unary expression.
 pub(crate) fn unary(op: UnaryOp, rhs: Expression, tgt_type: Type) -> Expression {
     Expression::Unary(Unary {

tooling/ast_fuzzer/src/program/func.rs

@@ -931,19 +931,16 @@
         // Increment the index in the beginning of the body.
         expr::prepend(
             &mut loop_body,
-            expr::assign(
+            expr::assign_ident(
                 idx_ident,
                 expr::binary(idx_expr.clone(), BinaryOp::Add, expr::u32_literal(1)),
             ),
         );
 
         // Put everything into if/else
+        let max_loop_size = self.gen_loop_size(u)?;
         let loop_body = expr::if_else(
-            expr::binary(
-                idx_expr,
-                BinaryOp::Equal,
-                expr::u32_literal(self.ctx.config.max_loop_size as u32),
-            ),
+            expr::binary(idx_expr, BinaryOp::Equal, expr::u32_literal(max_loop_size as u32)),
             Expression::Break,
             loop_body,
             Type::Unit,
@@ -985,19 +982,16 @@
         // Increment the index in the beginning of the body.
         expr::prepend(
             &mut loop_body,
-            expr::assign(
+            expr::assign_ident(
                 idx_ident,
                 expr::binary(idx_expr.clone(), BinaryOp::Add, expr::u32_literal(1)),
             ),
         );
 
         // Put everything into if/else
+        let max_loop_size = self.gen_loop_size(u)?;
         let inner_block = Expression::Block(vec![expr::if_else(
-            expr::binary(
-                idx_expr,
-                BinaryOp::Equal,
-                expr::u32_literal(self.ctx.config.max_loop_size as u32),
-            ),
+            expr::binary(idx_expr, BinaryOp::Equal, expr::u32_literal(max_loop_size as u32)),
             Expression::Break,
             loop_body,
             Type::Unit,
@@ -1013,17 +1007,26 @@
 
         Ok(Expression::Block(stmts))
     }
+
+    fn gen_loop_size(&self, u: &mut Unstructured) -> arbitrary::Result<usize> {
+        if self.ctx.config.vary_loop_size {
+            u.choose_index(self.ctx.config.max_loop_size)
+        } else {
+            Ok(self.ctx.config.max_loop_size)
+        }
+    }
 }
 
 #[test]
 fn test_loop() {
     let mut u = Unstructured::new(&[0u8; 1]);
     let mut ctx = Context::default();
     ctx.config.max_loop_size = 10;
-    ctx.add_main_decl(&mut u);
+    ctx.config.vary_loop_size = false;
+    ctx.gen_main_decl(&mut u);
     let mut fctx = FunctionContext::new(&mut ctx, FuncId(0));
     fctx.budget = 2;
     let loop_code = format!("{}", fctx.gen_loop(&mut u).unwrap()).replace(" ", "");
 
     println!("{loop_code}");
     assert!(
@@ -1045,9 +1048,10 @@
     let mut u = Unstructured::new(&[0u8; 1]);
     let mut ctx = Context::default();
     ctx.config.max_loop_size = 10;
-    ctx.add_main_decl(&mut u);
+    ctx.config.vary_loop_size = false;
+    ctx.gen_main_decl(&mut u);
     let mut fctx = FunctionContext::new(&mut ctx, FuncId(0));
     fctx.budget = 2;
     let while_code = format!("{}", fctx.gen_while(&mut u).unwrap()).replace(" ", "");
 
     println!("{while_code}");

tooling/ast_fuzzer/src/program/mod.rs

@@ -180,7 +180,7 @@ impl Context {
 
     /// Generate and add main (for testing)
     #[cfg(test)]
-    fn add_main_decl(&mut self, u: &mut Unstructured) {
+    fn gen_main_decl(&mut self, u: &mut Unstructured) {
         let d = self.gen_function_decl(u, 0).unwrap();
         self.function_declarations.insert(FuncId(0u32), d);
     }
@@ -208,7 +208,7 @@ impl Context {
 
     /// As a post-processing step, identify recursive functions and add a call depth parameter to them.
     fn rewrite_functions(&mut self, u: &mut Unstructured) -> arbitrary::Result<()> {
-        rewrite::add_recursion_depth(self, u)
+        rewrite::add_recursion_limit(self, u)
     }
 
     /// Return the generated [Program].