docs: Remove unnecessary code comments

Author: Jon-Becker

crates/vm/src/core/opcodes/mod.rs

@@ -150,16 +150,6 @@ macro_rules! opcodes {
                 /// This macro provides a convenient way to construct a `WrappedOpcode` for a specific
                 /// opcode (`$name`), supporting between 0 and 8 input arguments that implement
                 /// `Into<WrappedInput>`.
-                ///
-                /// # Examples
-                ///
-                /// ```
-                /// // Create an ADD opcode with two inputs
-                /// let add_op = w_add!(value1, value2);
-                ///
-                /// // Create a MSTORE opcode with memory offset and value
-                /// let mstore_op = w_mstore!(offset, value);
-                /// ```
                 #[macro_export]
                 macro_rules! [<w_$name:lower>] {
                     // zero inputs

crates/vm/src/core/opcodes/wrapped.rs

@@ -39,23 +39,6 @@ impl WrappedOpcode {
     /// The depth is calculated as the maximum depth of any input plus 1.
     /// A depth of 1 means the opcode has only raw inputs (or no inputs).
     /// Greater depths indicate a chain of operations.
-    ///
-    /// ```
-    /// use heimdall_vm::core::opcodes::wrapped::{WrappedOpcode, WrappedInput};
-    /// use alloy::primitives::U256;
-    /// use heimdall_vm::ext::lexers::solidity::WrappedOpcode;
-    ///
-    /// // Create a PUSH1 0x01 operation
-    /// let push1 = WrappedOpcode::new(0x60, vec![WrappedInput::Raw(U256::from(1))]);
-    /// assert_eq!(push1.depth(), 1);  // Depth is 1 because it has only raw inputs
-    ///
-    /// // Create an ADD operation that takes the result of two PUSH operations
-    /// let add = WrappedOpcode::new(0x01, vec![
-    ///     WrappedInput::Opcode(push1.clone()),
-    ///     WrappedInput::Opcode(push1.clone())
-    /// ]);
-    /// assert_eq!(add.depth(), 2);  // Depth is 2 because it contains operations with depth 1
-    /// ```
     pub fn depth(&self) -> u32 {
         self.inputs.iter().map(|x| x.depth()).max().unwrap_or(0) + 1
     }
@@ -66,21 +49,6 @@ impl std::fmt::Display for WrappedOpcode {
     ///
     /// The format is: `OPCODENAME(input1, input2, ...)` where each input is
     /// formatted according to its own [`Display`] implementation.
-    ///
-    /// ```
-    /// use heimdall_vm::core::opcodes::wrapped::{WrappedOpcode, WrappedInput};
-    /// use heimdall_vm::ext::lexers::solidity::WrappedOpcode;
-    /// use alloy::primitives::U256;
-    ///
-    /// let push1 = WrappedOpcode::new(0x60, vec![WrappedInput::Raw(U256::from(1))]);
-    /// assert_eq!(push1.to_string(), "PUSH1(1)");
-    ///
-    /// let add = WrappedOpcode::new(0x01, vec![
-    ///     WrappedInput::Opcode(push1.clone()),
-    ///     WrappedInput::Opcode(push1.clone())
-    /// ]);
-    /// assert_eq!(add.to_string(), "ADD(PUSH1(1), PUSH1(1))");
-    /// ```
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
@@ -99,21 +67,6 @@ impl WrappedInput {
     ///
     /// This method is used to calculate the recursive depth of operations
     /// for analysis and optimization purposes.
-    ///
-    /// ```
-    /// use heimdall_vm::core::opcodes::wrapped::WrappedInput;
-    /// use heimdall_vm::ext::lexers::solidity::WrappedOpcode;
-    /// use alloy::primitives::U256;
-    ///
-    /// // Raw inputs have depth 0
-    /// let raw = WrappedInput::Raw(U256::from(42));
-    /// assert_eq!(raw.depth(), 0);
-    ///
-    /// // Opcode inputs have the depth of the operation they contain
-    /// let push1 = WrappedOpcode::new(0x60, vec![WrappedInput::Raw(U256::from(1))]);
-    /// let op_input = WrappedInput::Opcode(push1);
-    /// assert_eq!(op_input.depth(), 1);
-    /// ```
     pub fn depth(&self) -> u32 {
         match self {
             WrappedInput::Raw(_) => 0,
@@ -127,19 +80,6 @@ impl std::fmt::Display for WrappedInput {
     ///
     /// - For [`Raw`] inputs, displays the contained [`U256`] value.
     /// - For [`Opcode`] inputs, recursively formats the contained [`WrappedOpcode`].
-    ///
-    /// ```
-    /// use heimdall_vm::core::opcodes::wrapped::WrappedInput;
-    /// use heimdall_vm::ext::lexers::solidity::WrappedOpcode;
-    /// use alloy::primitives::U256;
-    ///
-    /// let raw = WrappedInput::Raw(U256::from(42));
-    /// assert_eq!(raw.to_string(), "42");
-    ///
-    /// let push1 = WrappedOpcode::new(0x60, vec![WrappedInput::Raw(U256::from(1))]);
-    /// let op_input = WrappedInput::Opcode(push1);
-    /// assert_eq!(op_input.to_string(), "PUSH1(1)");
-    /// ```
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             WrappedInput::Raw(u256) => write!(f, "{u256}"),
@@ -153,19 +93,6 @@ impl From<U256> for WrappedInput {
     ///
     /// This implementation allows for more ergonomic code when creating
     /// [`WrappedInput`]s from raw values.
-    ///
-    /// ```
-    /// use heimdall_vm::core::opcodes::wrapped::WrappedInput;
-    /// use alloy::primitives::U256;
-    ///
-    /// let u256_val = U256::from(42);
-    /// let input: WrappedInput = u256_val.into();
-    ///
-    /// match input {
-    ///     WrappedInput::Raw(val) => assert_eq!(val, U256::from(42)),
-    ///     _ => panic!("Expected Raw variant"),
-    /// }
-    /// ```
     fn from(val: U256) -> Self {
         WrappedInput::Raw(val)
     }
@@ -176,20 +103,6 @@ impl From<WrappedOpcode> for WrappedInput {
     ///
     /// This implementation allows for more ergonomic code when creating
     /// [`WrappedInput`]s from operations.
-    ///
-    /// ```
-    /// use heimdall_vm::core::opcodes::wrapped::WrappedInput;
-    /// use heimdall_vm::ext::lexers::solidity::WrappedOpcode;
-    /// use alloy::primitives::U256;
-    ///
-    /// let push1 = WrappedOpcode::new(0x60, vec![WrappedInput::Raw(U256::from(1))]);
-    /// let input: WrappedInput = push1.clone().into();
-    ///
-    /// match input {
-    ///     WrappedInput::Opcode(op) => assert_eq!(op, push1),
-    ///     _ => panic!("Expected Opcode variant"),
-    /// }
-    /// ```
     fn from(val: WrappedOpcode) -> Self {
         WrappedInput::Opcode(val)
     }