Refactor some code into the common crate

crates/format/src/case.rs

@@ -1,7 +1,8 @@
 use serde::Deserialize;
 
+use revive_dt_common::macros::define_wrapper_type;
+
 use crate::{
-    define_wrapper_type,
     input::{Expected, Input},
     mode::Mode,
 };
@@ -45,5 +46,5 @@ impl Case {
 define_wrapper_type!(
     /// A wrapper type for the index of test cases found in metadata file.
     #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    CaseIdx(usize);
+    pub struct CaseIdx(usize);
 );

crates/format/src/input.rs

@@ -11,9 +11,10 @@ use alloy_primitives::{FixedBytes, utils::parse_units};
 use semver::VersionReq;
 use serde::{Deserialize, Serialize};
 
+use revive_dt_common::macros::define_wrapper_type;
 use revive_dt_node_interaction::EthereumNode;
 
-use crate::{define_wrapper_type, metadata::ContractInstance};
+use crate::metadata::ContractInstance;
 
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 pub struct Input {
@@ -84,7 +85,7 @@ pub enum Method {
 
 define_wrapper_type!(
     #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    EtherValue(U256);
+    pub struct EtherValue(U256);
 );
 
 impl Serialize for EtherValue {

crates/format/src/lib.rs

@@ -3,6 +3,5 @@
 pub mod case;
 pub mod corpus;
 pub mod input;
-pub mod macros;
 pub mod metadata;
 pub mod mode;

crates/format/src/macros.rs

@@ -1,106 +0,0 @@
-/// Defines wrappers around types.
-///
-/// For example, the macro invocation seen below:
-///
-/// ```rust,ignore
-/// define_wrapper_type!(CaseId => usize);
-/// ```
-///
-/// Would define a wrapper type that looks like the following:
-///
-/// ```rust,ignore
-/// pub struct CaseId(usize);
-/// ```
-///
-/// And would also implement a number of methods on this type making it easier
-/// to use.
-///
-/// These wrapper types become very useful as they make the code a lot easier
-/// to read.
-///
-/// Take the following as an example:
-///
-/// ```rust,ignore
-/// struct State {
-///     contracts: HashMap<usize, HashMap<String, Vec<u8>>>
-/// }
-/// ```
-///
-/// In the above code it's hard to understand what the various types refer to or
-/// what to expect them to contain.
-///
-/// With these wrapper types we're able to create code that's self-documenting
-/// in that the types tell us what the code is referring to. The above code is
-/// transformed into
-///
-/// ```rust,ignore
-/// struct State {
-///     contracts: HashMap<CaseId, HashMap<ContractName, ContractByteCode>>
-/// }
-/// ```
-#[macro_export]
-macro_rules! define_wrapper_type {
-    (
-        $(#[$meta: meta])*
-        $ident: ident($ty: ty) $(;)?
-    ) => {
-        $(#[$meta])*
-        pub struct $ident($ty);
-
-        impl $ident {
-            pub fn new(value: $ty) -> Self {
-                Self(value)
-            }
-
-            pub fn new_from<T: Into<$ty>>(value: T) -> Self {
-                Self(value.into())
-            }
-
-            pub fn into_inner(self) -> $ty {
-                self.0
-            }
-
-            pub fn as_inner(&self) -> &$ty {
-                &self.0
-            }
-        }
-
-        impl AsRef<$ty> for $ident {
-            fn as_ref(&self) -> &$ty {
-                &self.0
-            }
-        }
-
-        impl AsMut<$ty> for $ident {
-            fn as_mut(&mut self) -> &mut $ty {
-                &mut self.0
-            }
-        }
-
-        impl std::ops::Deref for $ident {
-            type Target = $ty;
-
-            fn deref(&self) -> &Self::Target {
-                &self.0
-            }
-        }
-
-        impl std::ops::DerefMut for $ident {
-            fn deref_mut(&mut self) -> &mut Self::Target {
-                &mut self.0
-            }
-        }
-
-        impl From<$ty> for $ident {
-            fn from(value: $ty) -> Self {
-                Self(value)
-            }
-        }
-
-        impl From<$ident> for $ty {
-            fn from(value: $ident) -> Self {
-                value.0
-            }
-        }
-    };
-}

crates/format/src/metadata.rs

@@ -9,9 +9,10 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 
+use revive_dt_common::macros::define_wrapper_type;
+
 use crate::{
     case::Case,
-    define_wrapper_type,
     mode::{Mode, SolcMode},
 };
 
@@ -217,18 +218,22 @@ define_wrapper_type!(
     /// Represents a contract instance found a metadata file.
     ///
     /// Typically, this is used as the key to the "contracts" field of metadata files.
-    #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    #[derive(
+        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
+    )]
     #[serde(transparent)]
-    ContractInstance(String);
+    pub struct ContractInstance(String);
 );
 
 define_wrapper_type!(
     /// Represents a contract identifier found a metadata file.
     ///
     /// A contract identifier is the name of the contract in the source code.
-    #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    #[derive(
+        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
+    )]
     #[serde(transparent)]
-    ContractIdent(String);
+    pub struct ContractIdent(String);
 );
 
 /// Represents an identifier used for contracts.