Review changes: simplify get or insert, use common fmt

Author: grandizzy

crates/cheatcodes/src/evm.rs

@@ -13,7 +13,7 @@ use alloy_rlp::Decodable;
 use alloy_sol_types::SolValue;
 use foundry_common::{
     fs::{read_json_file, write_json_file},
-    slot_identifier::{SlotIdentifier, SlotInfo, format_value},
+    slot_identifier::{SlotIdentifier, SlotInfo},
 };
 use foundry_evm_core::{
     ContextExt,
@@ -37,6 +37,7 @@ use std::{
 };
 
 mod record_debug_step;
+use foundry_common::fmt::format_token_raw;
 use record_debug_step::{convert_call_trace_to_debug_step, flatten_call_trace};
 use serde::Serialize;
 
@@ -189,8 +190,8 @@ impl Display for AccountStateDiffs {
                                 "@ {slot} ({}, {}): {} → {}",
                                 slot_info.label,
                                 slot_info.slot_type.dyn_sol_type,
-                                format_value(&decoded.previous_value),
-                                format_value(&decoded.new_value)
+                                format_token_raw(&decoded.previous_value),
+                                format_token_raw(&decoded.new_value)
                             )?;
                         } else {
                             // Have slot info but no decoded values - show raw hex values
@@ -866,9 +867,7 @@ impl Cheatcode for startStateDiffRecordingCall {
         let Self {} = self;
         state.recorded_account_diffs_stack = Some(Default::default());
         // Enable mapping recording to track mapping slot accesses
-        if state.mapping_slots.is_none() {
-            state.mapping_slots = Some(Default::default());
-        }
+        state.mapping_slots.get_or_insert_default();
         Ok(Default::default())
     }
 }

crates/cheatcodes/src/evm/mapping.rs

@@ -10,9 +10,7 @@ use revm::{
 impl Cheatcode for startMappingRecordingCall {
     fn apply(&self, state: &mut Cheatcodes) -> Result {
         let Self {} = self;
-        if state.mapping_slots.is_none() {
-            state.mapping_slots = Some(Default::default());
-        }
+        state.mapping_slots.get_or_insert_default();
         Ok(Default::default())
     }
 }

crates/common/src/slot_identifier.rs

@@ -6,6 +6,7 @@
 use crate::mapping_slots::MappingSlots;
 use alloy_dyn_abi::{DynSolType, DynSolValue};
 use alloy_primitives::{B256, U256, hex};
+use foundry_common_fmt::format_token_raw;
 use foundry_compilers::artifacts::{Storage, StorageLayout, StorageType};
 use serde::Serialize;
 use std::{str::FromStr, sync::Arc};
@@ -175,8 +176,8 @@ impl Serialize for DecodedSlotValues {
         use serde::ser::SerializeStruct;
 
         let mut state = serializer.serialize_struct("DecodedSlotValues", 2)?;
-        state.serialize_field("previousValue", &format_value(&self.previous_value))?;
-        state.serialize_field("newValue", &format_value(&self.new_value))?;
+        state.serialize_field("previousValue", &format_token_raw(&self.previous_value))?;
+        state.serialize_field("newValue", &format_token_raw(&self.new_value))?;
         state.end()
     }
 }
@@ -586,7 +587,7 @@ impl SlotIdentifier {
                 && let Ok(sol_type) = DynSolType::parse(key_type_label)
                 && let Ok(decoded) = sol_type.abi_decode(&key.0)
             {
-                let decoded_key_str = format_value(&decoded);
+                let decoded_key_str = format_token_raw(&decoded);
                 decoded_keys.push(decoded_key_str.clone());
                 label = format!("{label}[{decoded_key_str}]");
             } else {
@@ -663,31 +664,6 @@ fn get_array_base_indices(dyn_type: &DynSolType) -> String {
     }
 }
 
-/// Formats a [`DynSolValue`] as a raw string without type information and only the value itself.
-pub fn format_value(value: &DynSolValue) -> String {
-    match value {
-        DynSolValue::Bool(b) => b.to_string(),
-        DynSolValue::Int(i, _) => i.to_string(),
-        DynSolValue::Uint(u, _) => u.to_string(),
-        DynSolValue::FixedBytes(bytes, size) => hex::encode_prefixed(&bytes.0[..*size]),
-        DynSolValue::Address(addr) => addr.to_string(),
-        DynSolValue::Function(func) => func.as_address_and_selector().1.to_string(),
-        DynSolValue::Bytes(bytes) => hex::encode_prefixed(bytes),
-        DynSolValue::String(s) => s.clone(),
-        DynSolValue::Array(values) | DynSolValue::FixedArray(values) => {
-            let formatted: Vec<String> = values.iter().map(format_value).collect();
-            format!("[{}]", formatted.join(", "))
-        }
-        DynSolValue::Tuple(values) => {
-            let formatted: Vec<String> = values.iter().map(format_value).collect();
-            format!("({})", formatted.join(", "))
-        }
-        DynSolValue::CustomStruct { name: _, prop_names: _, tuple } => {
-            format_value(&DynSolValue::Tuple(tuple.clone()))
-        }
-    }
-}
-
 /// Checks if a given type label represents a struct type.
 pub fn is_struct(s: &str) -> bool {
     s.starts_with("struct ")