Fixes

Author: amigin

macros/src/data_wrapper/generate.rs

@@ -6,10 +6,13 @@ pub fn generate(
 ) -> Result<proc_macro::TokenStream, syn::Error> {
     let struct_name = &ast.ident;
 
-    let (tp, tp_as_str) = crate::utils::extract_type(input_as_string.as_str());
+    let extracted_tp = crate::utils::extract_type(input_as_string.as_str());
 
-    let as_value_fn = tp_as_str.get_as_value_fn();
 
+    
+    let as_value_fn = extracted_tp.get_as_value_fn();
+
+    let tp = &extracted_tp.tp;
 
     let result = quote! {
 

macros/src/utils.rs

@@ -2,26 +2,27 @@ use std::str::FromStr;
 
 
 pub struct ExtractedType<'s> {
-    pub tp: &'s str,
+    pub tp_str: &'s str,
+    pub tp: proc_macro2::TokenStream,
 }
 
 
 impl<'s> ExtractedType<'s> {
 
     pub fn get_type_and_wrapper(&'s self)->(&'s str, bool){
 
-        if let Some(start_index) = self.tp.find('<'){
-            let Some(end_index) = self.tp.find(">") else{
-                return (self.tp, false);
+        if let Some(start_index) = self.tp_str.find('<'){
+            let Some(end_index) = self.tp_str.find(">") else{
+                return (self.tp_str, false);
             };
 
-            let type_str = &self.tp[start_index + 1..end_index].trim();
+            let type_str = &self.tp_str[start_index + 1..end_index].trim();
 
             return (type_str, true);
         }
 
 
-        (self.tp, false)
+        (self.tp_str, false)
     }
 
     pub fn get_as_value_fn(&self)->proc_macro2::TokenStream{
@@ -38,28 +39,30 @@ impl<'s> ExtractedType<'s> {
             }
         }
 
-        let value = format!("as_{}", self.tp);
+        let value = format!("as_{}", tp);
 
         let fn_name =  proc_macro2::TokenStream::from_str(value.as_str()).unwrap();
 
 
+        let tp = &self.tp;
+
         quote::quote! {
             pub fn #fn_name(&self) -> #tp {
                 self.0
-             }
+            }
         }
     }
 }
 
-pub fn extract_type<'s>(input_as_string: &'s str) -> (proc_macro2::TokenStream, ExtractedType<'s>) {
+pub fn extract_type<'s>(input_as_string: &'s str) -> ExtractedType<'s> {
     let open_index = input_as_string.find("(").unwrap();
     let close_index = input_as_string.find(")").unwrap();
 
     let type_str = &input_as_string[open_index + 1..close_index].trim();
 
     let type_tokens = proc_macro2::TokenStream::from_str(type_str);
     match type_tokens {
-        Ok(tokens) => (tokens, ExtractedType { tp: type_str }),
+        Ok(tokens) => ExtractedType { tp_str: type_str, tp: tokens },
         Err(_) => {
             panic!("Invalid type: {}", type_str);
         }