unsilence unused_variables warning and fix occurrences

Author: Robbepop

crates/wasmi/src/engine/translator/func2/layout/mod.rs

@@ -34,7 +34,7 @@ impl StackLayout {
     /// # Errors
     ///
     /// If too many local variables are being registered.
-    pub fn register_locals(&mut self, amount: u32, ty: ValType) -> Result<(), Error> {
+    pub fn register_locals(&mut self, amount: u32, _ty: ValType) -> Result<(), Error> {
         self.len_locals += amount as usize;
         Ok(())
     }

crates/wasmi/src/engine/translator/func2/mod.rs

@@ -1,4 +1,4 @@
-#![expect(dead_code, unused_imports, unused_variables)]
+#![expect(dead_code, unused_imports)]
 
 #[macro_use]
 mod utils;
@@ -250,7 +250,7 @@ impl FuncTranslator {
 
     /// Translates the end of the Wasm function enclosing Wasm `block`.
     fn translate_end_func(&mut self, frame: BlockControlFrame) -> Result<(), Error> {
-        let fuel_info = match (&self.fuel_costs, frame.consume_fuel_instr()) {
+        let _fuel_info = match (&self.fuel_costs, frame.consume_fuel_instr()) {
             (Some(fuel_costs), Some(consume_fuel)) => {
                 FuelInfo::some(fuel_costs.clone(), consume_fuel)
             }
@@ -351,7 +351,7 @@ impl FuncTranslator {
                 };
                 self.instrs.push_instr(instr);
             }
-            n => {
+            _ => {
                 let height = frame.height();
                 let result = self.layout.temp_to_reg(OperandIdx::from(height - 1))?;
                 let values = BoundedRegSpan::new(RegSpan::new(result), len_results);
@@ -362,22 +362,22 @@ impl FuncTranslator {
     }
 
     /// Translates the end of a Wasm `loop` control frame.
-    fn translate_end_loop(&mut self, frame: LoopControlFrame) -> Result<(), Error> {
+    fn translate_end_loop(&mut self, _frame: LoopControlFrame) -> Result<(), Error> {
         todo!()
     }
 
     /// Translates the end of a Wasm `if` control frame.
-    fn translate_end_if(&mut self, frame: IfControlFrame) -> Result<(), Error> {
+    fn translate_end_if(&mut self, _frame: IfControlFrame) -> Result<(), Error> {
         todo!()
     }
 
     /// Translates the end of a Wasm `else` control frame.
-    fn translate_end_else(&mut self, frame: ElseControlFrame) -> Result<(), Error> {
+    fn translate_end_else(&mut self, _frame: ElseControlFrame) -> Result<(), Error> {
         todo!()
     }
 
     /// Translates the end of an unreachable Wasm control frame.
-    fn translate_end_unreachable(&mut self, frame: UnreachableControlFrame) -> Result<(), Error> {
+    fn translate_end_unreachable(&mut self, _frame: UnreachableControlFrame) -> Result<(), Error> {
         todo!()
     }
 

crates/wasmi/src/engine/translator/func2/simd/visit.rs

@@ -2,155 +2,155 @@ use super::FuncTranslator;
 use wasmparser::VisitSimdOperator;
 
 impl VisitSimdOperator<'_> for FuncTranslator {
-    fn visit_v128_load(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load8x8_s(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load8x8_s(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load8x8_u(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load8x8_u(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load16x4_s(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load16x4_s(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load16x4_u(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load16x4_u(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load32x2_s(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load32x2_s(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load32x2_u(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load32x2_u(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load8_splat(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load8_splat(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load16_splat(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load16_splat(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load32_splat(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load32_splat(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load64_splat(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load64_splat(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load32_zero(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load32_zero(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load64_zero(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_load64_zero(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_store(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+    fn visit_v128_store(&mut self, _memarg: wasmparser::MemArg) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load8_lane(&mut self, memarg: wasmparser::MemArg, lane: u8) -> Self::Output {
+    fn visit_v128_load8_lane(&mut self, _memarg: wasmparser::MemArg, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load16_lane(&mut self, memarg: wasmparser::MemArg, lane: u8) -> Self::Output {
+    fn visit_v128_load16_lane(&mut self, _memarg: wasmparser::MemArg, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load32_lane(&mut self, memarg: wasmparser::MemArg, lane: u8) -> Self::Output {
+    fn visit_v128_load32_lane(&mut self, _memarg: wasmparser::MemArg, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_load64_lane(&mut self, memarg: wasmparser::MemArg, lane: u8) -> Self::Output {
+    fn visit_v128_load64_lane(&mut self, _memarg: wasmparser::MemArg, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_store8_lane(&mut self, memarg: wasmparser::MemArg, lane: u8) -> Self::Output {
+    fn visit_v128_store8_lane(&mut self, _memarg: wasmparser::MemArg, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_store16_lane(&mut self, memarg: wasmparser::MemArg, lane: u8) -> Self::Output {
+    fn visit_v128_store16_lane(&mut self, _memarg: wasmparser::MemArg, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_store32_lane(&mut self, memarg: wasmparser::MemArg, lane: u8) -> Self::Output {
+    fn visit_v128_store32_lane(&mut self, _memarg: wasmparser::MemArg, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_store64_lane(&mut self, memarg: wasmparser::MemArg, lane: u8) -> Self::Output {
+    fn visit_v128_store64_lane(&mut self, _memarg: wasmparser::MemArg, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_v128_const(&mut self, value: wasmparser::V128) -> Self::Output {
+    fn visit_v128_const(&mut self, _value: wasmparser::V128) -> Self::Output {
         todo!()
     }
 
-    fn visit_i8x16_shuffle(&mut self, lanes: [u8; 16]) -> Self::Output {
+    fn visit_i8x16_shuffle(&mut self, _lanes: [u8; 16]) -> Self::Output {
         todo!()
     }
 
-    fn visit_i8x16_extract_lane_s(&mut self, lane: u8) -> Self::Output {
+    fn visit_i8x16_extract_lane_s(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_i8x16_extract_lane_u(&mut self, lane: u8) -> Self::Output {
+    fn visit_i8x16_extract_lane_u(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_i8x16_replace_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_i8x16_replace_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_i16x8_extract_lane_s(&mut self, lane: u8) -> Self::Output {
+    fn visit_i16x8_extract_lane_s(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_i16x8_extract_lane_u(&mut self, lane: u8) -> Self::Output {
+    fn visit_i16x8_extract_lane_u(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_i16x8_replace_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_i16x8_replace_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_i32x4_extract_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_i32x4_extract_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_i32x4_replace_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_i32x4_replace_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_i64x2_extract_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_i64x2_extract_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_i64x2_replace_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_i64x2_replace_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_f32x4_extract_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_f32x4_extract_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_f32x4_replace_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_f32x4_replace_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_f64x2_extract_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_f64x2_extract_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 
-    fn visit_f64x2_replace_lane(&mut self, lane: u8) -> Self::Output {
+    fn visit_f64x2_replace_lane(&mut self, _lane: u8) -> Self::Output {
         todo!()
     }
 

crates/wasmi/src/engine/translator/func2/stack/control.rs

@@ -23,30 +23,29 @@ pub struct ElseOperands {
     /// The end indices of each `else` operands.
     ends: Vec<usize>,
     /// All operands of all allocated `else` control frames.
-    providers: Vec<Operand>,
+    operands: Vec<Operand>,
 }
 
 impl Reset for ElseOperands {
     fn reset(&mut self) {
         self.ends.clear();
-        self.providers.clear();
+        self.operands.clear();
     }
 }
 
 impl ElseOperands {
     /// Pushes operands for a new Wasm `else` control frame.
     pub fn push(&mut self, operands: impl IntoIterator<Item = Operand>) {
-        self.providers.extend(operands);
-        let end = self.providers.len();
-        let index = self.ends.len();
+        self.operands.extend(operands);
+        let end = self.operands.len();
         self.ends.push(end);
     }
 
     /// Pops the top-most Wasm `else` operands from `self` and returns it.
     pub fn pop(&mut self) -> Option<Drain<Operand>> {
         let end = self.ends.pop()?;
         let start = self.ends.last().copied().unwrap_or(0);
-        Some(self.providers.drain(start..end))
+        Some(self.operands.drain(start..end))
     }
 }
 
@@ -203,7 +202,6 @@ impl ControlStack {
     /// Acquires the target [`ControlFrame`] at the given relative `depth`.
     pub fn acquire_target(&mut self, depth: usize) -> AcquiredTarget {
         let is_root = self.is_root(depth);
-        let height = self.height();
         let frame = self.get_mut(depth);
         if is_root {
             AcquiredTarget::Return(frame)
@@ -274,7 +272,7 @@ impl ControlFrame {
             ControlFrame::Loop(frame) => frame.branch_to(),
             ControlFrame::If(frame) => frame.branch_to(),
             ControlFrame::Else(frame) => frame.branch_to(),
-            ControlFrame::Unreachable(frame) => {
+            ControlFrame::Unreachable(_) => {
                 panic!("invalid query for unreachable control frame: `ControlFrame::branch_to`")
             }
         }
@@ -289,7 +287,7 @@ impl ControlFrame {
             ControlFrame::Loop(frame) => frame.consume_fuel_instr(),
             ControlFrame::If(frame) => frame.consume_fuel_instr(),
             ControlFrame::Else(frame) => frame.consume_fuel_instr(),
-            ControlFrame::Unreachable(frame) => {
+            ControlFrame::Unreachable(_) => {
                 panic!("invalid query for unreachable control frame: `ControlFrame::consume_fuel_instr`")
             }
         }

crates/wasmi/src/engine/translator/func2/stack/mod.rs

@@ -307,11 +307,7 @@ impl Stack {
     /// # Errors
     ///
     /// If the stack height exceeds the maximum height.
-    pub fn push_unreachable(
-        &mut self,
-        ty: BlockType,
-        kind: UnreachableControlFrame,
-    ) -> Result<(), Error> {
+    pub fn push_unreachable(&mut self, kind: UnreachableControlFrame) -> Result<(), Error> {
         self.controls.push_unreachable(kind);
         Ok(())
     }

crates/wasmi/src/engine/translator/func2/stack/operands.rs

@@ -257,14 +257,10 @@ impl OperandStack {
     #[must_use]
     fn operand_to_temp_at(&mut self, index: OperandIdx) -> Option<StackOperand> {
         let operand = self.get_at(index);
-        let ty = match operand {
-            StackOperand::Temp { ty, instr } => return None,
+        match operand {
+            StackOperand::Temp { .. } => return None,
             StackOperand::Immediate { val } => val.ty(),
-            StackOperand::Local {
-                local_index,
-                next_local,
-                prev_local,
-            } => self.locals.ty(local_index),
+            StackOperand::Local { local_index, .. } => self.locals.ty(local_index),
         };
         self.unlink_local(operand);
         self.operands[usize::from(index)] = operand;