chore: remove foreign calls array from Brillig VM constructor

acvm-repo/acvm/src/pwg/brillig.rs

@@ -133,7 +133,7 @@ impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
 
         // Instantiate a Brillig VM given the solved calldata
         // along with the Brillig bytecode.
-        let vm = VM::new(calldata, brillig_bytecode, vec![], bb_solver, profiling_active);
+        let vm = VM::new(calldata, brillig_bytecode, bb_solver, profiling_active);
         Ok(vm)
     }
 

acvm-repo/brillig_vm/src/lib.rs

@@ -107,7 +107,6 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
     pub fn new(
         calldata: Vec<F>,
         bytecode: &'a [Opcode<F>],
-        foreign_call_results: Vec<ForeignCallResult<F>>,
         black_box_solver: &'a B,
         profiling_active: bool,
     ) -> Self {
@@ -117,7 +116,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
             calldata,
             program_counter: 0,
             foreign_call_counter: 0,
-            foreign_call_results,
+            foreign_call_results: Vec::new(),
             bytecode,
             status: VMStatus::InProgress,
             memory: Memory::default(),
@@ -857,7 +856,7 @@ mod tests {
 
         // Start VM
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(calldata, &opcodes, vec![], &solver, false);
+        let mut vm = VM::new(calldata, &opcodes, &solver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
@@ -908,7 +907,7 @@ mod tests {
         ];
 
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(calldata, &opcodes, vec![], &solver, false);
+        let mut vm = VM::new(calldata, &opcodes, &solver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -977,7 +976,7 @@ mod tests {
         ];
 
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(calldata, &opcodes, vec![], &solver, false);
+        let mut vm = VM::new(calldata, &opcodes, &solver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1050,7 +1049,7 @@ mod tests {
             },
         ];
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(calldata, opcodes, vec![], &solver, false);
+        let mut vm = VM::new(calldata, opcodes, &solver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1111,7 +1110,7 @@ mod tests {
             },
         ];
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(calldata, opcodes, vec![], &solver, false);
+        let mut vm = VM::new(calldata, opcodes, &solver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1158,7 +1157,7 @@ mod tests {
             Opcode::Mov { destination: MemoryAddress::direct(2), source: MemoryAddress::direct(0) },
         ];
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(calldata, opcodes, vec![], &solver, false);
+        let mut vm = VM::new(calldata, opcodes, &solver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1224,7 +1223,7 @@ mod tests {
             },
         ];
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(calldata, opcodes, vec![], &solver, false);
+        let mut vm = VM::new(calldata, opcodes, &solver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1321,7 +1320,7 @@ mod tests {
             .chain([equal_opcode, not_equal_opcode, less_than_opcode, less_than_equal_opcode])
             .collect();
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(calldata, &opcodes, vec![], &solver, false);
+        let mut vm = VM::new(calldata, &opcodes, &solver, false);
 
         // Calldata copy
         let status = vm.process_opcode();
@@ -1451,7 +1450,7 @@ mod tests {
             },
         ];
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(vec![], opcodes, vec![], &solver, false);
+        let mut vm = VM::new(vec![], opcodes, &solver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1678,7 +1677,7 @@ mod tests {
         opcodes: &'a [Opcode<F>],
         solver: &'a StubbedBlackBoxSolver,
     ) -> VM<'a, F, StubbedBlackBoxSolver> {
-        let mut vm = VM::new(calldata, opcodes, vec![], solver, false);
+        let mut vm = VM::new(calldata, opcodes, solver, false);
         brillig_execute(&mut vm);
         assert_eq!(vm.call_stack, vec![]);
         vm
@@ -2366,7 +2365,7 @@ mod tests {
         ];
 
         let solver = StubbedBlackBoxSolver::default();
-        let mut vm = VM::new(calldata, &opcodes, vec![], &solver, false);
+        let mut vm = VM::new(calldata, &opcodes, &solver, false);
 
         vm.process_opcode();
         vm.process_opcode();

compiler/noirc_evaluator/src/acir/brillig_call.rs

@@ -311,7 +311,7 @@ fn execute_brillig<F: AcirField, B: BlackBoxFunctionSolver<F>>(
 
     // Instantiate a Brillig VM given the solved input registers and memory, along with the Brillig bytecode.
     let profiling_active = false;
-    let mut vm = VM::new(calldata, code, Vec::new(), blackbox_solver, profiling_active);
+    let mut vm = VM::new(calldata, code, blackbox_solver, profiling_active);
 
     // Run the Brillig VM on these inputs, bytecode, etc!
     let vm_status = vm.process_opcodes();

compiler/noirc_evaluator/src/brillig/brillig_ir.rs

@@ -353,7 +353,7 @@ pub(crate) mod tests {
         bytecode: &[BrilligOpcode<FieldElement>],
     ) -> (VM<'_, FieldElement, DummyBlackBoxSolver>, usize, usize) {
         let profiling_active = false;
-        let mut vm = VM::new(calldata, bytecode, vec![], &DummyBlackBoxSolver, profiling_active);
+        let mut vm = VM::new(calldata, bytecode, &DummyBlackBoxSolver, profiling_active);
 
         let status = vm.process_opcodes();
         if let VMStatus::Finished { return_data_offset, return_data_size } = status {
@@ -427,15 +427,22 @@ pub(crate) mod tests {
         });
 
         let bytecode: Vec<BrilligOpcode<FieldElement>> = context.artifact().finish().byte_code;
+
+        let mut vm = VM::new(vec![], &bytecode, &DummyBlackBoxSolver, false);
+        let status = vm.process_opcodes();
+        assert_eq!(
+            status,
+            VMStatus::ForeignCallWait {
+                function: "make_number_sequence".to_string(),
+                inputs: vec![ForeignCallParam::Single(FieldElement::from(12u128))]
+            }
+        );
+
         let number_sequence: Vec<FieldElement> =
             (0_usize..12_usize).map(FieldElement::from).collect();
-        let mut vm = VM::new(
-            vec![],
-            &bytecode,
-            vec![ForeignCallResult { values: vec![ForeignCallParam::Array(number_sequence)] }],
-            &DummyBlackBoxSolver,
-            false,
-        );
+        let response = ForeignCallResult { values: vec![ForeignCallParam::Array(number_sequence)] };
+        vm.resolve_foreign_call(response);
+
         let status = vm.process_opcodes();
         assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
     }

compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs

@@ -600,12 +600,10 @@ impl<'brillig> Context<'brillig> {
         }
 
         let bytecode = &generated_brillig.byte_code;
-        let foreign_call_results = Vec::new();
         let pedantic_solving = true;
         let black_box_solver = Bn254BlackBoxSolver(pedantic_solving);
         let profiling_active = false;
-        let mut vm =
-            VM::new(calldata, bytecode, foreign_call_results, &black_box_solver, profiling_active);
+        let mut vm = VM::new(calldata, bytecode, &black_box_solver, profiling_active);
         let vm_status: VMStatus<_> = vm.process_opcodes();
         let VMStatus::Finished { return_data_offset, return_data_size } = vm_status else {
             return EvaluationResult::CannotEvaluate;