update

Cargo.toml

@@ -20,7 +20,6 @@ path = "src/lib.rs"
 [dependencies]
 fluence-sdk-macro = { path = "crates/macro", version = "=0.2.4" }
 fluence-sdk-main = { path = "crates/main", version = "=0.2.4" }
-safe-transmute = "0.11.0"
 
 [features]
 # Print some internal logs by log_utf8_string

crates/wit/src/parsed_type/fn_epilog.rs

@@ -111,8 +111,8 @@ fn generate_epilog(ty: &Option<ParsedType>) -> proc_macro2::TokenStream {
             quote! {
                 #vector_serializer
                 let result = #generated_serializer_ident(result);
-                fluence::internal::set_result_ptr(result.as_ptr() as _);
+                fluence::internal::set_result_ptr(result.0 as _);
-                fluence::internal::set_result_size(result.len() as _);
+                fluence::internal::set_result_size(result.1 as _);
                 std::mem::forget(result);
             }
         }

crates/wit/src/parsed_type/foreign_mod_arg.rs

@@ -28,9 +28,12 @@ impl ForeignModArgGlueCodeGenerator for ParsedType {
         let arg = crate::new_ident!(format!("arg_{}", arg_start_id));
 
         match self {
-            ParsedType::Vector(_) | ParsedType::Utf8String => {
+            ParsedType::Utf8String => {
                 quote! { #arg.as_ptr() as _, #arg.len() as _ }
             }
+            ParsedType::Vector(_) => {
+                quote! { #arg.0 as _, #arg.1 as _ }
+            }
             ParsedType::Record(_) => quote! {
                 #arg.__fce_generated_serialize() as _
             },

crates/wit/src/parsed_type/vector_utils.rs

@@ -24,7 +24,7 @@ pub(crate) fn generate_vector_serializer(
     let values_serializer = match value_ty {
         ParsedType::Boolean => {
             quote! {
-                fluence::internal::transmute_vec::<i32, u8>(arg).unwrap()
+                unimplemented!()
             }
         }
         ParsedType::I8
@@ -36,7 +36,8 @@ pub(crate) fn generate_vector_serializer(
         | ParsedType::U32
         | ParsedType::U64 => {
             quote! {
-                fluence::internal::transmute_vec::<#value_ty, u8>(arg).unwrap()
+                let arg = std::mem::ManuallyDrop::new(arg);
+                (arg.as_ptr() as _, arg.len() as _)
             }
         }
         ParsedType::F32 => {
@@ -46,7 +47,8 @@ pub(crate) fn generate_vector_serializer(
                     result.push(value.to_bits());
                 }
 
-                fluence::internal::transmute_vec::<u32, u8>(result).unwrap()
+                let result = std::mem::ManuallyDrop::new(result);
+                (result.as_ptr() as _, (4 * result.len()) as _)
             }
         }
         ParsedType::F64 => {
@@ -56,7 +58,8 @@ pub(crate) fn generate_vector_serializer(
                     result.push(value.to_bits());
                 }
 
-                fluence::internal::transmute_vec::<u64, u8>(result).unwrap()
+                let result = std::mem::ManuallyDrop::new(result);
+                (result.as_ptr() as _, (8 * result.len()) as _)
             }
         }
         ParsedType::Utf8String => {
@@ -64,11 +67,13 @@ pub(crate) fn generate_vector_serializer(
                 let mut result: Vec<u32> = Vec::with_capacity(arg.len());
 
                 for value in arg {
+                    let value = std::mem::ManuallyDrop::new(value);
                     result.push(value.as_ptr() as _);
                     result.push(value.len() as _);
                 }
 
-                fluence::internal::transmute_vec::<u32, u8>(result).unwrap()
+                let result = std::mem::ManuallyDrop::new(result);
+                (result.as_ptr() as _, (4 * result.len()) as _)
             }
         }
         ParsedType::Vector(ty) => {
@@ -81,12 +86,13 @@ pub(crate) fn generate_vector_serializer(
 
                 let mut result: Vec<u32> = Vec::with_capacity(2 * arg.len());
                 for value in arg {
-                    let value = std::mem::ManuallyDrop::new(#serializer_ident(value));
+                    let (ptr, size) = #serializer_ident(value);
-                    result.push(value.as_ptr() as _);
+                    result.push(ptr as _);
-                    result.push(value.len() as _);
+                    result.push(size as _);
                 }
 
-                fluence::internal::transmute_vec::<u32, u8>(result).unwrap()
+                let result = std::mem::ManuallyDrop::new(result);
+                (result.as_ptr() as _, (4 * result.len()) as _)
             }
         }
 
@@ -98,7 +104,8 @@ pub(crate) fn generate_vector_serializer(
                     result.push(value.__fce_generated_serialize() as _);
                 }
 
-                fluence::internal::transmute_vec::<u32, u8>(result).unwrap()
+                let result = std::mem::ManuallyDrop::new(result);
+                (result.as_ptr() as _, (4 * result.len()) as _)
             }
         }
     };
@@ -106,11 +113,7 @@ pub(crate) fn generate_vector_serializer(
     let arg = crate::new_ident!(arg_name);
 
     quote! {
-        unsafe fn #arg(arg: Vec<#value_ty>) -> Vec<u8> {
+        unsafe fn #arg(arg: Vec<#value_ty>) -> (u32, u32) {
-            if arg.is_empty() {
-                return vec![];
-            }
-
             #values_serializer
         }
     }
@@ -125,24 +128,36 @@ pub(crate) fn generate_vector_deserializer(
     let values_deserializer = match value_ty {
         ParsedType::Boolean => {
             quote! {
-                fluence::internal::transmute_vec::<u8, i32>(arg).unwrap()
+                unimplemented!()
             }
         }
         ParsedType::F32 => {
             quote! {
-                let mut arg = fluence::internal::transmute_vec::<u8, u32>(arg).unwrap();
+                let mut arg: Vec<u64> = Vec::from_raw_parts(offset as _, size as _, size as _);
-                arg.into_iter().map(f32::from_bits).collect::<Vec<_>>()
+                let mut result = Vec::with_capacity(arg.len());
+
+                for value in arg {
+                    result.push(f32::from_bits(value as _));
+                }
+
+                result
             }
         }
         ParsedType::F64 => {
             quote! {
-                let mut arg = fluence::internal::transmute_vec::<u8, u64>(arg).unwrap();
+                let mut arg: Vec<u64> = Vec::from_raw_parts(offset as _, size as _, size as _);
-                arg.into_iter().map(f64::from_bits).collect::<Vec<_>>()
+                let mut result = Vec::with_capacity(arg.len());
+
+                for value in arg {
+                    result.push(f64::from_bits(value as _));
+                }
+
+                result
             }
         }
         ParsedType::Utf8String => {
             quote! {
-                let mut arg = fluence::internal::transmute_vec::<u8, u32>(arg).unwrap();
+                let mut arg: Vec<u64> = Vec::from_raw_parts(offset as _, size as _, size as _);
                 let mut arg = arg.into_iter();
                 let mut result = Vec::with_capacity(arg.len() / 2);
                 while let Some(offset) = arg.next() {
@@ -162,7 +177,7 @@ pub(crate) fn generate_vector_deserializer(
             quote! {
                 #inner_vector_deserializer
 
-                let mut arg = fluence::internal::transmute_vec::<u8, u32>(arg).unwrap();
+                let mut arg: Vec<u64> = Vec::from_raw_parts(offset as _, size as _, size as _);
                 let mut result = Vec::with_capacity(arg.len());
 
                 let mut arg = arg.into_iter();
@@ -180,7 +195,7 @@ pub(crate) fn generate_vector_deserializer(
             let record_name_ident = crate::new_ident!(record_name);
 
             quote! {
-                let arg = fluence::internal::transmute_vec::<u8, u32>(arg).unwrap();
+                let mut arg: Vec<u64> = Vec::from_raw_parts(offset as _, size as _, size as _);
                 let mut result = Vec::with_capacity(arg.len());
 
                 for offset in arg {
@@ -191,20 +206,23 @@ pub(crate) fn generate_vector_deserializer(
                 result
             }
         }
-        v => {
+        _ => {
             quote! {
-                fluence::internal::transmute_vec::<u8, #v>(arg).unwrap()
+                let mut arg: Vec<u64> = Vec::from_raw_parts(offset as _, size as _, size as _);
+                let mut result = Vec::with_capacity(arg.len());
+
+                for value in arg {
+                    result.push(value as _);
+                }
+
+                result
             }
         }
     };
 
     quote! {
         unsafe fn #arg(offset: u32, size: u32) -> Vec<#value_ty> {
-            let arg: Vec<u8> = Vec::from_raw_parts(offset as _, size as _, size as _);
+            let size = size / 8;
-            if arg.is_empty() {
-                return vec![];
-            }
-
             #values_deserializer
         }
     }

crates/wit/src/token_stream_generator/record_generator/record_deserializer.rs

@@ -104,18 +104,18 @@ impl RecordDeserializerGlueCodeGenerator for fce_ast_types::AstRecordItem {
                     }
                 }
                 ParsedType::Vector(ty) => {
-                    let ptr_id = value_id;
-                    let size_id = value_id + 1;
-                    value_id += 1;
-
                     let generated_deserializer_name =
-                        String::from("__fce_generated_vec_deserializer");
+                        format!("__fce_generated_vec_deserializer_{}", value_id);
                     let generated_deserializer_ident = new_ident!(generated_deserializer_name);
                     let vector_deserializer = crate::parsed_type::generate_vector_deserializer(
                         ty,
                         &generated_deserializer_name,
                     );
 
+                    let ptr_id = value_id;
+                    let size_id = value_id + 1;
+                    value_id += 1;
+
                     quote! {
                         #vector_deserializer
                         let #field = unsafe { #generated_deserializer_ident(raw_record[#ptr_id] as _, raw_record[#size_id] as _) };

crates/wit/src/token_stream_generator/record_generator/record_serializer.rs

@@ -60,9 +60,8 @@ impl RecordSerializerGlueCodeGenerator for fce_ast_types::AstRecordItem {
                     quote::quote! {
                         #vector_serializer
                         let #serialized_field_ident = unsafe { #generated_serializer_ident(#field_ident) };
-                        raw_record.push(#serialized_field_ident.as_ptr() as _);
+                        raw_record.push(#serialized_field_ident.0 as _);
-                        raw_record.push(#serialized_field_ident.len() as _);
+                        raw_record.push(#serialized_field_ident.1 as _);
-                        std::mem::forget(#serialized_field_ident);
                     }
                 }
                 ParsedType::Record(_) => {

src/lib.rs

@@ -81,5 +81,4 @@ pub mod internal {
     pub use fluence_sdk_main::get_result_size;
     pub use fluence_sdk_main::set_result_ptr;
     pub use fluence_sdk_main::set_result_size;
-    pub use safe_transmute::transmute_vec;
 }