rename AssocTypeConversions to TypeConverter

3 files changed, 32 insertions, 32 deletions

diff --git a/src/lib.rs b/src/lib.rs
index 5e3653d..8fa1294 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -44,7 +44,7 @@ use crate::parse_trait_sig::SignatureChanges;
 use crate::parse_trait_sig::TypeTransform;
 use crate::syn_utils::iter_path;
 use crate::syn_utils::trait_bounds;
-use crate::transform::AssocTypeConversions;
+use crate::transform::TypeConverter;
 
 mod parse_assoc_type;
 mod parse_trait_sig;
@@ -66,7 +66,7 @@ pub fn dynamize(_attr: TokenStream, input: TokenStream) -> TokenStream {
 
     let mut objectifiable_methods: Vec<(Signature, SignatureChanges)> = Vec::new();
 
-    let mut assoc_type_conversions = AssocTypeConversions::default();
+    let mut type_converter = TypeConverter::default();
 
     for item in &original_trait.items {
         if let TraitItem::Type(assoc_type) = item {
@@ -82,7 +82,9 @@ pub fn dynamize(_attr: TokenStream, input: TokenStream) -> TokenStream {
                     )
                 }
                 Ok((ident, type_)) => {
-                    assoc_type_conversions.0.insert(ident.clone(), type_);
+                    type_converter
+                        .assoc_type_conversions
+                        .insert(ident.clone(), type_);
                 }
             }
         }
@@ -91,7 +93,7 @@ pub fn dynamize(_attr: TokenStream, input: TokenStream) -> TokenStream {
     for item in &original_trait.items {
         if let TraitItem::Method(method) = item {
             let mut signature = method.sig.clone();
-            match parse_trait_signature(&mut signature, &assoc_type_conversions) {
+            match parse_trait_signature(&mut signature, &type_converter) {
                 Err((_, MethodParseError::NonDispatchableMethod)) => continue,
                 Err((span, MethodParseError::UnconvertibleAssocType)) => {
                     return abort!(
diff --git a/src/parse_trait_sig.rs b/src/parse_trait_sig.rs
index 4c0b4fd..8f578f7 100644
--- a/src/parse_trait_sig.rs
+++ b/src/parse_trait_sig.rs
@@ -9,7 +9,7 @@ use syn::{Ident, Signature, TypeImplTrait};
 use crate::match_assoc_type;
 use crate::parse_assoc_type::BoxType;
 use crate::syn_utils::{iter_type, trait_bounds, TypeOrPath};
-use crate::transform::{dynamize_function_bounds, AssocTypeConversions, TransformError};
+use crate::transform::{dynamize_function_bounds, TransformError, TypeConverter};
 
 #[derive(Debug, Clone)]
 pub enum TypeTransform {
@@ -49,7 +49,7 @@ pub struct SignatureChanges {
 
 pub fn parse_trait_signature(
     signature: &mut Signature,
-    assoc_type_conversions: &AssocTypeConversions,
+    type_converter: &TypeConverter,
 ) -> Result<SignatureChanges, (Span, MethodParseError)> {
     if is_non_dispatchable(signature) {
         return Err((signature.span(), MethodParseError::NonDispatchableMethod));
@@ -67,11 +67,10 @@ pub fn parse_trait_signature(
         }
     }
 
-    let type_param_transforms =
-        dynamize_function_bounds(&mut signature.generics, assoc_type_conversions)?;
+    let type_param_transforms = dynamize_function_bounds(&mut signature.generics, type_converter)?;
 
     let return_type = match &mut signature.output {
-        ReturnType::Type(_, og_type) => match assoc_type_conversions.parse_type_path(og_type) {
+        ReturnType::Type(_, og_type) => match type_converter.convert_type(og_type) {
             Ok(ret_type) => ret_type,
             Err(TransformError::UnconvertibleAssocType(span)) => {
                 return Err((span, MethodParseError::UnconvertibleAssocType));
@@ -147,7 +146,7 @@ mod tests {
         parse_trait_sig::{
             parse_trait_signature, MethodParseError, SignatureChanges, TypeTransform,
         },
-        transform::AssocTypeConversions,
+        transform::TypeConverter,
     };
 
     #[test]
@@ -173,14 +172,14 @@ mod tests {
         })
         .unwrap();
 
-        let mut assoc_type_map = AssocTypeConversions::default();
+        let mut type_converter = TypeConverter::default();
         let ident = format_ident!("A");
         let dest_inner = Type::Verbatim(quote! {Example});
         let dest = DestType::Into(&dest_inner);
-        assoc_type_map.0.insert(ident, dest);
+        type_converter.assoc_type_conversions.insert(ident, dest);
 
         assert!(matches!(
-            parse_trait_signature(&mut type1.sig, &assoc_type_map),
+            parse_trait_signature(&mut type1.sig, &type_converter),
             Ok(SignatureChanges {
                 return_type: TypeTransform::Into,
                 ..
diff --git a/src/transform.rs b/src/transform.rs
index 4625f4c..47e27a6 100644
--- a/src/transform.rs
+++ b/src/transform.rs
@@ -15,7 +15,9 @@ use crate::{
 };
 
 #[derive(Default)]
-pub struct AssocTypeConversions<'a>(pub HashMap<Ident, DestType<'a>>);
+pub struct TypeConverter<'a> {
+    pub assoc_type_conversions: HashMap<Ident, DestType<'a>>,
+}
 
 pub enum TransformError {
     UnconvertibleAssocType(Span),
@@ -39,8 +41,8 @@ fn is_supported_collection_map(ident: &Ident) -> bool {
     ident == "HashMap" || ident == "BTreeMap"
 }
 
-impl AssocTypeConversions<'_> {
-    pub fn parse_type_path(&self, type_: &mut Type) -> Result<TypeTransform, TransformError> {
+impl TypeConverter<'_> {
+    pub fn convert_type(&self, type_: &mut Type) -> Result<TypeTransform, TransformError> {
         if !iter_type(type_).any(match_assoc_type) {
             return Ok(TypeTransform::NoOp);
         }
@@ -69,8 +71,7 @@ impl AssocTypeConversions<'_> {
                                             if binding.ident == "Item"
                                                 && iter_type(&binding.ty).any(match_assoc_type)
                                             {
-                                                let inner =
-                                                    self.parse_type_path(&mut binding.ty)?;
+                                                let inner = self.convert_type(&mut binding.ty)?;
                                                 let box_type = BoxType {
                                                     inner: quote! {#elem},
                                                     placeholder_lifetime: true,
@@ -96,7 +97,7 @@ impl AssocTypeConversions<'_> {
                 if path.segments.len() == 2 {
                     let ident = &path.segments.last().unwrap().ident;
                     let dest_type = self
-                        .0
+                        .assoc_type_conversions
                         .get(ident)
                         .ok_or_else(|| TransformError::UnconvertibleAssocType(ident.span()))?;
                     *type_ = dest_type.get_dest();
@@ -113,13 +114,11 @@ impl AssocTypeConversions<'_> {
                                 if (last_seg.ident == "Option" && path_len == 1)
                                     || last_seg.ident == "Result"
                                 {
-                                    return Ok(TypeTransform::Map(
-                                        self.parse_type_path(arg)?.into(),
-                                    ));
+                                    return Ok(TypeTransform::Map(self.convert_type(arg)?.into()));
                                 } else if is_supported_collection(&last_seg.ident) && path_len == 1
                                 {
                                     return Ok(TypeTransform::Collection(
-                                        self.parse_type_path(arg)?.into(),
+                                        self.convert_type(arg)?.into(),
                                     ));
                                 }
                             }
@@ -134,13 +133,13 @@ impl AssocTypeConversions<'_> {
                             {
                                 if last_seg.ident == "Result" {
                                     return Ok(TypeTransform::Result(
-                                        self.parse_type_path(arg1)?.into(),
-                                        self.parse_type_path(arg2)?.into(),
+                                        self.convert_type(arg1)?.into(),
+                                        self.convert_type(arg2)?.into(),
                                     ));
                                 } else if is_supported_collection_map(&last_seg.ident) {
                                     return Ok(TypeTransform::CollectionMap(
-                                        self.parse_type_path(arg1)?.into(),
-                                        self.parse_type_path(arg2)?.into(),
+                                        self.convert_type(arg1)?.into(),
+                                        self.convert_type(arg2)?.into(),
                                     ));
                                 }
                             }
@@ -158,7 +157,7 @@ impl AssocTypeConversions<'_> {
 
 pub fn dynamize_function_bounds(
     generics: &mut Generics,
-    assoc_type_conversions: &AssocTypeConversions,
+    type_converter: &TypeConverter,
 ) -> Result<HashMap<Ident, Vec<TypeTransform>>, (Span, MethodParseError)> {
     let mut type_param_transforms = HashMap::new();
 
@@ -167,7 +166,7 @@ pub fn dynamize_function_bounds(
             if let TypeParamBound::Trait(bound) = bound {
                 dynamize_trait_bound(
                     bound,
-                    assoc_type_conversions,
+                    type_converter,
                     &type_param.ident,
                     &mut type_param_transforms,
                 )?;
@@ -184,7 +183,7 @@ pub fn dynamize_function_bounds(
                             if let TypeParamBound::Trait(bound) = bound {
                                 dynamize_trait_bound(
                                     bound,
-                                    assoc_type_conversions,
+                                    type_converter,
                                     ident,
                                     &mut type_param_transforms,
                                 )?;
@@ -226,7 +225,7 @@ pub fn dynamize_function_bounds(
 
 fn dynamize_trait_bound(
     bound: &mut TraitBound,
-    assoc_type_conversions: &AssocTypeConversions,
+    type_converter: &TypeConverter,
     type_ident: &Ident,
     type_param_transforms: &mut HashMap<Ident, Vec<TypeTransform>>,
 ) -> Result<(), (Span, MethodParseError)> {
@@ -237,7 +236,7 @@ fn dynamize_trait_bound(
             if segment.ident == "Fn" || segment.ident == "FnOnce" || segment.ident == "FnMut" {
                 let mut transforms = Vec::new();
                 for input_type in &mut args.inputs {
-                    match assoc_type_conversions.parse_type_path(input_type) {
+                    match type_converter.convert_type(input_type) {
                         Ok(ret_type) => {
                             transforms.push(ret_type);
                         }