diff --git a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs b/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
index 10b1ab22a8d..3c867ae48dd 100644
--- a/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/wasm/mod.rs
@@ -45,7 +45,7 @@ pub(crate) struct BackendError(#[from] Error);
 
 impl From<FeatureError> for BackendError {
     fn from(value: FeatureError) -> Self {
-        value.into()
+        BackendError(Error::FromFeature(value))
     }
 }
 
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index ab4358739e9..bd33b5ee8fc 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -256,10 +256,11 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
 #[cfg(test)]
 mod test {
     use acir::brillig::{BlackBoxOp, MemoryAddress};
+    use acvm_blackbox_solver::StubbedBlackBoxSolver;
 
     use crate::{
         black_box::{evaluate_black_box, to_u8_vec, to_value_vec},
-        DummyBlackBoxSolver, HeapArray, HeapVector, Memory,
+        HeapArray, HeapVector, Memory,
     };
 
     #[test]
@@ -280,7 +281,7 @@ mod test {
             output: HeapArray { pointer: 2.into(), size: 32 },
         };
 
-        evaluate_black_box(&op, &DummyBlackBoxSolver, &mut memory).unwrap();
+        evaluate_black_box(&op, &StubbedBlackBoxSolver, &mut memory).unwrap();
 
         let result = memory.read_slice(MemoryAddress(result_pointer), 32);
 
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 0f430b0d5b2..65654e24720 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -16,7 +16,7 @@ use acir::brillig::{
     HeapVector, MemoryAddress, Opcode, ValueOrArray,
 };
 use acir::FieldElement;
-use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
+use acvm_blackbox_solver::BlackBoxFunctionSolver;
 use arithmetic::{evaluate_binary_field_op, evaluate_binary_int_op, BrilligArithmeticError};
 use black_box::evaluate_black_box;
 use num_bigint::BigUint;
@@ -593,59 +593,10 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
     }
 }
 
-pub(crate) struct DummyBlackBoxSolver;
-
-impl BlackBoxFunctionSolver for DummyBlackBoxSolver {
-    fn schnorr_verify(
-        &self,
-        _public_key_x: &FieldElement,
-        _public_key_y: &FieldElement,
-        _signature: &[u8],
-        _message: &[u8],
-    ) -> Result<bool, BlackBoxResolutionError> {
-        Ok(true)
-    }
-    fn pedersen_commitment(
-        &self,
-        _inputs: &[FieldElement],
-        _domain_separator: u32,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        Ok((2_u128.into(), 3_u128.into()))
-    }
-    fn pedersen_hash(
-        &self,
-        _inputs: &[FieldElement],
-        _domain_separator: u32,
-    ) -> Result<FieldElement, BlackBoxResolutionError> {
-        Ok(6_u128.into())
-    }
-    fn fixed_base_scalar_mul(
-        &self,
-        _low: &FieldElement,
-        _high: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        Ok((4_u128.into(), 5_u128.into()))
-    }
-    fn ec_add(
-        &self,
-        _input1_x: &FieldElement,
-        _input1_y: &FieldElement,
-        _input2_x: &FieldElement,
-        _input2_y: &FieldElement,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        Ok((5_u128.into(), 6_u128.into()))
-    }
-    fn poseidon2_permutation(
-        &self,
-        _input: &[FieldElement],
-        len: u32,
-    ) -> Result<Vec<FieldElement>, BlackBoxResolutionError> {
-        Ok(vec![0_u128.into(); len as usize])
-    }
-}
-
 #[cfg(test)]
 mod tests {
+    use acvm_blackbox_solver::StubbedBlackBoxSolver;
+
     use super::*;
 
     #[test]
@@ -662,7 +613,7 @@ mod tests {
 
         // Start VM
         let opcodes = [calldata_copy];
-        let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
 
         // Process a single VM opcode
         //
@@ -706,7 +657,7 @@ mod tests {
         opcodes.push(Opcode::Jump { location: 3 });
         opcodes.push(Opcode::JumpIf { condition: destination, location: 4 });
 
-        let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -763,7 +714,7 @@ mod tests {
             jump_if_not_opcode,
             add_opcode,
         ];
-        let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
@@ -811,7 +762,7 @@ mod tests {
             },
             Opcode::Stop { return_data_offset: 1, return_data_size: 1 },
         ];
-        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -842,7 +793,7 @@ mod tests {
             Opcode::Mov { destination: MemoryAddress::from(2), source: MemoryAddress::from(0) };
 
         let opcodes = &[calldata_copy, mov_opcode];
-        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -898,7 +849,7 @@ mod tests {
                 condition: MemoryAddress(1),
             },
         ];
-        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -981,7 +932,7 @@ mod tests {
             .chain(cast_opcodes)
             .chain([equal_opcode, not_equal_opcode, less_than_opcode, less_than_equal_opcode])
             .collect();
-        let mut vm = VM::new(calldata, &opcodes, vec![], &DummyBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
 
         // Calldata copy
         let status = vm.process_opcode();
@@ -1276,14 +1227,14 @@ mod tests {
     fn brillig_execute_and_get_vm(
         calldata: Vec<FieldElement>,
         opcodes: &[Opcode],
-    ) -> VM<'_, DummyBlackBoxSolver> {
-        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+    ) -> VM<'_, StubbedBlackBoxSolver> {
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
         brillig_execute(&mut vm);
         assert_eq!(vm.call_stack, vec![]);
         vm
     }
 
-    fn brillig_execute(vm: &mut VM<DummyBlackBoxSolver>) {
+    fn brillig_execute(vm: &mut VM<StubbedBlackBoxSolver>) {
         loop {
             let status = vm.process_opcode();
             if matches!(status, VMStatus::Finished { .. } | VMStatus::ForeignCallWait { .. }) {
diff --git a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
index fd538dc578b..1f5681ed470 100644
--- a/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
+++ b/aztec_macros/src/transforms/compute_note_hash_and_nullifier.rs
@@ -127,7 +127,7 @@ pub fn inject_compute_note_hash_and_nullifier(
     Ok(())
 }
 
-fn generate_compute_note_hash_and_nullifier(note_types: &Vec<String>) -> NoirFunction {
+fn generate_compute_note_hash_and_nullifier(note_types: &[String]) -> NoirFunction {
     let function_source = generate_compute_note_hash_and_nullifier_source(note_types);
 
     let (function_ast, errors) = parse_program(&function_source);
@@ -140,7 +140,7 @@ fn generate_compute_note_hash_and_nullifier(note_types: &Vec<String>) -> NoirFun
     function_ast.functions.remove(0)
 }
 
-fn generate_compute_note_hash_and_nullifier_source(note_types: &Vec<String>) -> String {
+fn generate_compute_note_hash_and_nullifier_source(note_types: &[String]) -> String {
     // TODO(#4649): The serialized_note parameter is a fixed-size array, but we don't know what length it should have.
     // For now we hardcode it to 20, which is the same as MAX_NOTE_FIELDS_LENGTH.
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index d10dcf13d9f..90a5d54ae59 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -108,7 +108,7 @@ impl BrilligArtifact {
         self.byte_code.append(&mut byte_code);
 
         // Remove all resolved external calls and transform them to jumps
-        let is_resolved = |label: &Label| self.labels.get(label).is_some();
+        let is_resolved = |label: &Label| self.labels.contains_key(label);
 
         let resolved_external_calls = self
             .unresolved_external_call_labels
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 46b0318d5de..e3dd4c33986 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -2502,16 +2502,13 @@ mod test {
         check_call_opcode(&main_opcodes[0], 1, vec![Witness(0), Witness(1)], vec![Witness(2)]);
         check_call_opcode(&main_opcodes[1], 1, vec![Witness(0), Witness(1)], vec![Witness(3)]);
 
-        match &main_opcodes[2] {
-            Opcode::AssertZero(expr) => {
-                assert_eq!(expr.linear_combinations[0].0, FieldElement::from(1u128));
-                assert_eq!(expr.linear_combinations[0].1, Witness(2));
+        if let Opcode::AssertZero(expr) = &main_opcodes[2] {
+            assert_eq!(expr.linear_combinations[0].0, FieldElement::from(1u128));
+            assert_eq!(expr.linear_combinations[0].1, Witness(2));
 
-                assert_eq!(expr.linear_combinations[1].0, FieldElement::from(-1i128));
-                assert_eq!(expr.linear_combinations[1].1, Witness(3));
-                assert_eq!(expr.q_c, FieldElement::from(0u128));
-            }
-            _ => {}
+            assert_eq!(expr.linear_combinations[1].0, FieldElement::from(-1i128));
+            assert_eq!(expr.linear_combinations[1].1, Witness(3));
+            assert_eq!(expr.q_c, FieldElement::from(0u128));
         }
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/dom.rs b/compiler/noirc_evaluator/src/ssa/ir/dom.rs
index bd1481a7474..15fa3bad38d 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dom.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dom.rs
@@ -249,13 +249,8 @@ mod tests {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            basic_block::BasicBlockId,
-            dfg::CallStack,
-            dom::DominatorTree,
-            function::{Function, InlineType, RuntimeType},
-            instruction::TerminatorInstruction,
-            map::Id,
-            types::Type,
+            basic_block::BasicBlockId, dfg::CallStack, dom::DominatorTree, function::Function,
+            instruction::TerminatorInstruction, map::Id, types::Type,
         },
     };
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
index 5d743e953a5..d95ec451779 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
@@ -73,12 +73,7 @@ impl PostOrder {
 mod tests {
     use crate::ssa::{
         function_builder::FunctionBuilder,
-        ir::{
-            function::{Function, InlineType, RuntimeType},
-            map::Id,
-            post_order::PostOrder,
-            types::Type,
-        },
+        ir::{function::Function, map::Id, post_order::PostOrder, types::Type},
     };
 
     #[test]
diff --git a/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs b/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
index 6d556e86cb5..0409f0e6a49 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/bubble_up_constrains.rs
@@ -77,7 +77,6 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::{InlineType, RuntimeType},
             instruction::{Binary, BinaryOp, Instruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
index 88948331960..6cac8c91bc3 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
@@ -283,7 +283,6 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::{InlineType, RuntimeType},
             instruction::{Binary, BinaryOp, Instruction, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index df89dcb716d..d1b3e1e83f5 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -169,7 +169,6 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, Intrinsic},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index e731a7952a6..07771397ce8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -841,7 +841,7 @@ mod test {
         function_builder::FunctionBuilder,
         ir::{
             dfg::DataFlowGraph,
-            function::{Function, InlineType, RuntimeType},
+            function::Function,
             instruction::{BinaryOp, Instruction, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs
index adb6d2871e5..ce54bb533f7 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs
@@ -114,12 +114,7 @@ mod test {
 
     use crate::ssa::{
         function_builder::FunctionBuilder,
-        ir::{
-            cfg::ControlFlowGraph,
-            function::{InlineType, RuntimeType},
-            map::Id,
-            types::Type,
-        },
+        ir::{cfg::ControlFlowGraph, map::Id, types::Type},
         opt::flatten_cfg::branch_analysis::find_branch_ends,
     };
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 63c78b99cdf..ead3cac071c 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -522,7 +522,7 @@ mod test {
         function_builder::FunctionBuilder,
         ir::{
             basic_block::BasicBlockId,
-            function::{InlineType, RuntimeType},
+            function::InlineType,
             instruction::{BinaryOp, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
index f1a38585bd6..7b87142d824 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
@@ -414,7 +414,6 @@ mod tests {
         ir::{
             basic_block::BasicBlockId,
             dfg::DataFlowGraph,
-            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, Instruction, Intrinsic, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/rc.rs b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
index 7b5196f2004..1561547e32e 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/rc.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
@@ -166,12 +166,8 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            basic_block::BasicBlockId,
-            dfg::DataFlowGraph,
-            function::{InlineType, RuntimeType},
-            instruction::Instruction,
-            map::Id,
-            types::Type,
+            basic_block::BasicBlockId, dfg::DataFlowGraph, function::RuntimeType,
+            instruction::Instruction, map::Id, types::Type,
         },
     };
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
index b9675d99c90..f524b10f1f2 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
@@ -154,7 +154,6 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            function::{InlineType, RuntimeType},
             instruction::{BinaryOp, TerminatorInstruction},
             map::Id,
             types::Type,
diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index 92ec1e8f1bb..8110e3469f1 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -464,12 +464,7 @@ impl<'f> LoopIteration<'f> {
 mod tests {
     use crate::ssa::{
         function_builder::FunctionBuilder,
-        ir::{
-            function::{InlineType, RuntimeType},
-            instruction::BinaryOp,
-            map::Id,
-            types::Type,
-        },
+        ir::{instruction::BinaryOp, map::Id, types::Type},
     };
 
     #[test]
diff --git a/compiler/noirc_frontend/src/lexer/lexer.rs b/compiler/noirc_frontend/src/lexer/lexer.rs
index c4b6bb288dc..cb21f58e58b 100644
--- a/compiler/noirc_frontend/src/lexer/lexer.rs
+++ b/compiler/noirc_frontend/src/lexer/lexer.rs
@@ -1178,7 +1178,7 @@ mod tests {
                                     .as_ref()
                                     .map(|token_discriminator| {
                                         discriminant(token_discriminator)
-                                            == discriminant(&next_token.token())
+                                            == discriminant(next_token.token())
                                     })
                                     .unwrap_or(true);
 
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 7ecff12163a..cdfa16400ae 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -1242,7 +1242,7 @@ where
 mod test {
     use super::test_helpers::*;
     use super::*;
-    use crate::{ArrayLiteral, Literal};
+    use crate::ArrayLiteral;
 
     #[test]
     fn parse_infix() {
diff --git a/compiler/noirc_frontend/src/parser/parser/literals.rs b/compiler/noirc_frontend/src/parser/parser/literals.rs
index 32f4f03de2e..83d7b832d27 100644
--- a/compiler/noirc_frontend/src/parser/parser/literals.rs
+++ b/compiler/noirc_frontend/src/parser/parser/literals.rs
@@ -105,6 +105,7 @@ mod test {
             Case { source: r#" r#"foo" "#, expect: "(none)", errors: 2 },
             // empty string
             Case { source: r#"r"""#, expect: r#"r"""#, errors: 0 },
+            #[allow(clippy::needless_raw_string_hashes)]
             Case { source: r####"r###""###"####, expect: r####"r###""###"####, errors: 0 },
             // miscellaneous
             Case { source: r##" r#\"foo\"# "##, expect: "plain::r", errors: 2 },
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index ba12a20460d..1acd581b2be 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -128,9 +128,7 @@ impl<'a, B: BlackBoxFunctionSolver> DebugContext<'a, B> {
         line: i64,
     ) -> Option<OpcodeLocation> {
         let line = line as usize;
-        let Some(line_to_opcodes) = self.source_to_opcodes.get(file_id) else {
-            return None;
-        };
+        let line_to_opcodes = self.source_to_opcodes.get(file_id)?;
         let found_index = match line_to_opcodes.binary_search_by(|x| x.0.cmp(&line)) {
             Ok(index) => {
                 // move backwards to find the first opcode which matches the line
@@ -631,7 +629,6 @@ fn build_source_to_opcode_debug_mappings(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::context::{DebugCommandResult, DebugContext};
 
     use crate::foreign_calls::DefaultDebugForeignCallExecutor;
     use acvm::{
@@ -647,8 +644,6 @@ mod tests {
             BinaryFieldOp, HeapValueType, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray,
         },
     };
-    use nargo::artifacts::debug::DebugArtifact;
-    use std::collections::BTreeMap;
 
     #[test]
     fn test_resolve_foreign_calls_stepping_into_brillig() {
diff --git a/tooling/debugger/src/foreign_calls.rs b/tooling/debugger/src/foreign_calls.rs
index aae2212fd54..f11ac22cd75 100644
--- a/tooling/debugger/src/foreign_calls.rs
+++ b/tooling/debugger/src/foreign_calls.rs
@@ -65,7 +65,7 @@ impl DefaultDebugForeignCallExecutor {
     pub fn load_artifact(&mut self, artifact: &DebugArtifact) {
         // TODO: handle loading from the correct DebugInfo when we support
         // debugging contracts
-        let Some(info) = artifact.debug_symbols.get(0) else {
+        let Some(info) = artifact.debug_symbols.first() else {
             return;
         };
         self.debug_vars.insert_debug_info(info);
diff --git a/tooling/nargo/src/artifacts/debug_vars.rs b/tooling/nargo/src/artifacts/debug_vars.rs
index 8e5c2bc46a4..6a42a4c3311 100644
--- a/tooling/nargo/src/artifacts/debug_vars.rs
+++ b/tooling/nargo/src/artifacts/debug_vars.rs
@@ -36,9 +36,7 @@ impl DebugVars {
 
     fn lookup_var(&self, var_id: DebugVarId) -> Option<(&str, &PrintableType)> {
         self.variables.get(&var_id).and_then(|debug_var| {
-            let Some(ptype) = self.types.get(&debug_var.debug_type_id) else {
-                return None;
-            };
+            let ptype = self.types.get(&debug_var.debug_type_id)?;
             Some((debug_var.name.as_str(), ptype))
         })
     }
diff --git a/tooling/nargo_fmt/build.rs b/tooling/nargo_fmt/build.rs
index c356b403ae5..6f41768c1dc 100644
--- a/tooling/nargo_fmt/build.rs
+++ b/tooling/nargo_fmt/build.rs
@@ -58,10 +58,10 @@ fn format_{test_name}() {{
     let expected_output = r#"{output_source}"#;
 
 
-    let (parsed_module, _errors) = noirc_frontend::parse_program(&input);
+    let (parsed_module, _errors) = noirc_frontend::parse_program(input);
 
     let config = nargo_fmt::Config::of("{config}").unwrap();
-    let fmt_text = nargo_fmt::format(&input, parsed_module, &config);
+    let fmt_text = nargo_fmt::format(input, parsed_module, &config);
 
     if std::env::var("UPDATE_EXPECT").is_ok() {{
         std::fs::write("{output_source_path}", fmt_text.clone()).unwrap();